home babyUML

A laboratory for exploring
a New Discipline of Programming

(previously the IS21C project)

The goal of the BabyUML project is to increase my confidence in my programs. The keywords are simplicity and leverage. Simplicity helps me to think clearly and a reader to understand and audit my code (my peers are very good at catching my blunders). Leverage lets me say more with less. The end result shall be a new interactive development with appropriate languages and tools for supporting high level abstractions.

The essence of object orientation is that objects interact to produce some desired result. Yet current programming languages are focused on individual objects as they are specified by their classes; there are no explicit language constructs for describing communities of interacting objects. In BabyUML, I will zoom back from the individual objects and let my code specify the community as a whole with abstractions taken from OOram role modeling and the UML concepts of collaboration and interaction.

The conceptual foundation for BabyUML is now established. It is called the DCI paradigm: Data-Collaboration-Interaction. (Formerly DCA). A presentation was at the JAOO conference in Aarhus in September 2007. This is a .ZIP-file. JAOO-trygve.ppt is the talk itself.

Things your mother didn't tell you about architecture and GUIs

An earlier version was at the ROOTS conference in Bergen in april 2007.

An article on the use of roles in programming is a submission to the Roles’07 workshop that was co-located with ECOOP 07:

Roles and Classes in Object Oriented Programming

An interim report on the BabyUML project was published by Nova Scientific Publishers as a chapter in Klein (ed): "Computer Software Engineering Research";2003; Chapter 2 - Programming with Roles and Classes: The BabyUML Approach; pp. 45-88; ISBN: 1-60021-774-5. The submitted chapter can be found at

Programming with Roles and Classes; the BabyUML Approach

I am riding a dear hobbyhorse in this short commentary in the same book:

The Case for Readable Code.

Some other publications:

MVC and DCA: Two complimentary system architectures.
(Model-View-Controller and Data-Collaboration-Algorithm)
A Java program presented at JavaZone 2006 that explores two powerful BabyUML object structures:

      JavaZone talk on Sept. 13, 2006: 09-JavaZone/talk.ppt
      Demo program discussion (Final Version) 09-JavaZone/mvc-dca.pdf
      Java experimental program: 09-JavaZone/BabyProject-3.zip
      Demo: Activity network demonstration applet.

An invited "expert voice" article for the Springer Journal on Software System Modelling:
The BabyUML Discipline of Programming
where A Program = Data + Communication + Algori thms

Final slides for ECMDA 2005 keynote (.ppt)

The BabyUML vision:
Empowering People with BabyUML: A sixth Generation Programming Language. Opening talk, ECOOP 2004, Oslo (.pdf)


Reverse Engineering of the Squeak/Tweak Islands construct and why it is not suitable as a foundation for BabyUML components (.pdf)

Latest walk-trough of demo code (.ppt)

Latest demo code report (.pdf)

Latest Squeak image. (Work in chaotic progress, not recommended for anything) (Squeak, .zip)

BabySRE: Squeak Reverse Engineering: Three tools making the Squeak objects visible and tangible (.pdf)

A good tool is an artifact that augments its user's might. A good tool is also a pleasure to use. Christopher Alexander discusses the concept of a quality without a name in relation to architecture. It could equally well be applied to information systems. Looking back on my almost half century in the business, I realize that the thrust has been on making tools for ordinary people. Particularly if we remember the oft forgotten fact that programmers are also ordinary people needing good tools.

A lifetime with computers culminates in my current project. I call it BabyUML. Deep down, it's all about giving information systems the quality without a name. I have always believed that people should be foremost in our minds when we design systems. The BabyUML goal is to make programs readable so that we can master them.

1973 marked the end of an era and the beginning of a new in my career as a computer programmer. The first era culminated with me writing the last program of a series that gave me a comfortable feeling. The new era came about because we moved from stable, closed systems to continuously changing, open systems. New problems, new challenges. I have still not mastered them; I still cannot build a significant program that is “so simple that there are obviously no deficiencies”.

There is a widespread belief that current software complexity is an unavoidable consequence of the complexity of the requirements and that we have to tolerate deficient software. I claim that this is merely a myth, and that our problems can be solved with adequate programming concepts, languages and tools that leverage the communication aspects of our systems.

BabyUML is probably an unreasonably ambitious project, but it is great fun. It builds on Smalltalk, Dynabook, UML, and most of the work I have been doing for the past 45 years. Its goal is to surmount a number of problems we often find in current mainstream applications:

It is hard to do sums with roman numerals. It is equally hard to build communicating systems with current tools. BabyUML is a laboratory for experimenting with new programming disciplines and languages. The laboratory is used to explore the specification of hierarchical structures of collaborating components and to explore how to make the component essence explicit and visible, hiding the details within the component members. The goal is to disprove the complexity myth and to help me feel comfortable with my future programs. The means is to harness three generations of programming technology into a coherent whole:

  1. A conceptual schema defines all legal member structures.
  2. The implementation constitutes the implementation schema.
  3. The component collaborations constitute the external schemas. The collaboration roles are mapped to the conceptual schema through queries.

I attack the challenges of this project from three angles:

I have two goals:

This is too much work for one person, and I hope that other people will identify interesting inssues and dig into them..

Here is some relevant material:

Title Themes Comment
 Towards A New Discipline of Programming
article (.PDF)
BabyUML I lost control over my software in 1973 when I progressed from FORTRAN to object oriented programming. The goal of the BabyUML project is that I shall regain control. In this article, I am exploring new ways of programming with objects. I select, simplify and twist UML and other constructs and demonstrate how they help bridge the gap between me as a programmer and the objects running in my computer.
Towards a New Discipline of Programming
Language Laboratory.

messy pre-draft of technical report (.PDF)
BabyUML The evolving technical report.
Towards A New Discipline of Programming
Talk at ROOTS, Bergen, 2005-04-27
BabyUML General overview
Workshop at ROOTS, Bergen, 2005-04-29
(.PPT) (.PDF)
BabyUML Presenting the code of the demo programs.
BabySRE: Squeak Reverse Engineering. (.PDF) BabyUML BabySRE is a package containing three tools making the Squeak objects visible and tangible. This is a technical note with a demo example. The package is also published on SqueakMap.
Empowering People with BabyUML:
A sixth Generation Programming Language.

Opening talk, ECOOP 2004, Oslo
Handout (.PDF)
Combine the algorithms of the 3rd generation languages with the information modelling of the 4th. Unify the technology of UML/MOF with that of Smalltalk and get:
> Systems that the users can understand , control and own.
> A world where the atoms are objects and the molecules are encapsulated constructs of interlinked objects
> A world where clearly delineated groups of objects are seperately owned and controlled.
> A world where the description of system design, code and run time objects all coexist and are part of the same program.
> A world where the execution lasts forever while different pieces are added and removed dynamically.
InformationSystems for the 21st Century

rOOts, Bergen, April 2004
Squeak slides/demo
is21c System development methodologies and architectures face several severe challenges. The premier goal of the IS21c project is to give users understanding, mastery and control of their information systems. The key to a solution is a user's mental model of his or her information and applications. The model must be explicit and tangible. Our focus is on the professional user in a business setting. We propose to let the models be tangible object models which the user can investigate, operate and otherwise manipulate.

(You can run the demo on a Windows system. Download the .zip-file, unzip, and execute IS21C-Squeak\Squeak.exe)
Object Orientation and Information Systems for the 21st Century
Understand – Explore – Master – Control
(Objektorientering og Informasjonssystemer for det 21. århundre)
NIK Confenernce, Oslo 2003.
.PPT (in English)
is21c, vm

My first presentation of the IS21c project. Features a demo of the meta-layers with an object, its class, and its metaclass. All as objects simultanesously on the screen. Change a method in the class, and the object immediately changes behavior.

A Rudimentary UML Virtual Machine as a Smalltalk Extension
Draft version, Feb. 2002: .PDF
uml, vm, is21c

The UML metamodel defines the abstract syntax of well formed model. A UML model is a structure of interrelated objects that conform to this syntax. I am experimenting with a UML Virtual Machine where anything and everything of interest exists as objects in this VM. Things in the application domain exist as objects. Classes and metaclasses exist as objects. Metametaclasses exist as objects. An Instance object is created by sending the message new to a class object. A class object is created by sending the message new to a metaclass object, etc. up the instantiation chain. I discuss three, disjoint structures in this UML-VM:
• Collaboration structure. How objects are interconnected and how they interoperate.
• Subclass/superclass structure. How classes inherit features from other classes.
• Instantiation structure. Every object is an instance of a class. Every class object is an instance of a metaclass, etc.

Data, Metadata, Metametadata, and a UML Virtual Machine
(Talk, JavaBIN. Aug. 2002) .PPT
is21c, uml, vm  
A Rudimentary UML Virtual Machine.
Working paper, Jan 2002. .PPT
is21c, uml, vm

A Smalltalk world is a structure of interrelated objects that reside in a Smalltalk Virtual Machine (VM). Anything and everything of interest exists as objects in this VM. Every object is an instance of a class. So is every class and metaclass object.

The analogy to UML is striking. A UML model is a structure of interrelated objects. I have found I cannot see through the details of a UML Virtual Machine (UMLVM) without actually writing one. It seems to me that this will be well worth while because it will illuminate the principles underlying UML.

by Erik Holbæk-Hanssen, Petter Håndlykken, Kristen Nygaard
Extract from report,
Norwegian Computing Center, Feb. 1977

systems, is21c Erik Holbæk-Hanssen, Petter Håndlykken and Kristen Nygaard give this imortant definition: "A system is a part of the world which we choose to reqard as a whole, separated from the rest of the world during some period of consideration, a whole which we choose to consider as containing a collection of components, each characterized by a selected set of associated data items and patterns, and by actions which may involve itself and other components. "
Paper, IFIP Congress, Toronto, Canada, 1977
First published in the 1977 IFIP Proceedings.
Scanned by the author July 2003.

is21c, roles, uml, mvc The yards of the Aker Group in Norway have been using network techniques and ad hoc methods for planning and control for many years. The systems used have not been satisfactory, and a new moelling tool was devised for the yards. The basic building block of this tool is considerably more powerful than the activity of the traditional networks. It is called a Component, and carries both its own data and the algorithms needed to manipulate them. Each Component represents an identifiable portion of the real world in the yard. The planning process consists of the Components sending information to each other (messages), and acting upon information received. An experimental system for the planning and control of the Design Sector of A/S Bergens Mekaniske Verksteder has been developed.
Paper, ICCAS conference, Tokyo, 1973.
Scanned by the author July 2003
is21c, components, architecture, mvc, The organisation of a yard may be strongly influenced by the information system it takes into use. The converse should also be true: Systems development should be subordinated the desired evolution of the organisation. The principle of Communicating Data Processes is introduced as a tool for building information systems that are easily moulded for fitting an existing organisation and for adaption to its continuous development. A description of the principle is given, as well as an outline of a new system designed for testing it out in practical shipbuilding.

Last updated 2005-11-11