Generative and Component-Based Software Engineering

Despite advances in software engineering and process methodologies over the past decades, not many IT projects seem particularly well adapted to today's fast-paced world. Software developers must start to acknowledge change and even uncertainty as a given, rather than the exception that should be studiously avoided, and they must adapt their techniques accordingly. Some business domains have seen attempts to address this situation. Several workflow vendors, for instance, have been marketing change and end-user programmability as major assets of their products. But, in general, they have been strangely ignorant of (good) modern software engineering practices, and the results have not really lived up to the claims. But we may expect a revival on a grander scale: the ability to (re) define the business logic on the fly is becoming a crucial asset when businesses re-align their core processes around the Internet. The Internet is transforming the way we envision and design applications. While we could build yesterday's simple Web applications with, let's face it, primitive techniques, this is simply no longer true. High-volume databases, long-term transactions, interoperability, distributed objects, re-use, these are some of the technical issues that must be dealt with. But the real challenge will be to leverage all this technology: we must empower the user to set up, maintain and change his applications more easily. We need dynamic systems, where applications can be changed at run-time in a high-level way, preferably by end-users. Above all, we need appropriate architectural techniques. In this paper we explore the use of dynamic object models. It turns out that the basic concepts are fairly simple. As for the difficulties, we can borrow solutions from many disciplines in computer science. If we do it right, we can even make the system work for itself.

[1]  Don S. Batory,et al.  Scalable software libraries , 1993, SIGSOFT '93.

[2]  David A. Moon,et al.  Object-oriented programming with flavors , 1986, OOPLSA '86.

[3]  Don Batory,et al.  Implementing large-scale object-oriented components , 1999 .

[4]  David Notkin,et al.  Using C++ Templates to Implement Role-Based Designs , 1996, ISOTAS.

[5]  Don Batory,et al.  A programming language for writing domain-specific software system generators , 1996 .

[6]  Ian M. Holland,et al.  Specifying Reusable Components Using Contracts , 1992, ECOOP.

[7]  James O. Coplien,et al.  Curiously recurring template patterns , 1995 .

[8]  Bjarne Stroustrup,et al.  The Annotated C++ Reference Manual , 1990 .

[9]  G. G. Stokes "J." , 1890, The New Yale Book of Quotations.

[10]  Ole Lehrmann Madsen,et al.  Object-oriented programming in the BETA programming language , 1993 .

[11]  David Notkin,et al.  Using role components in implement collaboration-based designs , 1996, OOPSLA '96.

[12]  John C. Mitchell,et al.  F-bounded polymorphism for object-oriented programming , 1989, FPCA.

[13]  Kent Beck,et al.  A laboratory for teaching object oriented thinking , 1989, OOPSLA 1989.

[14]  Martin Odersky,et al.  Do Parametric Types Beat Virtual Types , 1998 .

[15]  Ian M. Holland,et al.  Contracts: specifying behavioral compositions in object-oriented systems , 1990, OOPSLA/ECOOP '90.

[16]  Yannis Smaragdakis,et al.  Object-oriented frameworks and product lines , 2000, SPLC.

[17]  Bjarne Stroustrup,et al.  C++ : programovací jazyk : The C++ programming language (Orig.) , 1997 .

[18]  Krzysztof Czarnecki,et al.  Generative programming - methods, tools and applications , 2000 .

[19]  Brian Foote,et al.  Designing Reusable Classes , 2001 .

[20]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .