for object-oriented development based on the BETA programming language. ... gramming courses, and then object-oriented analysis and design in the software ...
Using Object-Orientation as a Common Basis for System Development Education JØRGEN LINDSKOV KNUDSEN, OLE LEHRMANN MADSEN Computer Science Department, Aarhus University, Ny Munkegade 115, DK-8000 Aarhus C, Denmark (E-mail: {jlknudsen,olmadsen}@daimi.aau.dk) (WWW: http://www.daimi.aau.dk/~beta/info)
SUMMARY
Object-orientation has a long tradition at the Computer Science Department, Aarhus University, starting with Simula in the early seventies. For more than 20 years there have been courses in object-oriented programming, including BETA, Smalltalk, Self and others. Recently objectorientation has started to be integrated in other parts of the curriculum such as in software engineering, distributed systems and databases. In this paper we report on this approach to teaching object-orientation. One of the advantages of object-orientation is that it provides an integrating perspective on the various areas to be taught. Besides providing a common conceptual framework, it also makes it possible to use common languages and tools that have a profound influence on the integration. Especially in the software engineering course, it has been possible to let the students experience an iterative software development method where they make a number of iterations through analysis, design and implementation. To do these iterations, it is necessary with good development tools like a CASE tool that supports code generation and reverse engineering. The Mjølner BETA System is used in the various courses as a common platform, but the students are also introduced to other object-oriented environments like Smalltalk, Self, Eiffel, and C++. The Mjølner BETA System that is a software development environment for object-oriented development based on the BETA programming language.
1.
Introduction
Object-oriented programming is becoming an integrated part of the curriculum of many educational institutions, and at many other places, it is currently being discussed whether or not to integrate object-orientation in the curriculum. Several questions need to be discussed when introducing object-orientation. Some of these are: Should a modern language or one that is used by industry be selected as the basis for the teaching? Should the first course introduce objectorientation or should this be delayed to a subsequent course. How should object-orientation affect other courses in, e.g. software engineering, databases, distributed programming, and parallel programming? In this paper, we shall discuss the experience with teaching object-orientation at the Computer Science Department, Aarhus University. Object-orientation has been part of the curriculum since the early seventies, when Simula[DMN67] was used. Since 1979, there has been graduate courses on object-oriented programming and since 1987, object-oriented programming has been part of the undergraduate courses. Since 1994, object-orientation has also been used in courses on software engineering, distributed systems and to some extent databases. The primary language used in these courses have been the BETA programming language[MMN93]. BETA is a modern statically typed, object-oriented language, and to complement this language, Smalltalk[GR83] and recently Self[SU95] have been used as examples
of dynamically typed, object-oriented languages. Also Scheme[AS85] has been used, with emphasis on how to build an object-oriented extension of Scheme. The main subject of this paper is to describe how object-orientation is used as an integrating foundation for courses in programming, software engineering, databases and distributed systems. This common foundation has made it possible to obtain a high degree of integration between these courses. Before object-orientation was introduced, these courses were rather isolated since different concepts and techniques were taught. At ECOOP'88 [KM88], we gave a first report on this approach to teaching object-orientation. The main message here was that it is more important to teach the underlying concepts of object-orientation than the actual language. In [Knu94], further experience was reported including experience from other institutions. One of the main advantages of object-orientation is that it provides an integrated perspective upon a number of activities in system development. Modern software development methods [RBP91, Boo91, CY91, MMNS93] are based on object-orientation, since object-orientation makes it possible to use the same conceptual framework for analysis, design and implementation. Similarly the same basic language constructs such as class, subclass, virtual function, etc. can be used in all three phases. By teaching object-oriented programming in the programming courses, and then object-oriented analysis and design in the software engineering courses, it is possible to obtain a better integration of these courses. The same integration can be obtained with database courses and distributed systems courses. By using an object-oriented data model in the database course, the relations between programming and software engineering becomes more clear. Similarly by teaching distributed systems based on objects, the students can make better use of their skills from the programming courses. To obtain the full benefit of object-orientation it is necessary to select languages and tools that are tightly integrated. Object-oriented methods are based on an iterative development approach where the designers alternate between the different phases such as analysis, design and implementation. Without tools to support code generation for design diagrams and reverse engineering from code to diagrams, it is very difficult to support object-oriented software development in practice. For a database course, it is possible to concentrate on the database issues if the data definition language is the same language as the one being used in the programming classes, and if the model of persistence is object-oriented and at the same time type orthogonal. Finally for teaching distributed systems, it is an advantage if as many aspects as possible has been covered by the programming courses (again relying on the same model of object-orientation). One example of this is concurrency. If concurrency and synchronisation have been covered by the programming covered already, these issues are not be new to the students when studying distributed systems. Besides reporting on the experience with integrating object-orientation in many different courses, we will also comment on issues such as selection of programming language and whether or not to introduce object-oriented programming as the first language.
2.
Selection of Programming Language
An important part of this discussion of software development education is which object-oriented language to select for the courses. Some people argue that the students should be taught a programming language that is being heavily used in industry. C++ [Str91] is then the only choice, although Smalltalk and Java[GA96] are becoming contenders here.
Others have the opinion that students should be taught a modern programming language, probably more than one. There are a number of arguments for this approach: •
The student's level of abstract thinking will be better. It is a well-known principle that students should be trained in designing abstractions. By knowing abstraction mechanisms from modern languages, their ability to use less abstract languages will also be improved. Put in another way: by learning a modern language, the students get a richer programming language vocabulary that is useful no matter which language is used in practice.
•
The students will use less time on irregular and complicated details of an old-fashioned language, and the students will be aware of the shortcomings of an old-fashioned language.
•
The students should be prepared for the future, and modern language constructs will eventually spread into industry. Students with an education in modern languages will usually have no problems in learning a specific old-fashioned language being used in industry. The other way around is much more difficult.
Many people think that it does not matter which programming language is being used for teaching since the emphasis in teaching should be on concepts, principles and techniques. It is true that the main emphasis in a programming course should be on concepts, principles and techniques and not on the actual language used (see, e.g. [KM88]). On the other hand, the choice of language impacts the effects of the teaching. The programming language should support the concepts, principles and techniques being taught as much as possible, since the students otherwise will use too much time on realising the concepts, principles and techniques in the given language. And no matter how good the teaching is, the actual languages being used by the students will have a huge influence on their abilities to design well-structured programs. As is the case for natural languages, it is hard to communicate concepts without a language to express the concepts in terms of sentences and words. BETA is a good example of a modern object-oriented programming language and it has been used for teaching object-oriented programming at a number of universities. BETA is based on a few powerful mechanisms and a number of constructs found in other languages are built from first principles. On example is the pattern mechanism that unifies class, procedure, function, process, exception, etc. Some people find it hard to teach programming using a language based on first principles and prefer a language with special syntax for most of the constructs being taught. However, using a language based on first principles makes it easier to emphasise that an important aspect of programming is designing new abstractions such as data structures with associated operations and control structures. This is harder if the students become used to use only the built-in data structures and control structures.
3.
Object-Oriented Programming
It should be emphasised, that object-orientation started with object-oriented programming [Ma96]. The success of object-orientation started out with the success of languages like Simula, Smalltalk, Flavours, Loops, C++, etc. Later object-orientation emerged into other areas such as software engineering, analysis and design methods, databases and distribution. We strongly believe that good skills in object-oriented programming are the basic foundation for applying object-orientation in other courses.
Since object-oriented programming is considered the basis for teaching object-oriented technology, it puts some requirements on the programming courses. The programming courses must introduce object-orientation in such a way that the concepts, languages and tools are applicable in the other courses. This emphasises that a modern language should be used as a basis. In the Scandinavian tradition for object-oriented programming based on Simula and BETA, design and modelling have always been considered important. Simula was designed as a simulation language and therefore it is important to be able to create models of the part of reality being simulated. The emphasis on modelling and design is a central part of the Scandinavian approach to object-orientation [KLMM94, chap. 4]. This implies, that it is of secondary importance in the object-oriented programming course(s) to teach the syntax and semantics of the programming language and how to realise algorithms and data structures in that language (although they naturally should be taught these issues). In the design of BETA it has been considered central to develop a conceptual framework that can be used in modelling and design and which is richer than the actual programming language. The conceptual framework is the means of perspective used by programmers1 to understand the concepts and phenomena of a given problem domain, to express design of new artefacts and to organise implementations. It is important that the conceptual framework is richer than the programming language, since the programmer should be aware of the limitations of the modelling language. The conceptual framework developed together with BETA is independent of BETA and can be used together with other languages as well, although there of course is a tight connection. The conceptual framework discusses notions such as concept and phenomenon, means for organisation of knowledge including classification and composition, different forms of classification including tree-structured classifications, multiple classifications, several independent classifications and dynamic classifications, different forms of composition including part-whole composition, reference composition, etc. Most books on objectorientation touch these issues to a more or less degree, but in most cases in a superficial way. The conceptual framework for BETA is presented in [MMN93, KLMM94] and its role in teaching is discussed in [KM89]. The emphasis on modelling and design as part of the programming course has proved its success in practice. The students are able to construct good designs and they have good feeling of when to use inheritance and when to use composition. They are aware that inheritance is not just a code sharing mechanism but a means for representing classification hierarchies in a programming language. Of course they are also aware of the benefits with respect to reuse of code. The emphasis on modelling and design is also an important basis for subsequent courses in software engineering and databases where modelling and design are central. A good foundation from the programming course is a necessary precondition for these courses. 3.1
Other Issues
The object-oriented programming course is the second programming course taken by the students. They are introduced to algorithms and data structures in the first programming course using a modern procedural language designed for this course. The object-oriented programming course then builds on this basis by initially introducing the BETA language. This situa1
We use the term programmer in a broad sense meant to cover modelling during analysis, design and implementation as well as data modelling in databases.
tion is not ideal, since it would be an advantage to introduce object-oriented programming also for introductory programming. BETA is used for introductory programming at a number of universities, but it is not within the scope of this paper to discuss these experiences. In the current setting, the situation is acceptable, most importantly because the language being taught in the introductory programming course is a modern language, emphasising elegant procedural and data abstractions. A major goal of the object-oriented programming course is programming in-thelarge. Object-orientation is considered well suited for this purpose and a major aspect in the teaching is that the students shall make heavy use of class libraries and frameworks, just as design of libraries and frameworks play a central role. The most used frameworks in the teaching are the graphical user interface frameworks from the Mjølner BETA System and in this way the teaching of user interface construction is combined with the teaching of libraries and frameworks. The Mjølner BETA System has a platform independent user interface framework that is implemented for Motif, Windows 95/NT and Macintosh. It is thus possible to develop the user interface on one platform and easily recompile it to one of the other platforms. The availability of the teaching system on PCs and Macintosh is a major advantage for the teaching. Most students have their own home computer and it is a great advantage if they can run the software at home. The Department attempts to offer most of the software used for teaching for Linux based PCs, since this is the most popular system used by the students. In addition the Mjølner BETA System is available to the students on Windows 95/NT and Macintosh. Exception handling is another aspect of programming in-the-large and is therefore a central part of the object-oriented programming course. Related to exception handling and programming-in-the-large is the issues of software testing that is also covered by this course. To introduce the students to the issues of realistic applications, a need occurs for discussing the issues of information being stored between program executions, or being shared between different programs. This implies that this course introduces the issues of object persistence and object-oriented databases (more on this later). A final issue to be mentioned is concurrent programming. Our experience with teaching programming is that concurrent programming should be introduced as early as possible. It is a great advantage that the students as early as possible learn to structure a program as a collection of concurrent co-operating components. Concurrent programming should not be introduced as a complicated add-on to sequential programming, but as a natural and important element of programming. The experience from teaching Simula has been that the coroutine mechanism of Simula should be introduced as early as possible and that the quasi-parallel mechanism of Simula was a good vehicle for teaching the students that programs are not just sequential. We thus think that concurrency should be a requirement for an object-oriented language used for teaching.
4.
Software Engineering
In the course on software engineering, the main emphasis is on participatory design, proto– typing and methodologies. Like object-orientation, participatory design is a discipline that has a long tradition in Scandinavia and started with a joint project between the Norwegian Iron and Metal Workers Union and Norwegian Computing Centre led by Kristen Nygaard (who was one of the creators of Simula). Participatory design among others involves prototyping and iterative software development, so emphasis has been on iterative methods although traditional
waterfall methods and Structured Analysis and Design (SA/SD) were also taught. In the course, the problems with the waterfall methods have always been emphasised. Various different tools were used to support the teaching. For developing fast prototypes, tools like HyperCard were used. For database support, Oracle was used. It was not realistic to use a professional CASE tool to support, e.g. SA/SD and instead the students were using general drawing tools to create diagrams. The course has always been successful in teaching participatory design and the students have been able to carry out the development of a prototype together with some end user organisation. The difficult part of the course has been to have the students experience a complete software development process resulting in the development of a full application. As mentioned the students have developed a prototype, but it was not possible to complete this prototype into a complete application. Most courses in software engineering have suffered these problems, since the traditional methods are not well suited for iterative software development. In addition the concepts and techniques in analysis, design and implementation were quite different just as it is difficult to obtain good tool support. One result of this is that the students have difficulties combining the insights from the programming and software engineering courses. In the programming courses they learn to program and in the software engineering course they learn about analysis and design, but rarely come to complete the implementation of their design. This situation is typical for many schools; it is not just a phenomenon at Aarhus University. At other schools we have experienced a worse situation. Here the software engineering courses practice what Erik Dybdal has named the funnel method: the students learn a lot of analysis, some design and very little implementation and have severe difficulties in understanding the overall process. The authors of this paper are responsible for the object-oriented programming course at the department and the above may be read as a critique of the software engineering course. This is not the intension. There is enough material to fill out the time in the programming course as well as the software engineering course. As mentioned the software engineering course has put the main emphasis on participatory design and fast prototyping and there is simply not enough time to carry out a complete project going through all phases of a software development project. To improve on this situation, the groups responsible for the programming course and software engineering courses in 1992 decided to investigate the possibilities of obtaining a higher degree of integration between the courses, basing the integration on object-orientation. This goal was actually part of a more ambitious goal set up by the DEVISE project at the computer science department. The DEVISE project was formed based on three research groups in programming languages and environment, system development and formal methods based on high level Petri nets. The goal of this project was to improve the quality and efficiency of development of large software systems. Research in software development is often carried out by groups each of which are studying one aspect of software development and few research groups consider the entire process, resulting in a lack of integration. The situation in research is quite analogous to the above described situation in teaching with lack of integration between the courses in the different areas. The goal of the DEVISE project was to improve on this situation including improving the result of the teaching. In 1992, object-oriented analysis and design were introduced in the software engineering course based on the books by Coad & Yourdon [CY91] and later [MMNS93]. At the methodological level this gave some improvements since the students were now able to use the same
concepts through analysis, design and implementation. It was, however, difficult to practice an iterative method due to poor tool support. In the beginning the OOA tool for the Macintosh was used, but it was not considered acceptable since it was slow and did not support code generation and reverse engineering.2 Often the students preferred to use a standard drawing tool. A major activity in DEVISE is development of new tools. The Mjølner BETA System was originally developed in a Nordic project called Mjølner [KLMM94] with participation by the programming language group and resulted in a programming environment based on the BETA language. The software development group had a long tradition with participator design and fast prototyping. One of the goals of DEVISE was to extend the Mjølner BETA System with tools that could be used by the software engineering group for participatory design and fast prototyping. These tools should be integrated with the program development tools such that the students would experience a high degree of integration between the programming and software engineering courses. A major requirement of the tools was that they should support an iterative software development method. Starting in 1994, the following tools from the Mjølner BETA System are used by the students: •
A code browser and structure editor. These tools are already introduced in the programming course and thus not new for the students.
•
An object-oriented CASE tool [CS96]. The CASE tool supports diagrammatic notation for BETA. The notation is similar to OMT, but the semantics of the diagrams are defined by BETA. This means that the tool directly supports code generation and reverse engineering. Initially the students may create class and object diagrams. Since the diagrams are just another syntax for BETA, the underlying BETA code is immediately available and the students can extend the BETA code to an initial prototype. If the structure of the code is changed during implementation, it is possible to obtain the corresponding diagrams, that is reverse engineering is directly supported.
•
A direct manipulation interface builder. The interface builder is similar in functionality to many other interface builders and allows you to construct user interfaces by direct manipulation. The interface builder constructs a BETA program with slots to be filled-in with the application code. The structure of the application being generated is symmetric with respect to the interface and the application. The developer may start from either end. In addition, reverse engineering is supported in the sense that the developer may go back and change the interface part.
The course as before teaches participatory design, fast prototyping and software development methods, but now based on object-orientation. The students will have to carry out a realistic software development project with real users (co-operation with companies and institutions outside the university setting) where they go through analysis, design and implementation in a number of iterations and they will have to develop their prototype almost to a final application. At the end they will have to deliver analysis and design diagrams that are consistent with their implementation. It is not mandatory for the students to use the Mjølner BETA tools, but they can use other tools. The use of object-orientation as a means for integrating the programming and software engineering course has come to stay (until something better shows up). From a methodological 2
Newer versions of the OOA tool may have improved on this.
point of view it is clearly superior to the traditional methods. The students can build directly on their knowledge from their programming course. At this point it should be emphasised that a main emphasis in the programming course is on modelling and design. It is mandatory that the students have training in object-oriented programming with emphasis on modelling and design before they start on object-oriented analysis and design. They must be well trained in the basis. The experience with the course has so far been satisfactory. The students have been able to go through a number of iterations of their project and to actually implement a running application in most cases. The very tight integration with the programming course with respect to the use of object-orientation and the tools being used in the two courses have been an advantage. In addition, the good support for code generation and reverse engineering has clearly made it easier for the students to try an iterative method in practice. The tools used were in their first versions (prototypes) and were not commercial prod3 ucts . In a teaching situation, you will often use initial versions of new advanced tools and these will have errors, so it is important that the organisation of the course is prepared for this situation, as it in general is important that there is an efficient course organisation to take care of unforeseen problems and inconveniences. Compared to commercial products, some of the tools do not have as many bells and whistles, but this is less important in the above teaching situation where support for iterative development and tool integration is much more important to the success of this course.
5.
Persistence and Databases
There is no database course in the curriculum. Instead the teaching of databases is handled in part by various different courses. In the first year programming course, the students are introduced to a relational database system that has been specially designed for this course. Here the students learn about the basic properties of relations and an associated simple and clean query language. In the software engineering course the students made use of Oracle to build their prototypes. None of the courses are, however, devoted to the area of databases. The students may later in their study take a graduate course in databases. The lack of a special database course is in the opinion of the authors a weakness in the curriculum. Starting in 1991, aspects of object-oriented database modelling have started to become part of the programming course and the software engineering course. Programming, methodologies (analysis and design) and databases have a common denominator in the form of modelling and design. With object-orientation it has become possible to use the same conceptual framework for modelling and design. This means that the modelling and design issues being taught in the programming course are immediately useful for databases as for methodologies. It is thus possible to move slowly into the area of databases from the programming course. In the programming course this is done by introducing the notion of persistence of objects. Here it is possible to concentrate the teaching on which objects should be persistent and which should be transient, and how to store objects in a persistent store. The modelling aspects are the same as for the programming part. BETA supports a simple and easy to use persistence mechanism, and the students can easily save their objects in a file. Before persistence was introduced it was difficult to make good projects for the students, since it was a lot of work to save objects on a file. Often this was not done, and the exercises were not realistic, since objects only survived during the exe3
Most of the tools will eventually be products of Mjølner Informatics.
cution of the program. Now the students can easily build applications creating objects and saving them in a persistent store and read them again when later running another application, or the same one. From a methodological and teaching point of view, we find it important that persistence is type orthogonal, i.e. that all objects can be saved in a persistent store. When designing classes/objects, part of the design is to decide which objects are persistent and which are transient, and this decision cannot be taken early in a project. When the students have obtained experience with using a persistent store, they are introduced to databases in the form of object-oriented databases. Since the students at that time are used to modelling and persistence it is possible to concentrate on new issues such as transactions, concurrency control, notifications, etc. For this purpose, an object-oriented database based on BETA is used. This OODB is implemented on top of the persistent store for BETA and adds concurrency control, transactions and notifications. In a teaching situation, it is clearly an advantage that persistence and databases can be used based on the same language as the students have been using during the programming course. In the database part, the students face a situation with several users of the database. It is therefore an advantage if they have some familiarity with concurrent and distributed programming and this is best obtained in our opinion by using a programming language that supports concurrency and distribution. As mentioned above, there is no special course for databases and the current curriculum should leave more time for data bases. Since there is a long way to go before object-oriented databases becomes as wide spread used as relational databases or even replaces them, the students should of course also be introduced to relational databases. We think, however, that this is best done after they have learned about object-oriented databases. In addition the students should learn how a relational model and/or entity-relationship model may be realised as an object-oriented model and what the differences and similarities are.
6.
Distributed Systems
The Mjølner BETA System is also used in the course on distributed programming, but to a less extent than the courses mentioned above. The distributed systems course has one part concentrating on modelling of highly concurrent systems including protocols using High-level Petri Nets [Jen92]. Another part is devoted to more low-level aspects such as RPC, client/server, distributed file systems, etc. As a practical exercise, the students have to implement a distributed application. For this purpose they use the process library from the Mjølner BETA System that supports RPC, remote shells, etc. on UNIX. Since the students already are familiar with structuring applications into a set of concurrent components, they do not have to start by learning about these issues including threads and synchronisation. Instead they can concentrate on issues related to distribution, i.e. process communication, naming schemes, and error handling. When starting from C or C++, issues like concurrency, threads and synchronisation have to be considered and are in practice only available as extensions of C and C++. We think that is an advantage if the students are familiar with these issues before learning about distributed systems. The Mjølner BETA System is currently not used in an optimal way in the distributed systems course. In addition to the process library used in the course there is more high level distribution library that makes it easy to implement distributed applications. The distribution library has abstractions corresponding to network nodes, processes in nodes and name spaces. The li-
brary supports creation of processes on remote nodes and objects may transparently refer objects in processes on remote nodes. The library is implemented via proxy objects that takes care of the communication with remote nodes. The rationale for just introducing the process library is that it is more close to the situation in the real world where implementation of distributed systems involves a lot of low level coding. We think that the students should also experience how easily distributed applications can be implemented by using proper abstractions.
7.
Conclusion
We have described how object-orientation has been used as an integrating basis for courses in programming (in-the-large) including concurrent programming, software engineering, databases, and distributed systems It has been argued above, that it is important to select integrated tools and languages to support the teaching. In this way the students will be able to obtain the main benefit from object-orientation. This argument, however, is also true for practical software development. If the full benefit of object-orientation is to be obtained, the software developer should use tools and languages that are fully integrated [Mad96]. In practice, the developer/company is, however, often required to used a specific programming language, a specific method, CASE tool or database system. This makes it difficult to obtain the full integration. These restrictions are, however, not present for teaching. Here the best possible tools and languages should be selected. In this way the students will learn the state-of-art and how well tools and languages can support software development. Acknowledgements The systems development course is organised by Susanne Bødker, Kaj Grønbæk and Morten Kyng; the distributed systems course by Søren Christensen and Kurt Jensen; and the program– ming course by Jørgen Lindskov Knudsen and Ole Lehrmann Madsen. Jakob Bardram, Henrik Bærbak Christensen, Michael Christensen, Kaj Grønbæk, Jørgen Lindskov Knudsen, Stephan Erbs Korsholm, Morten Kyng, Ole Lehrmann Madsen, Elmer Sandvad, and Henrik Røn were involved in discussing requirements to the tools to be used in the software development course, including a pre-evaluation project of the tools, and constant evaluation during the course. The actual tools were mainly implemented by Michael Christensen, Henry Michael Lassen, and Elmer Sandvad, but with contributions from many other people in the DEVISE project and Mjølner Informatics. Finally the many students that have participated in the courses deserve special thanks! Opinions expressed in this paper may not necessarily be shared by the above mentioned people.
8.
References
[AS85] [Boo91] [CS96]
H. Abelson, G.J. Sussman: Structure and Interpretation of Computer Programs, MIT Press, 1985. G. Booch: Object Oriented Design with Applications. Redwood City, CA: Benjamin Cummings, 1991. M. Christensen, E. Sandvad: Integrated Tool Support for Design and Implementation, Nordic Workshop on Programming Environment Research, Aalborg, May 29-31, 1996.
[CY91] [DMN67]
P. Coad, E. Yourdon: Object-Oriented Analysis (2nd ed.). Yourdon Press, 1991. O.-J. Dahl, B. Myhrhaug, K. Nygaard: SIMULA 67: Common Base Language. NCC Publ. S22, Norwegian Computing Centre, Oslo, Norway, 1967. [GA96] J. Gosling, K. Arnold: The Java Programming Language, Addison-Wesley, 1996. [GR83] A. Goldberg, D. Robson: Smalltalk-80: The Language and it's Implementation. Reading, MA: Addison-Wesley, 1983. [Ken92] K. Jensen: Coloured Petri Nets – Volume 1: Basic Concepts. EATCS Monographs on Theoretical Computer Science, Springer-Verlag, 1992. [KLMM94] J. L. Knudsen, M. Löfgren, O. L. Madsen, B. Magnusson: Object-Oriented Environments - The Mjølner Approach. Prentice-Hall, 1994, ISBN 0-13-009291-6 [KM88] J. L. Knudsen, O. L. Madsen: Teaching Object-Oriented Programming is more than Teaching Object-Oriented Programming Languages. Proc. ECOOP'88, Oslo, Norway, Springer Lecture Notes in Computer Science Vol. 322 1988. [Knu94] J. L. Knudsen (ed.): Teaching Object-Oriented Methodology and Languages. In [KLMM94]. [Ma96] O. L. Madsen: Open Issues in Object-Oriented Programming. Software — Practice and Experience, Vol. 25(S4), S4/3-S4/43 (Dec. 1995). [Mey91] B. Meyer: Eiffel: The Language. Prentice Hall, 1991. [MMN93] O. L. Madsen, B. Møller-Pedersen, K. Nygaard: Object-Oriented Programming in the BETA Programming Language. ACM Press/Addison Wesley, 1993, ISBN 0201-62430-3. [MMNS93] L. Mathiassen, A. Munk-Madsen, P.A. Nielsen, J. Stage: Objekt-orienteret Analyse. Marko, 1993. [RBP91] J. Rumbaugh, M. Blaha, W. Premerlani, F. Eddy, W. Lorensen: Object-Oriented Modelling and Design. Englewood Cliffs, NJ: Prentice Hall, 1991. [Str91] B. Stroustrup: The C++ Programming Language (2nd ed.). Addison-Wesley Publishing Company, 1991. [SU95] R.B. Smith, D. Ungar: Programming as an Experience: The Inspiration for Self. Proceedings of ECOOP'95, Springer Lecture Notes in Computer Science, Vol. 952, Springer-Verlag, 1995.
