Publications and Reports

Books and Edited Collections

  1. Applied Metamodelling: A Foundation for Language Driven Development. Second Edition, Feb 2008. A. Clark, P. Sammut and J. Willans. (65 citations)

    The motivation behind XMF was to develop a technology that would support a language driven approach to modelling and system development. Our starting point was that UML was not sufficiently flexible and in order to address this we designed an executable meta-language. This book describes the approach and provides an introduction to the key technologies: meta-models, language definition and mappings. The book concludes with a number of worked examples.

    Applied Metamodelling Book

  2. Superlanguages: Developing Languages and Applications with XMF. First Edition, March 2008. A. Clark, P. Sammut, J. Willans.

    This book provides an extensive description of the XMF technology. The Applied Metamodelling book introduces the field and provides an overview of the methodology. The Superlanguages book describes the underlying technology in detail. It defines the language used by XMF, how to use grammars for language definition and provides many complete worked examples.

    Superlanguages Book

  3. Object Modeling with the OCL - The Rationale behind the Object Constraint Language. A. Clark, J. Warmer (eds). LNCS vol. 2263. 2002.

    Jos Warmer and I produced this collection of papers by key authors in the field. The collection contains the original Amsterdam Manifesto that started the OCL movement.

    OCL Book

  4. Proceedings of the Workshop on Expressing and Reasoning about Constraints in UML. A. Clark, S. Kent and J. Warmer (eds). March 2000. University of Kent.
  5. Proceedings of UML 2.0 - The Future of the UML Object Constraint Language (OCL). A. Clark, J Warmer (eds). Workshop at UML 2000 - The Unified Modeling Language. Advancing the Standard. Third International Conference, York, UK, October 2000
  6. Proceedings of the third Rigorous Object-Oriented Methods Workshop (ROOM3). A. Clark, A. Evans, K. Lano (eds). BCS Electronic Workshops in Computing, ISBN: 1-902505-38-7, January 2000. York.
  7. Proceedings of the Third Northern Formal Methods Workshop. A. Evans, D. Duke, A. Clark (eds). BCS Electronic Workshops in Computing, 1998.
Home.

Chapters in Books

  1. A Meta-Model Facility for a Family of UML Constraint Languages. A. Clark, A. Evans, S. Kent. In Advances in Object Modelling with the OCL. A. Clark, J. Warmer (eds.), Springer Verlag, LNCS 2263. March 2002.

    With the move towards UML becoming a family of modelling languages, there is a need to view the Object Constraint Language in the same light. The aim of this paper is to identify a meta-modelling facility that encompasses the specification of the semantics of a family of object constraint languages. This facility defines a common set of model concepts, semantic domain concepts and semantic mappings that can be conveniently reused when constructing new family members.

  2. The Knowledge Based Programmer's Assistant Revisited : Representation, Reasoning and Review (Esprit project 32). G. Oddy, K. Poulter, A. Clark. ESPRIT '86 Results and Achievements. North-Holland 1987.

    The Portable Common Tool Environment (PCTE) was one of the first ESPRIT projects and was the first project I worked on after graduating. The PCTE was a kind of operating system that supported an object-oriented style of file-system (graph rather than tree shaped). The Knowledge Based Programmer's Assistant (KBPA) was a system that used program templates to transform a high-level specification of a program into code. Since the various features of the KBPA were highly structured, this was a good case study for the PCTE. As far as I recall, this was done on SUN 1 workstations and took several minutes to generate a simple sorting procedure in Ada. This paper reviews the project.
Home.

Journal Special Issues

  1. Model-Driven Development S. Mellor, A. Clark, T. Futagami (eds). IEEE Software, vol 20, issue 5, Sep - Oct 2003.
  2. Rigorous Object-Oriented Methods. A. Clark, A. Evans, K. Lano (eds). Special Issue of L'Objet. Vol 9 No 4. 2003.

    Rigorous Object Oriented Methods

Home.

Journal Papers

  1. Language Driven Development and MDA. A. Clark A. Evans, P. Sammut, J. Willans. MDA Journal (10). 2004.

    This article was published in the MDA Journal edited by Dave Frankel. It describes an approach to modelling that embraces, language definition, execution and meta-modelling. It was written as an companion piece to a previous article by Steve Cook: Domain Specific Modeling and Model Driven Architecture.
  2. Aspect-Oriented Meta-Modelling. A. Clark, A. Evans, S. Kent. BCS Computer Journal, Special Section on AOP and Separation of Cross Cutting Concerns. 2003 46(5):566-577

    This paper describes in some detail how the package extension and package template mechanisms that we developed as part of our efforts to take a structured approach to defining modelling languages like UML 2.0. Templates are parametric packages and allow patterns to be defined that can later be stamped out. Package extension is similar to class inheritance and allows models to be constructed from components.
  3. Editorial: Rigorous Object-Oriented Methods. A. Clark, A. Evans, K. Lano. Special Issue of L'Objet. Vol 9 No 4, pp 7 - 11. 2003.

    The special issue included some of the best papers from the ROOM 4 workshop held at King's College in 2004.
  4. Model-Driven Development - Guest Editor's Introduction. S. Mellor, A. Clark, T. Futagami (eds). IEEE Software, vol 20, issue 5, Sep - Oct 2003, pp 14 - 18.
  5. Modelling Language Transformations. A. Clark, A. Evans, G Maskeri, P. Sammut, J. Willans. In Rigorous Object-Oriented Methods, Special Issue of L'Objet. Vol 9 No 4 pp 31 - 51. 2003.

    The advent of model driven software engineering necessitates that there are frameworks and techniques that enable the translation of software expressed in one language to another language. Although the ability to do this is not new, compilers have long been addressing this need for programming languages; existing techniques are bespoke for the source and target language. The diverse nature of software applications demands that software engineers use (and adapt) a wide range of different languages to express software. In this paper we present a framework and approach for rapidly describing transformations between languages using transformation patterns.
  6. The Specification of a Reference Implementation for the Unified Modelling Language. A. Clark, A. Evans, S. Kent. In B. Henderson-Sellers and F. Barbier (eds) Object Modelling with UML. Special Issue of L'Objet. Vol 7, no 3/2001, pp363-385, 2001.

    As part of our contribution to the UML 2.0 standard we tried to persuade members of the OMG that there should be a reference implementation for UML which was freely available so that vendors could test out their implementations. The proposal fell on deaf ears, but this paper outlines aspects of how it might have worked.
  7. Quality Issues in the Formal Refinement of KBS. A. Clark. Reviewed and accepted to appear in the International Journal of Expert Systems: Research and Applications. 1998.

    This paper is an extended version of A Formal Basis for the Refinement of Rule Based Transition Systems adding more underlying theory and examples. A semantics is developed for a small language that can be used to represent rule-based systems along with semantics preserving refinement transformations that increase rule efficiency. A quality control process for developing KBS with the language is proposed. The paper was accepted and went through the normal update process, however the Journal subsequently folded without publication.
  8.  A Formal Basis for the Refinement of Rule Based Transition Systems. A. Clark. The Journal of Functional Programming 6(2). 1996.

    This paper makes a contribution to the refinement of systems which involve search by proposing a simple non-deterministic model for rule-based transition systems and using this to define a meaning for rule based refinement which allows each stage of the software development path to be verified with respect to the previous stage.
  9.  Pattern Recognition of Noisy Sequences of Behavioural Events Using Functional Combinators. A. Clark. The Computer Journal. 37(5) 1994.

    This work was undertaken as part of the ESPRIT VIEWS project which aimed to develop and deploy computer vision technology. The project used two case studies: understanding vehicle behaviour at a roundabout; understanding surveillance data from cameras at an airport. This paper addresses the problem of detecting pre-defined behaviours from visual cues. In particular, the visual input data is noisy and incomplete. The described approach uses a novel parsing algorithm to match sequences of cues to behaviours expressed as grammars.
  10.  A Layered Object-Oriented Programming Language. A. Clark. GEC Journal of Research. 11(3) 1994.

     This paper describes a collection of standard object-oriented programming language properties. It analyzes them by extending a simple lambda-calculus with simple OO primitives and then building up a language that exhibits all of the properties as a sequence of layers on top of the extended calculus. The paper arise out of PhD work and describes some results that did not make it into the final thesis.
Home.

Conference and Workshop Papers

  1. Knowledge industry survival strategy (KISS): fundamental principles and interoperability requirements for domain specific modeling languages. Jorn Bettin, William Cook, Tony Clark, Steven Kelly. In the Proc. of the 24th ACM SIGPLAN conference companion on Object oriented programming systems languages and applications, Orlando, 2009. ISBN:978-1-60558-768-4.

    Domain Specific Languages are raising the level of abstraction of software specifications and of knowledge represen-tation in general. When DSLs are used to formalize the results of domain analysis, the result is a clean separation of concerns in the problem space. This is a major advance over aspect oriented programming, where separation of concerns is only achieved in the solution space. However, the level of interoperability between current DSL tools is comparable to the level of interoperability between CASE tools in the 90s. To increase the popularity of DSL based approaches, this needs to change. Software development has become highly decentralized, and an assumption that all parties in a global software supply chain will use identical tooling is simply not realistic. As a result today's software supply chains are much less automated than supply chains in other, more mature industries. The KISS series of workshops is used to incrementally establish a consensus on the fundamental principles that underpin the use of DSLs, and to improve DSL tool interoperability.
  2. A MOP Based DSL for Testing Java Programs using OCL Tony Clark. To be presented at the OCL 2009 Workshop - The Pragmatics of OCL and Other Tectual Specification Languages, MoDELS 09, Denver Colorado, USA, October 4-9, 2009.

    OCL is used to specify systems by defining pre and postconditions for class operations. Typically, the conditions refer to properties and operations that are defined in a model. When the model is implemented, various implementation decisions are made regarding properties and operations that cause the OCL conditions to be inconsistent with the implementation. This paper shows how OCL conditions can be performed against a Java implementation of a model and how a meta-object protocol can be used to control the relationship between the original model and the implementation thereby retaining OCL consistency
  3. A Case Study on Model Driven Data Integration for Data Centric Software Development. Hyeonsook Kim, Ying Zhang, Samia Oussena, Tony Clark. To be presented at the ACM First International Workshop on Data-intensive Software Management and Mining, Nov 06, 2009, Hong Kong, China.

    Model Driven Data Integration is a data integration approach that proactively incorporates and utilizes metadata across the data integration process. By decoupling data and metadata, MDDI drastically reduces complexity of data integration; whilst also providing an integrated standard development method, which is associated with Model Driven Architecture. This paper introduces a case study to adopt MDA technology as an MDDI framework for data centric software development; including data merging and data customization for data mining. A data merging model is also proposed to define relationships between different models at a conceptual level which is then transformed into a physical model. In this case study we collect and integrate historical data from various universities into the Data Warehouse system in order to develop student intervention services through data mining.
  4. Language Factories Tony Clark and Laurence Tratt. To be presented at Onward! 09, Orlando Florida, October 25-29, 2009.

    Programming languages are the primary mechanism by which software is created, yet most of us have access to only a few, fixed, programming languages. Any problem we wish to express must be framed in terms of the concepts the programming language provides for us, be they suitable for the problem or not. Domain Specific Languages (DSLs) suggest an appealing escape route from this fate, but since there is no real technology or theory underpinning them, new DSLs are rare. In this paper we present the Language Factories vision, which aims to bring together the theory and practice necessary to realise DSLs in a systematic way. In so doing, we hope to lower the barrier for language creation significantly, ultimately allowing software creators to use the languages most suited to them and their needs.
  5. First Class Grammars for Language Oriented Programming. Tony Clark. The 13th World Multi-Conference on Systemics, Cybernetics and Informatics: WMSCI 2009. July, 2009, Orlando Florida, USA.

    Programming languages that support Language Oriented Programming (LOP) allow developers to extend the host language with new programming features. The extensions include new concrete syntax constructs that are both re- placements for and interleaved with the host language. This paper describes the general features that are required in order to support the LOP approach in a language. The paper shows how many of the features are implemented in the XMF language system, describes the shortcomings of the implementation and outlines an extension to Java that would address these shortcomings.
  6. Model Based Functional Testing using Pattern Directed Filmstrips. Tony Clark. In the proceedings of the Fourth International Workshop on the Automation of Software Test (AST 09), May 18 - 19, ICSE 09, Vancouver Canada.

    Model driven functional system testing generates test scenarios from behavioural and structural models. In order to autmatically generate tests, conditions such as invariants and pre-/post-conditions must be precisely defined. UML provides the Object Constraint Language (OCL) for this purpose; however OCL expressions can become very complex. This paper describes an approach that allows many commonly found OCL patterns to be expressed as snapshot patterns that correspond directly to the information model diagrams. Behaviour is constructed as chains of snapshots, or filmstrips. Snapshots and filmstrips are as expressive as UML behaviour models and OCL but it is argued that theyare more accessible and more modular.
  7. Formalizing Homogeneous Language Embeddings. Tony Clark and Laurence Tratt. In the proceedings of the 9th Workshop on Language Descriptions Tools and Applications (LDTA). ETAPS 2009, York, UK.

    The cost of implementing syntactically distinct Domain Specific Languages (DSLs) can be reduced by homogeneously embedding them in a host language in cooperation with its compiler. Current homogeneous embedding approaches either restrict the embedding of multiple DSLs in order to provide safety guarantees, or allow multiple DSLs to be embedded but force the user to deal with the interoperability burden. In this paper we present the \mu-calculus which allows parameterisable language embeddings to be specified and analysed. By reducing the problem to its core essentials we are able to show how multiple, expressive, language embeddings can be defined in a homogeneous embedding context. We further show how variant calculi with user-defined safety criteria can be defined. 

    This report     shows how parsing mechanisms can be embedded in the mu-calculus and how a language translation can be proved to be property preserving. The parsing mechanism is defined using a DSL for expressing grammars that is defined in mu. HTML and SQL languages are defined independently and the semantics is shown to be preserved when the languages are translated to a target language.
  8. Beyond Annotations: A Proposal for Extensible Java (XJ). A. Clark, P. Sammut, J. Willans. In the proc. of  the Eighth IEEE International Working Conference on Source Code Analysis and Manipulation. Beijing, China, Sept, 2008.

    The XMF system is based on a bespoke language that includes some features that are key to Language Oriented Programming: grammars; syntax classes; parsers; quasi-quotes. This paper discusses various technologies and approaches for LOP and concludes that standardization is one of the key features that will bring LOP and Domain Specific Languages to the mainstream. The paper proposes an extension to Java that incorporates the key LOP and DSL features of XMF. The essential Java extensions are discussed and the paper concludes with a couple of examples.
  9. A Domain Specific Language for Interactive Applications. A. Clark. Model Driven Development Tool Implementers Forum. TOOLS 2007, Zurich. 2007.

    This paper was written in response to a challenge published by the forum organizers to develop a DSL for an interactive TV application. The idea was to write the communication language used to control the set-top box and to respond to commands from the hand-held controller. The paper contains a few DSLs for this purpose developed using the XMF engine.
  10. MDA-Driven Development of standard-compliant OSS components: the OSS/J Inventory Case-Study. N. Georgalas, M. Azmoodeh, A. Clark, A. Evans. In proc of Second European Workshop on Model Driven Architecture (MDA) 2004.

    This paper reports work done with BT in developing some model-driven tooling for representing aspects of the OSS telecomms standard. XMF-Mosaic was used to create a meta-model of part of the OSS telecomms service level standard and to use the meta-package feature of XMF-Mosaic to automatically create tools to support modelling using this DSL. The mapping feature of XMF-Mosaic is used to generate J2EE code.
  11. An eXecutable Metamodelling Facility for Domain Specific Language Design. A. Clark, A. Evans, P. Sammut, J. Willans. In proc. of 4th OOPSLA Workshop on Domain-Specific Modeling, 2004.

    We were a bit frustrated that we could not convince people to make MOF an executable language. This paper outlines the results of our efforts to generate an executable meta-modelling language that is used at the core of XMF-Mosaic.
  12. Transformation Language Design: A Metamodelling Foundation. A. Clark, A. Evans, P. Sammut and J. Willans. In Graph Transformations. LNCS Volume 3256 pp 13 – 21 2004.

    One of the innovations developed as part of XMF-Mosaic was the coupling of executable meta-modelling and pattern-based data transformations. The meta-level of a modelling language can include executable rules for transformation. This can be used for a variety of tasks including code generation and document generation. This paper provides an outline of the approach.
  13. A Pattern based model driven approach to model transformations. B. Appukuttan, A. Clark, S. Reddy, L. Tratt, R. V. In Proc. Metamodelling for MDA 2003, pages 110-128, November 2003.

    The 2U Consortium has recently submitted a proposal for the definition of the UML 2.0 infrastructure. This uses an innovative technique of rapidly “stamping out� the definition using a small number of patterns commonly found in software architecture. The patterns, their instantiation, and any further language details are described using precise class diagrams and OCL, this enables the definition to be easily understood. The main focus of the 2U approach is on the static part of the definition. A further concern when modelling software, using languages such as the UML, is describing the dynamic behaviour of the system over time. The contribution of this paper is to provide a template that can be used to “stamp out� the dynamic part of the UML 2.0 infrastructure. We argue for the suitability of the dynamic template because it makes little commitment to concrete abstractions and can, therefore, be used to support a broad spectrum of behavioural languages.
  14. A model driven approach to building implementable model transformations B. Appukuttan, A. Clark, S. Reddy, L. Tratt, R. Venkatesh. WiSME 2003, San Francisco CA, October 2003.

    In 2002 the OMG published a call for submissions to address the issue of model transformations within MDA. We were one of the main consortiums that submitted and this paper describes the overall approach.
  15. Model transformations in Converge. L. Tratt, A. Clark. WiSME 2003, San Francisco CA, October 2003.

    Laurie's Converge Language was an ideal technology for implementing some of the ideas from the QVT submission. This paper shows how it was done.
  16. Object-Oriented Theories for Model Driven Architecture. A. Clark, A. Evans, R. France. In the proceedings of the OOIS MDA Workshop, Springer Verlag, LNCS 2426. Montpellier France September 2002.

    An object-oriented theory is a snapshot (or object) diagram with variables in it and some constraints in terms of the variables. The diagrams can be combined to form deduction rules and the set of ground object models that can be generated are collectively referred to as an object-oriented theory. This paper outlines an approach to MDA using object-oriented theories.
  17. Using Icon-derived technologies to drive model transformations. L. Tratt A. Clark. In the proceedings of UML 2003 Workshop in Software Model Engineering.

    An earlier version of the ideas reported in the Converge paper above.
  18. Enhancing the Template Mechanism. L. Tratt, A. Clark. In the proceedings of the Workshop on Software Model Engineering held at the International Conference on UML, Dresden, Germany, October 2002.

    The 2U consortium used templates as a mechanism to construct their submission for UML 2.0 to the OMG. These templates were rather under-specified and this paper addressed this issue by proposing a formal calculus as a basis for template definition.
  19. A Metamodel for Package Extension with Renaming. A. Clark, A. Evans, S. Kent. In the proceedings of The 5th International Conference on the Unified Modeling Language (<<UML2002>>), Dresden, Germany, Springer-Verlag LNCS, October 2002. (17 citations)

    Package extension and template mechanisms were originally proposed as part of the Catalysis method.  This paper provides a rigorous metamodel
    definition of the package extension mechanism.
  20. Patterns for Renaming and Stamping out Object-Oriented Models. A. Clark, A. Evans, S. Kent. Accepted for the International Conference on Software Engineering Research and Practice, SERP 2002, Las Vagas, USA. (not presented).

    This is an MML paper showing how templates can be used to capture model patterns and then models can be created by supplying template arguments and joining the resulting model fragments.
  21. A pattern based approach to defining the dynamic infrastructure of UML 2.0. B. Appukuttan, A. Clark, A. Evans, G. Maskeri, P. Sammut, L. Tratt, J. Willans. In proceedings of the Fourth Workshop on Rigorous Object-Oriented Methods, ROOM 4, King’s College, March 2002.

    The 2U consortium proposed a template-based approach to defining UML 2.0. This paper provides an example of this approach showing how a dynamic language (such as the UML action language) can be defined in terms of templates.
  22. A pattern based approach to defining translations between languages. G. Maskeri, J. Willans, A. Clark, A. Evans, S. Kent, P. Sammut, Presented at the Fourth Workshop on Rigorous Object-Oriented Methods, ROOM 4, King’s College, March 2002.

    The 2U Consortium have recently submitted a proposal for the definition of the UML 2.0 infrastructure. This uses a innovative technique of rapidly “stamping out� the definition using a small number of patterns commonly found in software architecture. The contribution of this paper is to introduce the idea of reusability of mappings between languages and defining some of the reusable mapping templates. This paper also illustrates how these templates can be used to stamp out mapping between languages by stamping out a mapping between UML and Java.
  23. Engineering Modelling Languages: A Precise Metamodelling Approach. A Clark, A. Evans, S.Kent. In proceedings of the 5th International Conference on Fundamental Approaches to Software Engineering. France. 2002. pp 159 – 173. (50 citations)

    An MML paper that describes the overall approach of a language MML, a tool MMT and a method MMM used to define modelling languages.
  24. An Action Semantics for MML. J-M Alvarez, A. Clark, A. Evans. In proceedings of 4th International Conference on the Unified Modeling Language (<<UML2001>>), Toronto, LNCS 2185, Springer-Verlag, 2001. (23 citations).

    This paper describes an action semantics for UML based on the Meta-Modelling Language (MML) - a precise meta-modelling language designed for developing families of UML languages. Actions are defined as computational procedures with side-effects. The action semantics are described in the MML style, with model, instance and semantic packages. Different actions are described as specializations of the basic action in their own package. The aim is to show that by using a Catalysis like package extension mechanism, with precise mappings to a simple semantic domain, a well-structured and extensible model for an action language can be obtained.
  25. The Meta-Modeling Language Calculus: Foundation Semantics for UML. A. Clark, A. Evans and S. Kent. In proceedings of FASE Workshop, European Conference of Theory and Practice of Software (ETAPS), Genoa, LNCS, 2001. (64 citations)

    We were trying to define a small core meta-language that would allow us to build UML-style modelling languages. The language had to be object-oriented, executable, imperative and support OCL-like features. The MMT tool (which later evolved into XMF) implemented a language whose essential semantics was boiled down into a calculus described in this paper.
  26. The MMF Approach to Engineering Object-Oriented Design Languages. A. Clark, A. Evans, S. Kent, and P. Sammut. Presented at the workshop on Language Descriptions, Tools and Applications (LTDA 2001), Genoa, 2001. (43 citations)

    We designed a meta-language called MML in order to define UML-style languages by combining patterns in the form of templates. MML was implemented as a tool called MMT which provided a programming language for defining UML-style concepts (packages, classes, etc). MMT allowed language features to be parametric and thereby captured language patterns. The approach, language and tool was collectively referred to as MMF. This report is an extended version of the ETAPS FASE paper and describes MMF and provides some examples.
  27. Object-Oriented Refinement and Proof using Behaviour Functions. A. Clark. In the Proceedings of the Third Workshop on Rigorous Object-Oriented Methods, A. Clark, A. Evans, K. Lano (eds.), ROOM 3, BCS eWiCS, York, January, 2000.

    The Algebraic approach to specifying systems describes various aspects of a system as algebras, links the algebras together using morphisms and then defines the complete system as a solution to a set of equations that satisfy all the algebras and morphisms. This paper transfers the approach to a lambda-calculus setting and introduces a new calculus with equation-solving operators. The benefit of using a lambda-calculus is that the specification can be step-wise refined into an implementation.
  28. Using Profiles to Rearchitect the UML. A. Clark, A. Evans, S. Kent. Presented at the pUML Workshop, ECOOP, Nice, France, 2000.

    An early description of how we proposed to organize the UML as a bunch of composable properties.
  29. Formal Refinement and Proof of a Small Java Program. A. Clark. In proceedings of the ECOOP 99 workshop on Formal Methods for Java Program Development. Lisbon, June 1999.

    Part of an ongoing attempt to specify programs in terms of modular chunks of behaviour, combine the modules and then derive an implementation. Companion to Object-Oriented Refinement and Proof using Behaviour Functions.
  30. Typechecking UML Static Models. A. Clark. In Proceedings of the International Conference on UML, Colorado USA. Springer, LNCS, 1999.

    The Object Constraint Language had been around for a while but had attracted little scientific study. This paper defines a type system for OCL and shows how it can be used to type check UML models that use OCL for constraints.
  31. A Semantics for Object-Oriented Systems. A. Clark. In the Proceedings of the Third Northern Formal Methods Workshop. A. Clark, A. Evans, D. Duke (eds). BCS FACS Electronic Workshops in Computing. 1999.

    This paper describes a similar system to Object-Oriented Refinement and Proof using Behaviour Functions. 
  32. Semantics of the Unified Modeling Language. A. Clark, A. Evans. In proceedings of the first Rigorous Object-Oriented Methods Workshop (ROOM1) , Imperial College, University of London, 23 June 1997.

    A very early paper on the semantics of the Unified Modelling Language that uses a modal-logic to define the system behaviour expressed by a UML model. Modality is used to define what is meant by state machines and activity diagrams. Once the UML model has been translated to the modal-logic, the Tableau Method is used to establish system properties.
  33. Foundations of the Unified Modeling Language. A. Clark and A. Evans. In D. Duke and A. Evans, editors, BCS FACS - 2nd Northern Formal Methods Workshop, Ilkley, electronic Workshops in Computing, Springer Verlag 1997. (41 citations)

    Compare the use of the modal-logic in Semantics of the Unified Modeling Language with the use of Z to express the semantics of UML models in this paper.
  34. A.Clark, A.Evans. Foundations of the UML with Modal Logic. Presented atWorkshop on ‘Making OO Methods More Rigorous’, Imperial College, 24th June, 1997.

  35. The Generation of Animated Sequences from State Transition Systems. A. Clark, I. Palmer. In Proc. of the fifth Eurographics workshop on Programming Paradigms in Graphics, Maastricht, Sept. 2-3, 1995.

    This paper takes the modular compositional behaviour idea for systems and applies it to computer animation. Aspects of animations are specified as separate state machines and a collection of behaviour composition and restriction operators are defined and used to build the required animation.
  36. Towards an Expert System for the Analysis of Computer Aided Human Performance. A. Clark, G. Greatorex, A. Hill. In the Proceedings of the International Workshop on Human Computer Teamwork, Cambridge, Sep. 1994.

    At the time this work was done, Human Factors was an area that had little computer-based support. This work was an attempt to show that the information needed by a HF expert when analyzing tasks could be represented in a way that facilitated their activities. I can only find an early draft of this paper, however it gives the general ideas.
  37. Airside Ground Movement Surveillance. D. Corrall, A. Clark, A. Hill. In Proceedings of the International AGARD Conference #538 -- Machine Intelligence in Air Traffic Management. 1993.

    A paper giving an overview of the system whose technology is described in  Pattern Recognition of Noisy Sequences of Behavioural Events Using Functional Combinators.
  38. The Evolution of the STRATA Representation and Reasoning System (Or STRATA: The story behind the layers). K. Poulter, A. Clark, C. Jackson. In the Proceedings of the first workshop for the special interest group on knowledge manipulation engines. Cambridge, 1987.

    The STRATA AI Toolkit was developed by myself and Kevin Poulter at Marconi Research from 1985 to 1991. At the time, there was a great deal of interest in AI and KBS. Many high-technology groups were using Prolog and Lisp to develop reasoning systems. STRATA arose out of technology we developed as part of the KBPA demonstrator application for the ESPRIT PCTE project. At the time there were US-based AI toolkits emerging (for example Intellicorp KEE), but not much in Europe and we saw an opportunity. STRATA was developed in (Kyoto) Common Lisp and subsequently on Poplog which provided a library for a graphical user interface. STRATA included a collection of technologies including: a RETE-based forward chaining rule-system; a CLOS-based object-system (implemented before CLOS was part of Common Lisp); a Prolog-based backward chaining rule-system; viewpoints or multiple-worlds; a constraint satisfaction system. When it was eventually released as a product, STRATA was renamed KERIS for copyright reasons. It was used on a number of projects including Knowledge-based signal processing for radar ESM systems.
  39. The STRATA Representation and Reasoning System. K. Poulter, A. Clark. ESPRIT Technical Week. 1986.

    A paper giving an overview of the STRATA system (see above).
Home.

Reports

  1. Processing XML for Domain Specific Languages. A. Clark. 2008.

    XMF implements a novel mechanisms for processing XML using conventional BNF-style grammars. This paper describes the mechanism in detail and defines an XML parsing machine that efficiently processes SAX events.
  2. Meta-Packages: Painless Domain Specific Languages. A. Clark. 2008.

    This paper describes some technology that was developed as part of the XMF-Mosaic toolkit. UML provides fairly restricted access to the meta-level in order to tailor the modelling concepts and invent new languages. XMF-Mosaic provides complete access to the meta-level which can be extended and modified as required. However, complete access to the meta-level requires new tooling each time. We observed a middle ground whereby new languages defined by extending a basic collection of meta-concepts could be supported by some generic tooling. We called this approach meta-packages and this paper describes how they work.
  3. Language Driven Development and XMF-Mosaic, 2005.  A Clark, A. Evans, P. Sammut, J. Willans. Industry White Paper published by ZDNet.co.uk.

    This paper was written in order to raise the awareness of XMF-Mosaic. Here is the blurb that goes with it: The way that people design software and systems is about to be revolutionized. Developers will no longer be constrained by the tools they use, but will have the freedom to model the languages and tools that best fit their problem domain and development processes. By closely tailoring tools to suit their problem domain, developers will gain huge increases in productivity enabling them to bridge the gap between the way they naturally think about their problem domain and the software that implements it.
  4. A Calculus for QVT. A. Clark. 2004.

    The Queries View and Transformations RFP was issued by the OMG in order to address the issue of code generation from UML models. The QVT call aimed to provide a standard industry mechanism for processing models as part of the Model Driven Architecture initiative of the OMG. I was part of the initial group that started to put together a QVT language based on the Object Constraint Language. This paper describes a calculus that was part of that initial work. The work aimed to provide a simple compositional language that could be used to express UML models and QVT transformations.
  5. Issues surrounding model consistency and QVT. Laurence Tratt, Tony Clark Technical report TR-03-08, Department of Computer Science, King's College London. December 2003.

    Laurie and I worked on the initial definition of the Queries Views and Transformations (QVT) specification in the OMG. Part of the problem addressed by QVT is how to keep multiple models synchronized. This report describes an approach to model synchronization.
  6. Why modelling needs more than generalization. L. Tratt, A. Clark, A. S. Evans. King’s College Research Report. April 2002.
  7. Unambiguous UML (2U) Submission to UML 2 Infrastructure RFP. June 2002.

    After a great deal of effort we finally put together a submission to the OMG for UML 2.0 as part of a consortium called 2U (the winning consortium was called U2). This report is the submission which gained a great deal of technical support within the OMG, but unfortunately did not gain sufficient political weight. The report describes how to put UML together using a collection of language properties expressed at the meta-level using templates. It is essentially the MML approach described in papers elsewhere.
  8. Modelling generalization and other class-to-parent relationships. L. Tratt, A. Clark, A. Evans. King’s College Research Report. 2003.

    In order to reflect the different variations in meaning for the concept of generalization, modelling languages like UML need more then one semantic relationship. This paper discusses this issue and shows how the different semantics can be captured as patterns.
  9. Defining OCL Expressions Using Templates. J. Willans, P. Sammut, G. Maskeri, A. Evans, A. Clark. King’s College Research Report. 2002.

    At the time, OCL was part of UML but did not have a meta-model (this has since been rectified). This paper showed how the meta-model for OCL can be constructed using template patterns.
  10. Engineering a precise meta-model definition. A Clark, A. Evans, G. Maskeri, A. Moore, P. Sammut, J Willans. University of York Research Report. 2002.
  11. A Programmer’s Guide to MMT. A. Clark, A. Evans, S. Kent. King’s College Research Report. January 2002.

    MMT was an early version of XMF. This book introduces MMT and its libraries. Each aspect of MMT is described using a number of examples.
  12. Unambiguous UML. A. Clark, D. D’Souza, A. Evans, S. Mellor, S. Kent. (2U) submission to UML2 RFP on Infrastructure and OCL. August 2001.

    In 2000 the OMG published a call for a revision of the UML standard. A consortium of companies, organizations and individuals was formed in order to address the problems of complexity and bloat that were seen to be problems with the existing UML language. This report is the initial submission from that consortium which aimed to use a number of patterns exemplifying language properties in order to define the core of UML.
  13. A Translational Semantics for UML. A. Clark, D. D'Souza. King’s College Research Report. 2001.

    This (incomplete) report was work I did with Desmond D'Souza. Desmond was the co-developer of Catalysis. The report aims to use a very simple semantic domain based on snapshots and filmstrips as the basis for UML. The high-level concepts of UML are translated down onto the semantic domain.
  14. Submission to the UML2 RFP on OCL. Boldsoft, Rational Software Corporation, IONA. In association with J. Warmer, A. Kleppe, A. Clark, A. Ivner, J. Högström, M. Gogolla, M. Richters, H. Hussmann, S. Zschaler, S. Johnston, D. Frankel. August 2001.

    OCL is the Object Constraint Language which is part of the modelling language UML. In 2001 the Object Management Group published a request for proposals for OCL version 2.0. This report is the initial submission by a consortium of companies, organizations and individuals describing the proposed upgrades from OCL version 1.0.
  15. A Feasibility Study in Rearchitecting UML as a Family of Languages Using a Precise OO Meta-Modeling Approach. A. Clark, A. Evans, S. Kent, S. Brodsky, and S. Cook. Technical report, pUML Group and IBM. September 2000. (34 citations)

    This report was effectively commissioned by IBM and championed by Steve Cook (now with Microsoft) as an experiment to see if the upcoming UML 2.0 standard could be handled in a scientific way in order to meet the (often conflicting) requirements of different users. The report led to the 2U consortium being formed and the 2U UML 2.0 submission to the OMG.
  16. Response to UML 2.0 Request for Information. A. Clark, A. Evans, R. France, S. Kent and B. Rumpe. December 1999.

    An initial stake in the ground in the OMG UML 2.0 definition process (which eventually took several years).
  17. Implementation of Lazy Agents in the Functional Language EBG. A. Clark. University of Bradford Technical Report. 1999.

    The EBG language is used to implement a representation of multiple communicating agents. The agents are threaded together using a lazily evolving stream of messages. This paper conflates two research threads: EBG that compiles onto the Java VM; and, multi-agent systems. The threads might usefully have been untangled.
  18. Specification and Implementation of a Multi-Agent Calculus based on Higher-Order Functions. A. Clark, University of Bradford Technical Report. 1999.

    Similar report to that listed above. Different case study.
  19. EBG: A Lazy Functional Programming Language Implemented on the Java Virtual Machine. A. Clark. University of Bradford Technical Report. 1999.

    In the early days of Java there were few languages that used the Java VM as a target. This report describes work on a system called EBG that compiled a lazy functional language onto the Java VM and thereby allowed Java and EBG programs to co-exist. The report is interesting in that it describes how a functional language can be compiled to Java VM instructions by defining all the key components of the compiler in the functional language.
  20. A Semantics for Object-Oriented Design Notations. A Clark. University of Bradford Technical Report. 1999.

    At the time, graphical design notations like OMT and UML were increasingly popular. However there was little analysis of their semantics. This report uses concepts from Category Theory to develop a semantic domain and then to use an extended lambda-calculus to represent the semantic features.
  21. Proving Properties and Programs which Share. A. Clark. University of Bradford Technical Report. 1999.

    The analysis of program properties is essential to the production of high-quality systems. This paper makes a contribution to the analysis of imperative programs by proposing a model for aliasing.
  22. A Semantic framework for Object-Oriented Development. A. Clark. University of Bradford Technical Report. 1998.

    This report applies the Algebraic approach of modular composable behaviour specification to the lambda calculus. It gave rise to a handful of papers including: Object-Oriented Refinement and Proof using Behaviour Functions and Formal Refinement and Proof of a Small Java Program.
  23. Semantic Primitives for Object-Oriented Programming Languages. A. Clark. PhD Thesis, Queen Mary College, University of London. 1996.

    My PhD was sponsored by Marconi Research and was done part-time from 1989 to 1996. My supervisor was Peter Landin and my examiners were Bernard Sufrin and Russell Winder. The thesis is that you can reduce object-oriented languages down to a few basic primitives and then reconstruct the different types of OO language feature found in the wild. Peter Landin had a huge influence on my understanding of software during this time. As John Reynolds states in the preface to Theories of programming Languages: Peter Landin remarked long ago that the goal of his research was "to tell beautiful stories about computation". Peter's view was that to understand software you need systems that precisely, but not necessarily mathematically, describe the aspects you want to investigate. The SECD machine is one such system for describing how programming languages execute in terms of environments, closures and the like.
  24. The Formal Development of a Tableau Machine. A. Clark. University of Bradford Technical Report. December 1996.

    This paper was an exercise in constructing a program development method in terms of refining infeasible programs into feasible programs. The idea is that we provide an algebraic representation of the calculations we want to perform. These calculations may be infeasible in the sense that they cannot be performed by a conventional machine. Since the calculations are represented as data, they can be transformed using semantic preserving rules into calculations whose properties guarantee that they are feasible. The machine associated with the feasible calculations can be 'read off' the transformations. The notion of calculations is due to Peter Landin.
  25. ROO - A Model for Object-Oriented Reuse. A. Clark. University of Bradford Technical Report. 1996.

    This paper proposes a model for software reuse. Software components are modelled as state machines and reuse is achieved by behavioural matching.
  26. A Lazy Non-Deterministic Functional Language. A. Clark. Euclid 6.3 project MOSES Report. 1995.

    Euclid 6.3 was a European project much like Esprit or Framework N. The aim of the project was to address quality issues in the development of Knowledge Based Systems for military applications. As part of this work I was responsible for researching how rules systems could be improved. As a basis for this, I took KBS to be characterized by search strategies and therefore could be modelled using a non-deterministic lambda-calculus. This paper develops such a calculus and uses it to represent a standard KBS-style application.
  27. Transforming Sequences using Threaded Morphisms. A. Clark. University of Bradford Technical Report. 1995.

    Defining patterns of sequence transformations.
  28. Metaclasses and Reflection in Smalltalk. A. Clark. Marconi Research Technical Report. 1994.

    As part of my PhD I defined and implemented countless mini-OO languages in order to study how they worked and try out variations and extensions. Most of these implementations were done in Common Lisp. This report is typical of the many that were generated (but did not make it into the final thesis). This particular report is interesting because of the meta-circularity aspect of Smalltalk. I think that Smalltalk does not quite get the meta-circularity quite right, the ObjVLisp Model of Briot and Cointe seems a much better approach and I used it as the basis of XMF.
  29. A Basic Model Of KBS Software. A. Clark. Euclid 6.3 project MOSES Report. 1993.

    The Euclid 6.2 project MOSES addressed quality issues in the development of military KBS. My contribution to this project was to develop a computational model of KBS that could be used to define and analyze aspects of KBS quality. Since a key characteristic of KBS is search, a computational model based on non-determinism was developed and used to express terms relating to quality.
Home.