Discovering the foundations of the field at the Polytechnic of Bucharest (1970–1989)

The courses listed below belong to the first major stage of my teaching activity, roughly the first twenty years of my academic career.

Courses taught at Ovidius University of Constanța (1994–2004)

At Ovidius University I taught courses that covered three major directions: theoretical foundations of computer science, programming and compilation techniques, and software engineering. The list below brings together the courses taught, the years in which they were offered, and the study programmes for which they were intended.

• Formal Languages — 1994–1995
  Mathematics–Computer Science, year II.
• Systems Design and Implementation — 1994–1996
  Mathematics–Computer Science, year IV.
• Compiler Techniques / Compilers — 1994–2004
  Mathematics–Computer Science: years IV–V (1994–1997), year III (1995–2004).
  Computer Science: year III (2001–2004).
• Programming in Advanced Languages — 1996–1999
  Mathematics–Computer Science, year IV.
• Computer Programming — 1999–2004
  Computer Science, year I.
• Software Engineering — 2000–2004
  Mathematics–Computer Science, year IV;
  Computer Science, year III (2001–2004).
• Object-Oriented Programming — 2000–2004
  Computer Science, year II, semester I, 2h lecture + 2h lab;
  Mathematics–Computer Science, year III, semester I, 2h lecture + 2h lab.
• Web Programming — 2003–2004
  Computer Science, year IV.
• Modern Programming Techniques — 2003–2004
  MCTIM Master, year I.
• Computability — 2003–2004
  MCTIM Master, year I.

Course drafts for Ovidius University

• Outline for a Software Engineering course at Ovidius University.
• Prototype of the Java course at Ovidius University.
• Formal Languages ​​and Automata (Eng) — theoretical course on grammars, finite automata, stack automata and computability, taught at FILS in the period 2010–2012.
• Design Patterns (1999) — course on software design and reuse patterns.
• Design patterns in English taught at Ovidius University (2003) — an advanced course on design patterns in English, preparation for FILS.

Course taught at the Military Academy in Bucharest (1981–1982)

In 1981 and 1982 I taught a compilers course at the Military Academy in Bucharest, at a time when the former Military Technical Academy, dissolved in 1976, had been incorporated into the General Military Academy. The course was intended for students in Electronics.

Broadly speaking, the material was the same as the one I taught at the Polytechnic of Bucharest, Faculty of Control Engineering. I stopped teaching it when the young assistant Victor Patriciu, a graduate of the Polytechnic of Timișoara and one of those who had attended my course, was able to take it over.

• Compilers — 1981–1982
  Military Academy of Bucharest, Electronics Section. A course close in structure and content to the one taught during the same period at the Faculty of Control Engineering of the Polytechnic of Bucharest.

A coherent curriculum at the Faculty of Engineering in Foreign Languages (2004–2022)

The courses listed below belong to the last major stage of my teaching activity, roughly the final twenty years of my academic career. During the previous four decades I had taught in a more classical manner, mainly in programming languages, compilers, and theoretical computer science. The experience accumulated over those years allowed me to propose my own vision of how future software engineers should be trained.

During the period when I was head of department, I was able to enforce a curriculum designed to form genuine software engineers. It was not just a matter of accumulating isolated languages or programming techniques, but of following a coherent path: programming, development methods, software design, architectures and patterns, and an overall view of the field and its trends.

I taught the main courses in this sequence myself at first, in order to give them the desired coherence. I then gradually handed them over as I trained a few successors; the main continuator among them was Andrei Vasilățeanu.

In this context one should also place Web Application Development, taught in 2007–2011, through which I introduced into the curriculum the practical dimension of distributed web application development: client-side and server-side technologies, database access, MVC architecture, and web services.

Courses

• Programming Languages — the entry-level FILS course devoted to the introduction to programming, Java, and object-oriented thinking.
• Object-Oriented Programming — the second programming course at FILS, devoted to Java and the more advanced concepts of object-oriented programming.
• Formal Languages and Automata — a theoretical course on grammars, finite automata, pushdown automata, and computability, taught at FILS in 2010–2012.
• Compiler Techniques — a course on the foundations of programming languages and introductory compilation techniques, taught in year IV.
• Software Development Methods — a FILS course in the English track, devoted to software development methods, UML modelling, analysis, architecture, and object-oriented design.
• Méthodes du Développement du Logiciel — the French-language version of Software Development Methods, dedicated to modern software development methods, UML modelling, object-oriented analysis and design, and iterative development processes.
• Software Design Techniques — a course on software design and architecture, continuing Software Development Methods.
• Software Methodologies — a course devoted to software development methodologies: structured, object-oriented, agile, component-based, and service-oriented.
• Complements of Computer Science — an optional or advanced course with variable themes; in the recovered version presented here, the selected theme was Design Patterns.
• Software Architectures — an advanced course on software architectures, distributed systems, middleware, patterns, and enterprise integration.
• Web Application Development — a course taught at FILS in 2007–2011, devoted to client-server web applications: HTML/XHTML, CSS, JavaScript, servlets, JSP, JDBC, MVC architecture, and web services.

A coherent software engineering sequence

Part of the FILS curriculum formed a coherent sequence, from programming and development methods to architectures and reuse:

• Object-Oriented Programming — object-oriented modelling of applications
• Software Development Methods — the software development process
• Software Design Techniques — software design techniques
• Complements of Computer Science (Design Patterns) — reuse of solutions
• Software Methodologies — lessons from the history of software development
• Software Architectures — the organization of complex software systems
• Web Application Development — distributed web applications, from the client interface to server-side services and web services

Courses taught at Università “La Sapienza” in Rome (2007–2011)

After the attempt to have my engineering degree recognized in Italy — and the failure I have described elsewhere — I returned to the Faculty of Computer Engineering at La Sapienza, when they needed hourly-paid teachers for two introductory programming courses in the Corso di Laurea in Ingegneria Gestionale. I was welcomed enthusiastically by my colleagues and, for a few years (2007–2010), I was one of the two teachers in charge of these courses.

At the Università “La Sapienza” in Rome, within the Facoltà di Ingegneria, Corso di Laurea in Ingegneria Gestionale, I taught in Italian two successive first-year courses, conceived as a coherent sequence: from the basic notions of computing and algorithms to object-oriented programming in Java.

• Fondamenti di Informatica — year I, semester I. An introductory course in computing and programming devoted to the notion of the computer, data representation, algorithms, pseudocode, and the first concepts of programming in Java.
• Tecniche di Programmazione — year I, semester II. A continuation of the first-semester course, oriented toward object-oriented programming in Java: classes, objects, relations between classes, inheritance, abstract classes, interfaces, exceptions, collections, input/output, and graphical interfaces.

Teaching in the Erasmus Mundus DMKM programme (2010–2012)

In the last years of my university activity I also took part in the international Erasmus Mundus master programme Data Mining and Knowledge Management (DMKM), in which the Polytechnic University of Bucharest was a partner together with other European universities. In this framework I taught the course Software Methodologies in English.

• Software Methodologies — a course taught within the Erasmus Mundus DMKM master. It dealt with software development methodologies, software processes, life-cycle models, software engineering, Information Engineering, business modelling, and modelling techniques used in the development of information systems.