1 April 2001
In the last decade of the last millenium, object-oriented (OO) technology finally completed it's
transformation from a laboratory curiousity in the 1960s to become the mainstream
software development paradigm. It has been a long, tough journey - that nearly ended in obscurity -
primarily because OO technology required a major shift in the thought processes of systems designers,
developers and others involved in the software development lifecycle.
It wasn't until the introduction of OO-hybrid languages such as C++, Classic Ada and Object Pascal in
the eighties that the mainstream was introduced to and, given the opportunity to experiment with OO technology.
These languages combined support for OO programming with support for traditional procedural programming.
The lack of support of procedural programming in pure OO languages had hindered the adoption of OO technology
for many years. The journey that had begun with the introduction of objects in Simula in
the 1960s was now complete. OO technology was now accessible to the mainstream...well, OO programming was at least.
Simulation is the basic premise that underpins OO technology. An OO system is designed and implemented
essentially as a simulation of the real world using software artifacts. This premise is as powerful
as it is simple. By designing and building software
systems in this manner, the same language and ideas
can be used in the analysis, design and implementation of OO systems. This allowed a system to be designed
and tested (or more correctly allowed a system to be simulated) without having to actually build the system first.
This feature coupled with the ability to design systems at a very high level empowered experienced OO
practitioners to design and successfully implement more complex systems than had previously been possible.
The availabilty of various OO methodologies and the eventual adoption of the Unified Modelling Language
(UML) as the standard language for communicating OO concepts continued the advance of OO technology into
the mainstream. The popularity of the object-based Visual Basic language and the parallel development and
meteoric adoption of the fully object-oriented
Java programming language was the final catalyst that fuelled
the final stages of the rapid adoption of OO technologies by the mainstream.
ArgoUML was conceived as a tool and environment for use in the analysis and design of object-oriented software
systems. In this sense it is similar to many of the commercial CASE tools that are sold as tools for modelling
software systems. ArgoUML has a number of very important distictions from many of these tools:
ArgoUML includes a number of features that support the cognitive needs object-oriented software
designers and architects.
ArgoUML supports open standards extensively - UML, XMI, SVG, OCL and others. In this respect,
ArgoUML is still ahead (even almost five years after it's initial introduction) of many commercial
ArgoUML is a 100% Pure Java application. This allows ArgoUML to run on all platforms for which
a reliable port of the Java2 platform is available.
ArgoUML is an open source product. The availability of the source ensures that a new
generation of software designers and researchers will now have a proven framework from which they
can drive the development and evolution of CASE tools technologies.
In creating the ArgoUML development tool and environment, Jason Robbins and the rest of his research team at
UCL leveraged the benefits of UML as the most prevalent OO modelling language and Java as one of the most
productive OO development platforms to produce a solid tool for OO systems design and further a testbed for
the evolution of OO CASE tools development and research.