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 tools.
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 permits ensures that a new generation of software designers and researchers 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.