Software Development Methods
A course taught at the Faculty of Engineering in Foreign Languages (FILS), within the Information Engineering specialization. Its official title and course material were in English; this page presents the course as part of the coherent account of my teaching activity.
Key facts
- Institution: POLITEHNICA University of Bucharest
- Faculty: FILS – Faculty of Engineering in Foreign Languages
- Specialization: Information Engineering
- Year / semester: third year, second semester
- Language of instruction: English
- Official title: Software Development Methods
- Course coordinator: Luca Dan Șerbănați
- Laboratory / project: Andrei Vasilățeanu
- Structure: 2 lecture hours + 2 laboratory hours per week
- Total: 56 hours per semester
- Credits: 3
The place of the course in my teaching activity
This course belongs to the later stage of my teaching activity at FILS and expresses, in a concise form, an important part of the experience I accumulated in software engineering. Within a pedagogical framework accessible to undergraduate students, it brings together several themes that concerned me over the years: the software process, conceptual modelling, object-oriented analysis and design, the role of architecture and behavioural modelling, and the relationship among requirements, analysis, design, and implementation.
Although it is grounded in the object-oriented paradigm and in UML, the course is not limited to a simple presentation of techniques. It attempts to highlight what remains stable and general in software development methods: the need for modelling, separation of levels of abstraction, coherent documentation, and a controlled transition from the real world to implementable structures.
Objective of the course
The course explores methods and techniques for developing software systems from both theoretical and applied perspectives. Its guiding idea is that software development methods seek to optimize the software production process through prescribed activities, tools, and intermediate products, with the aim of improving software quality and the predictability of the development process.
The course material uses the object-oriented method as its main vehicle of presentation, with UML as the communication language for models and artefacts produced at the different stages of the life cycle. However, the emphasis does not fall exclusively on technique, but on what persists across all methods: problem analysis, conceptual modelling, design, documentation, and preparation for implementation.
Prerequisites and course profile
The syllabus places this course after subjects such as Object Oriented Programming, Algorithms and Data Structures, and Formal Languages & Compilers. It belongs to the category of conceptual courses: it does not aim merely at using languages or tools, but at developing a deeper understanding of abstract analysis, design, and modelling techniques.
Through its content, the course prepares students for roles such as business analyst, software analyst, or software architect, offering them a coherent framework for understanding how a software system is gradually constructed from problem to solution.
Course structure
1. Introduction to software engineering
The first part introduces the notions of system, information system, and software system, then discusses the specific nature of software as an engineering product, its complexity, the “software crisis,” and the typical causes of development failures. It then presents the notions of software engineering, software process, development methodology, and the relationship among process, notation, quality assurance, and CASE tools.
This section also analyses the main life-cycle models: the waterfall model, prototyping, iterative and incremental development, the spiral model, and then the Unified Process, with emphasis on iterations, risk reduction, architecture, and the role of use cases.
2. UML as the language of the methodology
Following the introductory section, the course presents UML as a visual modelling language for specifying, constructing, and documenting software-intensive systems. It introduces the main types of UML elements, the relationships among them, and the family of static and dynamic diagrams.
3. Foundations of object orientation
The second major section addresses the conceptual basis of object orientation: concepts, objects, types, classification, generalization, associations, mappings, roles, cardinalities, aggregation, and composition. The emphasis is not only on object-oriented programming, but on conceptual modelling of the domain and on the relationship among concepts, objects, and their UML representations.
4. Business Modelling
The course introduces business modelling as a necessary stage before software analysis proper. It discusses the purpose of the business model, the relationship between business modelling and software modelling, business processes, functions, agents, resources, and business rules. It then presents the main forms of documentation: business use cases, activity diagrams, the business object model, and the business domain model.
5. Requirements Analysis
The section devoted to requirements analysis covers functional and non-functional requirements, analysis artefacts, actors, use cases, scenarios, formats for describing a use case, and techniques for identifying actors and their goals. It presents both use-case diagrams and the textual documentation of main and alternative flows.
This section also introduces System Sequence Diagrams and operation contracts as means of moving from the system’s observable behaviour to the internal responsibilities of objects.
6. Domain analysis and the conceptual model
An important component of the course is the construction of the domain model: identifying conceptual classes, relevant attributes and associations, and clearly distinguishing between the conceptual model of the domain and the future software model. The course discusses simple techniques for identifying classes, the relationship between use cases and the domain model, and the role of class diagrams in object-oriented analysis.
7. Architectural design
The architecture section defines software architecture as the set of major decisions concerning system organization, structural elements, interfaces, connectors, and architectural styles. It introduces the concepts of component, connector, configuration, and architectural style.
The course then reviews classical styles: main program / subroutines, object-oriented systems, data-flow systems, data-centred architectures, layered architectures, virtual machines, client/server, and their variants. The final part also introduces patterns with an architectural or micro-architectural role, such as Facade, Observer, and Model-View-Controller.
8. Behavioural modelling and interactions
The final substantial part develops behavioural modelling: communication among objects, collaborations, interactions, sequence diagrams, and communication diagrams. The emphasis is on assigning responsibilities to classes and moving from scenarios and activities to collaborations among objects.
9. Responsibilities, collaborations, and design refinement
This area introduces techniques for assigning responsibilities, the relationship between collaboration and interaction, the use of sequence diagrams to discover objects, and the CRC Cards technique for structuring the important classes of the application.
10. A note on the course profile
The course material clearly shows that this was not simply a UML course. UML was used as a common language of expression, but the real purpose of the discipline was engineering-oriented: the controlled transition from understanding the problem and the business to requirements, the conceptual model, architecture, and object-oriented design.
Laboratory and project work
The syllabus shows that the course had a substantial practical component. Laboratories began with more technical Java topics—database access through JDBC, network programming with sockets, and Java RMI—and then moved to a sequence of analysis and design exercises and deliverables: business model, use-case model, system sequence diagrams and operation contracts, domain model, interaction diagrams, statecharts, application class diagram, and package diagram.
The project was individual, and homework assignments contributed gradually to the final project. From a pedagogical point of view, this is an important detail: students did not receive only theoretical notions, but were required to construct step by step a coherent set of models leading toward an implementable application.
Basic bibliography
- Luca Dan Șerbănați, Software Development Methods. Lecture Notes, FILS, 2009.
- R. S. Pressman, Software Engineering: A Practitioner’s Approach, 7th edition.
- L. D. Șerbănați, Integrating Tools for Software Development, Yourdon Press / Prentice Hall, 1992.
- G. Booch, J. Rumbaugh, I. Jacobson, The Unified Modeling Language. User Guide.
- M. Fowler, UML Distilled.
- C. Larman, Applying UML and Patterns.
Significance of the course
Viewed retrospectively, this course is representative of the way I understood teaching in my later years: not as the simple transmission of transient technologies, but as the formation of an engineering way of thinking about software. It combines classical elements of software engineering with UML techniques and with a broader view of the development process, close to systems engineering.
In essence, Software Development Methods is not merely a course about diagrams or object orientation. It is a course about the order that must be introduced into a complex process, about the controlled transition from reality to model and from model to software solution.