Requirements-to-Design-to-Code (R2D2C) is an approach to the engineering of computer-based systems that embodies the idea of requirements-based programming in system development. It goes further, however, in that the approach offers not only an underlying formalism, but full formal development from requirements capture through to the automatic generation of provably-correct code. As such, the approach has direct application to the development of systems requiring autonomic properties. We describe a prototype tool to support the method, and illustrate its applicability to the development of LOGOS, a NASA autonomous ground control system, which exhibits autonomic behavior. Finally, we briefly discuss other areas where the approach and prototype tool are being considered for application. 1.

Abstract: Modern information systems development is a complex task for it must fulfill a large variety of applicationand architecture-oriented requirements. Furthermore, such requirements often are a moving target for the developer, not only because the system has to stay open to a constantly changing application domain, but also because new requirements are added during the extremely long lifetime of such information systems. To make things worse, modern information systems are operated in a 24x7-modus which generates the pressure of highly dynamic, almost online system evolution. A main source of problems such development projects struggle with originates from the lack of a systematic subdivision of large software systems into manageable modules. As a consequence developers are traditionally involved in a complex patchwork of manual efforts to keep the various parts of the system in sync with each other and with the system’s requirements. In this paper we outline our approach to information system development which is based on a model for Conceptual Content Management (CCM). Our CCM approach profits from the dynamic, model-driven generation of smaller modules, which can be combined automatically into the full system. The generation process uses a CCM model of the application domain(s) from which our compiler framework dynamically generates the schema-dependent parts of the system. Due to the dynamic nature of this generation process, we are able to provide adequate support for both schema evolution and personalization of such a system. We have successfully employed the CCM approach to the development of complex web information systems. We give a brief account of CCM development and present an application example. 1

Abstract. Database modeling is based on the assumption of a high regularity of its application areas, an assumption which applies to both the structure of data and the behavior of users. Content modeling, however, is less strict since it may treat one application entity substantially differently from another depending on the instance at hand, and content users may individually add descriptive or interpretive aspects depending on their knowledge and interests. Therefore, we argue that adequate content modeling has to be open to changes, and content management systems have to react to changes dynamically, thus making content management a case for dynamic system generation. In our approach, openness and dynamics are provided through a compiler framework which is based on a conceptual model of the application domain. Using a conceptual modeling language users can openly express their views on the domain's entities. Our compiler framework dynamically generates the components of an according software system. Central to the compiler framework is the notion of generators, each generating a particular module for the intended application system. Based on the resulting modular architecture the generated systems allow personalized model de nition and seamless model evolution. In this paper we give details of the system modules and describe how the generators which create them are coordinated in the compiler framework. 1

Computer science as a field has not yet produced a general method to mechanically transform complex computer system requirements into a provably equivalent implementation. Such a method would be one major step towards dealing with complexity in computing, yet it remains the elusive “holy grail ” of system development. Currently available tools and methods that start with a formal model of a system and mechanically produce a provably equivalent implementation are valuable but not sufficient. The “gap” that such tools and methods leave unfilled is that the formal models cannot be proven to be equivalent to the system requirements as originated by the customer. For the classes of complex systems whose behavior can be described as a finite (but significant) set of scenarios, we offer a method for mechanically transforming requirements (expressed in restricted natural language, or appropriate graphical notations) into a provably equivalent formal model that can be used as the basis for code generation and other transformations. While other techniques are available, this method is unique in offering full mathematical tractability while using notations and techniques that are well known and well trusted. We illustrate the application of the method to an example procedure from the Hubble Robotic Servicing Mission currently under study and preliminary formulation at

Commercial of-the-shelf (COTS) code generators have become an integral part of modern commercial software development. Programmers use code generators to facilitate many tedious and error-prone software development tasks including language processing, XML data binding, graphical component creation, and middleware deployment. Despite the convenience offered by code generators, the generated code is not always adequate for the task at hand. This position paper proposes an approach to address this problem. We utilize the power of Aspect Oriented Programming (AOP) to enhance the functionality of generated code. Furthermore, our approach enables the programmer to specify these enhancements through an intuitive graphical interface. Our proof-of-concept software tool provides event-handling AspectJ aspects that enhance the functionality of the XML processing classes automatically generated by a commercial of-the-shelf code generator, Castor. 1.

Database schemata evolve continuously in real-world applications. Schema transformation modules facilitate the communication between incompatible systems with different Asset models. Because of the openness and dynamics properties of database schemata in Conceptual Content Management Systems, schema transformation modules have to be generated dynamically based on schemata changes. To do so, a Schema transformation module generator will be developed. Within the planned generator, model mappers are used to match outdated and revised database schemata using name based matching(similar to schema matching technique) and to compute the mappings between them. The Strategy pattern is followed to design an interface for a family of model mapping algorithms. One implementation for a model mapper algorithm is provided. The Adapter pattern is used to convert the interface of an outdated class to the interface of a revised class according to the chosen model mapping algorithm. Transformation code is generated for classes using Java meta model and after target code is generated in Java, the instances of schema transformation module symbol table are filled.

I am deeply indebted to my advisor Prof. Anand Tripathi for providing the vision for this project. Without his continuous support, and patience, this task would have become impossible. Everything that I have learned over these years is because of my close interactions with him while working on the various projects in the group. It has been absolutely priceless. My parents encouraged me to take up this challenge, and were by my side during the difficult periods. Aai and Baba, it is because of you that I have reached this stage. Special thanks go to Tanvir Ahmed. He helped me get started on the middleware during the early stages of this thesis. I want to thank the committee members, Prof. David Lilja, Prof. Eric Van Wyk, and Prof. Abhishek Chandra for serving on my committee. It would have been impossible to work on this thesis without the financial support provided