language mechanisms, derived in terms of that formalism, that are semantics-dependent but syntax-independent.Margaret H. Hamilton is one of the most brilliant software engineers. In fact, she is credited with coining the term software engineering in the first place as she wanted to give her software “legitimacy”, just like with other engineering disciplines (we’re still fighting the same battle!). She is most known for being Director of the Software Engineering Division of the MIT Instrumentation Laboratory, which developed the on-board flight software that brought us to the moon with the Apollo 11.

But what brings her here is the work she started after that mission finished. After carefully reviewing the software errors and incidences that happened during that mission, Margaret thought there had to be a better (i.e. less error-prone) way to approach software development and came up with the Universal Systems Language (for sure, one of the first modeling languages; still alive, see a recent integration of USL and SysML) together with the supporting methodology (Higher Order Software) and tool support (the 001 Tool suite).

In that work, we find many of the “standard” concepts of modern model-driven engineering practices. We can say that Margaret was not only a software engineering pioneer but also a model-driven engineering one!. 

If you read her recent IEEE software paper (What the errors tell us) you’ll realize that

  • USL already included the distinction between abstract and concrete syntax:

Language mechanisms are semantics-dependent but syntax-independent.

  • Model-based testing and verification

With USL, correct use of the language prevents (“eliminates”) errors “before-the-fact” in a system’s definition

  • Code-generation

All the code (and documentation) for a given software system are automatically generated from its formal definition, inheriting all the properties of the definition from which it came

  • Full life-cycle traceability from models to code

Instead of automation that supports the lifecycle, the lifecycle process itself can now be automated. Integration and traceability within a definition and from systems to software are seamless.

  • Platform-independent and platform-specific models, MDA-style

Because of USL’s open architecture, the automation can be configured to generate one of a possible set of implementations for a resource architecture (the how) of choice (e.g., a language, a database package, or the users’ own legacy code).

All this based on a pure model-driven approach where models are the only truth.

The developer never needs to change the code, since application changes are made to the USL definition—not to the code—and target resource architecture changes are made to the generator environment configuration—not to the code.

As Grady Booch famously said, history of software engineering is a rise in the levels of abstraction. I think we can confidently say that Margaret was one of the first key figures in following this path.

If you want to know more about her and her work, you can watch this recent keynote at ICSE’18:

Pin It on Pinterest

Share This