Ateneo - UPO

The course deals with the stages of the development of software systems: specification, design, implementation, validation and verification, maintenance. Moreover, the UML language for the specification and design of systems is introduced. The activity in the laboratory consists of preparing UML diagrams by means of a specific editor, and their translation into code.

- I. Sommerville, "Software Engineering", Addison Wesley
- M. Fowler, "UML distilled", Addison Wesley

The student must know:
1) the steps necessary to realize a software system, from the customer's requests, to the delivery, according to the engineering process;
2) the UML diagrams necessary to model the application domain, the requirements, the architecture, and the behaviour of the system;
3) terminology of engineering.

The student must be able to:
1) organize a working process according to the steps of Engineering, identifying and defining all the information necessary to implement the system (requirements, architecture, behaviour);
2) represent such information in terms of UML diagrams in order to be read by other developers, and write the code respecting the contents of such diagrams;
3) understand and use the language of engineers.

Knowledge acquired in the Programming paradigms course and Databases course.

The course consists of frontal lectures and laboratory lectures.
Frontal lectures take 32 hours.
Laboratory lectures take 16 hours.

Modality:
the frontal lectures explain the stages of Engineering and how they can be applied to the development of a software system.
Moreover the UML language is presented from both the formal point of view and the application point of view, showing how it can be used to model the application domain, the requirements, the system architecture and behaviour, and to support code writing.
The laboratory lectures are dedicated to preparing a project where UML diagrams are defined and translated into code.

Tools:
A specific case study is used during the frontal lectures to show how to design the system, starting from the elicitation of requirements from the application domain. The case study is gradually developed during the lectures about the practical application of Engineering stages and UML. The goal of the case study is providing a concrete example of application of the procedures presented in the course.
The preparation by the students of their own project in UML, is required during the laboratory lectures. Such project must have the same contents in terms of specification and design. The goal of the project is the practical application by the students, of the same procedures presented during the frontal lectures.
A specific UML editor (Visual Paradigm) is used in both kinds of lectures, to model the case study and prepare the project.
The course has its own page in the platform DIR (Didattica in Rete) which contains the slides, the instructions for the UML editor, several written tests in the past, etc.

During the course, deadlines are planned to delivery the parts of the laboratory project: specification diagrams (around the end of October), design diagrams (around the end of November), code and test-cases (around the end of December). This is done by means of a file sharing tool (Git) and pernits the periodic control of the students' work.

Students with physical disabilities, Learning Disabilities or Special Education Needs can requestspecific services and tools via the Staff Sviluppo e Coordinamento Carriere e Servizi alle Studentesse e agli Studenti, consulting the University webpage: https://www.uniupo.it/en/services/services-students-physical-or-learning-disabilities
Students with disabilities, learning disabilities or special education needs, once they have contacted the University Staff, can refer to the tutor in charge of the course to define the examination modalities, concerning academic aspects.

For the students attending the course, the exam is composed by two parts: 1) the delivery, at the end of the course, of the project realized during the laboratory lectures; 2) a written test concerning the theory. In order to be admitted to the written test the project must be delivered.

1) The evaluation of the project is based on the quality of the UML diagrams realized, in terms of precision (about 10 points), coherence (about 10 points), and completeness (about 10 points). Precision means the formal correctness of the diagrams, an acceptable detail level, and the absence of ambiguity in the interpretation of the contents. Coherence means that there are no discrepancies between a diagram and another one, and between the diagrams and the code implemented. Completeness means that all the required diagrams are present, together with the corresponding code and the test-cases.

2) The knowledge of the Engineering stages, the knowledge of the Engineering terminology, and the application of specific methods, are verified in the written test which is composed by both questions (about 15) about theoretical concepts, and practical exercises (about 3) about the methods.
The number of questions is motivated by the necessity to cover all the topics; however every question is quite specific and requires a relatively brief answer.
The score of every question is about 1.5 points over 30; the score of every exercise is about 2.5 points.
During the written test, consulting the course materials or manuals is not allowed.
The DIR platform, in the course page, contains examples of written tests in the past.

The final score is given by the average of the scores of the delivered project and the written test.

For the students not attending the course, the exam is oral and concerns all the topics of the course (theory and UML).
The oral exam consists of questions about the topics from theory (about 3), exercises about the methods presented in this part (about 2), questions about the formal aspects of UML (about 3), exercises about UML diagrams (about 2).
The score of every question is about 3 points over 30; the score of every exercise is about 3 points over 30.

- Introduction to the Software Engineering
- Software process (software life-cycle)
- Requirements specification
- Specification using UML
- System design
- Design using UML
- From UML to code
- Verification and validation
- Maintenance
- Project management
- Software process models
- Design patters
- Software tools
- Lab. project

The course consists of a theoretical section and a laboratory section. The theoretical section deals with the Engineering process structured in the following stages: specification, design, implementation, verification & validation, maintenance. The aim is showing how such process can be applied to the development of software systems. The laboratory section introduces the UML language for the specification and the design of systems. The activity in the laboratory consists of preparing UML diagrams about a certain software system, by means of an UML editor, and translating them into code. This allows the students to become familiar with such diagrams and improve the knowledge of them.

Knowledge and comprehension:
stages of Engineering, formal aspects of the several kinds of UML diagrams.

Ability to apply knowledge and comprehension:
application of the Engineering stages and UML to the development of a system software, and in particular,
- the study of the application domain;
- the requirement elicitation from the domain;
- UML modeling of the domain and the requirements;
- definition and UML modeling of a software architecture able to realize the requirements;
- definition and UML modeling of the component behaviour during the execution of a specific requirement, with a detail level allowing the programmer to implement the requirement.

Judgement autonomy:
study and definition in an autonomous way, of the application domain, the requirements, the system architecture and behaviour.

Communication abilities:
- communication and coordination inside the working group;
- expressing the system requirements with different levels of detail;
- designing the UML diagrams in a complete, detailed, and coherent way, with the goal of making them clear to any programmer.

Learning capacity:
acquiring the terminology of Engineering, planning the development of a system according to the stages of Engineering, modeling specification and design aspects by means of a formal language such as UML.