Seminar: Can we Increase Software Development Productivity by an Order of Magnitude

AOT Logo

Speaker: Shayne Flint, Senior Lecturer, School of Computer Science (SoCS, ANU)

Date: Thursday, 01 October 2009

Time: 4:00 PM – 5:00 PM
Venue: CSIT Seminar Room, N101, CSIT Building, Building (108), North Road, ANU (campus map)

Website: Seminars @ CECS

Enquiries: Dr Malcolm Newey

“Demand for software developers is increasing while the number of software engineering and IT students remains stable or in decline. At the same time, there is an increasing need to quickly build software systems in response to rapid social, economic and environmental change. The CECS Software-Intensive Systems Engineering (SiSE) group is addressing these issues by developing novel technology which aims to increase software development productivity by an order of magnitude.

“To achieve this objective we are exploring the use of Model- Driven Engineering (MDE) and ways to improve its effectiveness. Specifically, we are addressing problems in areas such as requirements and stakeholder management; integrating multiple viewpoints, cross-cutting concerns, modelling languages and paradigms; variations in architecture and implementation; model semantics, translation, synchronisation, evolution and reuse; the presence of uncertainty, imperfection and ambiguity; verification, scalability and visualisation. This is a long list, but our research indicates the possibility that many of these problems may be the result of entrenched assumptions that underpin existing approaches to MDE.”

In this seminar Dr Flint will demonstrate a new approach to MDE which is developed from a very different set of assumptions. The approach is proving effective and addresses or eliminates many of the problems with existing approaches. If commercialised, it could have direct and demonstrable economic impact by increasing ICT industry productivity and our ability to rapidly react to emerging opportunities and threats.

This seminar is part of the CECS Seminar Series.

Shayne Flint is a Senior Lecturer at the School of Computer Science, Australian National University, and is an active member of the department’s Software-Intensive Systems Engineering group. He started his career as a RAAF engineering officer and has worked in industry in various software/systems engineering, consulting, marketing, management and commercialization roles. Dr Flint has broad industry experience and is the originator of Aspect-Oriented Thinking, a systematic approach to developing, managing and integrating the multi-disciplinary knowledge and expertise required to understand and improve complex systems. Nowadays, he is driven by a desire to radically improve the productivity of software development, particularly within multi-disciplinary contexts such as environmental science and engineering.

Original Seminar Notice at: Can we Increase Software Development Productivity by an Order of Magnitude, CECS Seminar List, The Australian National University, 2009

Requirements Churn

Often software development begins with a concept, an idea, a mere verbalization of an intangible. This is followed by a concerted effort to nail down the requirements for the proposed system.

Requirements are seen as a formal necessity for flagging off the development effort.

Usually, a formal requirements statement is approved for conversion into design. In many instances, where the problem domain is novel or fast-paced, the software effort runs into hurdles due to either late-breaking or rapidly-changing requirements. Or the requirements might evolve blazingly fast due to timeline pressures.

This is requirements churn.

The causes for the high rate of change of requirements pose a serious problem to the maintainability of the development effort. It becomes increasingly difficult to ensure that the code base is in sync with the requirements and design models (the boundaries between these two often becoming blurred). This is greatly exacerbated by traditionally elaborative software development processes which posit many implicit implementation assumptions during the coding effort — assumptions which are neither documented in the design nor in the requirements. This is not due to a lack of trying on the developers’ part. In the world of vastly complex enterprise software development, sourcing changes back to the design and requirements models may sometimes entail a substantial investment of effort and resources.

Project documentation and maintenance is not child’s play.

With translational and model driven development, the compiled executable system is deemed an immutable. Changes are mandated to be sourced to the requirements and design models. This ensures that the rationale for design and implementation decisions is captured as information and knowledge, and helps avoid the anachronistic mis-step between requirements and implementation.

Creative Commons License
This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 2.5 License.

Hacking Models — The Dark Side

Humans have a penchance for abuse and misuse, perhaps more so than any other creature on this planet (when was the last time we saw tamarins misuse trees… okay I admit I don’t watch the Nature Channel that much!).  With every technology and tooling at our disposal, the urge to abuse it becomes much more greater.

Code hacking is an all too familiar syndrome plaguing the software development industry.  We muck around in a heap of code that doesn’t perform as required and apply source-level hot-wiring to meet immediate needs.  What’s obviously required here is a second inspection, stepping back to re-evaluate the underlying design.  What’s obviously the norm is coding in a tiny tweak (with the Twilight Zone theme playing in the background), recompiling, and observing behavior.  If the system doesn’t blow up in our faces, that’s one more plus for this obviously unhealthy kamikaze behavior.  That’s a lot of “obvious” statements!

Flash-forward to the future.  We are now dealing with a higher level of abstraction when working with model compilers.  With great power comes great responsiblity and blah blah blah.  If Bjarne Stroustroup referred to C++ as dangerously powerful, MDD is obviously one of those glowing devices with hideously devastating potential.

Devastating — if misused, that is.

 Wow!  Modeling is great.   If I just drag this class here, and this relationship there, and this domain there…and compile and execute…hmm… this behavior is not what I had in mind… so let’s try it again.


This is not “Magpie Motel” (that was fun, let’s do it again)!  Advances in modeling tooling can never replace the drudge work that is Analysis.  Incomplete and inadequate attention to the non-modeling tasks will always result in poorly understood requirements, and hence nightmarish models.

Remember.  With great power comes…  and yes, we don’t need to be bit by an arachnid to realize that in MDD!

Creative Commons License
This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 2.5 License.


Executable UML is designed to produce a comprehensive and understandable model of a solution independent of the organization of the software implementation. It is a highly abstract thinking tool that aids in the formalization of knowledge, and is also a way of describing the concepts that make up abstract solutions to software development problems.

The goal of software and systems design is utilize maximal reuse of artifacts and minimize rework and redundancy. xUML takes this layer of abstraction to the next higher layer, and with the tooling necessary to compile and debug a model now becoming available, it has emerged a highly viable development paradigm.

Some Resources to Get Started

  • Executable UML — A Foundation for Model-Driven Architecture : Stephen J Mellor, Marc J Balcer
  • MDA Distilled : Stephen J Mellor et al
  • Model Driven Architecture with Executable UML : Chris Raistrick et al
  • The Object Constraint Language — Getting Your Models Ready for MDA : Jos Warmer, Annekke Kleppe
  • Kennedy Carter iUMLite at

Creative Commons License

This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 2.5 License