Late 60’s and early 70’s Xero was a major player in the office automation space. Innovative work on user interfaces was happening at Rand Corporation(JOSS, Tablets, GRAIL), Stanford Research Institute (Doug Englebart, Personal Interactive Computing, Mouse etc) and MIT/Lincoln Laboratories (Ivan Sutherland / Sketchpad). Xerox gave Alan Kay and his team at their Palo Alto Research Centre (PARC) free reign to explore human computer interaction. Alan had worked on ARPANET and did a PhD on the FLEX machine, a precursor to a truly personal computer. He conceived the “Dynabook” which conceptually defined a tablet (think iPad, but easier for the user to program and tailor) in 1968!

Amazing things came out of PARC, including:

Object oriented programming for UI and general purposes
Smalltalk (still one of the best, purest, easiest to learn and productive general purpose languages available today)
Keyword syntax facilitating domain / application specific languages
Just in Time Compilation (JIT) and Virtual machine execution of bytecodes allowing systems to be ported easily across hardware
Integrated Development Environment (IDE ) with introspection
Bitmapped displays with graphics and fonts
Image storing state of system allowing easy and instant persist/restore and continuation of work
Model View Controller (MVC) paradigm for separation of domain model, business logic and user interface
Windows, Icons, Mouse and Pointer (WIMP) paradigm with overlapping, resizeable windows and the whole Graphical User Interface
Text, Image and Document editing with What you See is What you Get (WYSIWYG)
Laser printing
Ethernet

We owe these pioneers a major debt of gratitude! Subsequent developments include:

GUIs at Apple (licensed from Xerox) then Ms Windows (Imitated)
Objective C, the major systems language at Apple (Smalltalk ideas and class libraries on top of C) - the precursor of Swift
Object oriented databases
Office suites - Charles Simonyi did Bravo at PARC on the Alto system, the first WYSIWYG document editing system. He later spent 20+ yrs at Microsoft and created Word and Excel
OO in general, Smalltalk being a major influence on Java, Javascript, Ruby, Eiffel, Dart and many other languages. It is a direct ancestor of Squeak, Pharo, Amber and Newspeak
eXtreme & Pair programming (Kent Beck, Ward Cunningham) and aspects of Agile Development
Live programming/ debugging
Test Driven Development (SUnit, Kent Beck)
Agile Visualisation (Roassal)
Moldable Tools (Tudor Girba, GTools)
EToys and Scratch visual programming for children

I saw Smalltalk ideas in the 1981 Byte article, got hands on and seduced in 1991, and we have used it ever since in our products and tools. Capers-Jones 2017 research confirms Smalltalk still offers a 2-3x productivity improvement over mainstream languages. Vive la difference!

#OOP #Smalltalk #Softwareengineering #Code #ui

Many organisations still have armies of developers grinding away writing Create, Read, Update, Delete (*CRUD), enquire and report user interfaces and business logic - even in “Agile” projects! With a complex domain model, it can easily consume more than 60% of project effort. Indeed, some administrative systems are nearly 100% CRUD!

One solution is to resort to low-code or no-code tools, but organisations resist them for a variety of reasons, including lack of standards, limited skill availability, strategic risk and the fact that many of these only work well in narrow use cases.

It is really important in stakeholder facing applications and websites to have really good user interfaces, so what to do? One solution we have practiced for over two decades, and adapted for the web and mobile, is to have a domain driven user interface which exploits patterns for the commonly required functions.

Patterns consist of UI code templates which provide layout, controls and common business logic. They have placeholders where the specifics of the entity / concept to be captured, edited, updated or deleted etc. are plugged in. The domain specifics (Concepts, Relationships, Properties) are provided to the application as models which are accessible at generation or run time.

For statically bound environments (e.g. C++, Java, C# etc.) the customisation of a pattern with domain specifics can be done at compile time. In effect many interfaces conforming to the pattern are generated into the production application. For dynamically bound environments (e.g. Smalltalk, Python, JavaScript) the generation can even be done at runtime, effectively serving the code to the client where it will execute through interpretation.

This approach has numerous advantages, including:

Major reductions in code base size and hence effort in development and maintenance
Consistency of user interface and logic produced across developers and applications
Higher quality since the patterns can be developed by expert developers and thoroughly tested
Reduced time to market and greater agility. In the case of late bound environments it is even possible to extend the domain model at runtime and have the interface adapt immediately without any deployment
Massive reductions in effort when user interface refreshes are required (e.g. the latest / greatest JavaScript framework makes a new style “required”)

If you would like to see a talk and demonstration of this in action, you can watch the video here.

If you would like to skill up on the latest in Application and Solution Architecture thinking, take a look at our upcoming course: Techniques and Deliverables of Application and Solution Architecture.

#agile #SolutionArchitecture #DomainDriven #SoftwareDesign #Patterns

Lasting Impact of the Little Language that Could: Smalltalk turns 50

Zero CRUD* with Domain Models and Patterns