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”, Pearson, 10th edition, 2015, https://www.pearson.com/en-us/subject-catalog/p/software-engineering/P200000003258/9780133943030
- M. Fowler, “UML distilled”, Pearson, 3rd edition, 2003, https://www.informit.com/store/uml-distilled-a-brief-guide-to-the-standard-object-9780321193681?ranMID=24808

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 disabilities or Specific Learning Disorders (DSA) or Special Educational Needs (BES) can request specific services and tools dedicated to them by contacting the Career Development and Coordination and Student Services Staff and by consulting the dedicated page on the University website: https://uniupo.it/it/servizi/servizi-studenti-disabili-e-dsa Students with disabilities, DSA, BES can also contact the professor in charge of the course in relation to the declination of the exam methods.

The exam can be taken in two alternative ways: 1) partial tests; 2) general exam.

1.
PARTIAL TESTS:
There are two partial tests, both at the end of the course (January):
a) submission of the project (UML diagrams, code, test cases) developed during the laboratory lessons;
b) written test on theory topics only.

To be admitted to the written test, the project must have been submitted.

a) The project's evaluation is based on the quality of the UML diagrams created, in terms of accuracy (approximately 10 points), coherence (approximately 10 points), and completeness (approximately 10 points).
Accuracy refers to the formal correctness of the diagrams, an acceptable level of detail, and the absence of ambiguity in the interpretation of the content.
Coherence means that there must be no discrepancies between one diagram and another, and between the diagrams and the implemented code.
Completeness means that all required diagrams must be present, along with the corresponding code and test cases.
b) The written test tests knowledge of the various phases of the Engineering process, acquisition of engineering terminology, and the application of certain methods.
The written test includes both questions (approximately 15) on theoretical concepts and applied exercises (approximately 3) related to the methods.
The number of questions is based on the need to cover all topics; however, each question is quite specific and requires a relatively short answer.
A question is worth approximately 1.5 points out of 30; each exercise is worth approximately 2.5 points.

During the written test, consultation of course materials or manuals is not permitted.
On the DIR platform, on the course page, there are examples of past written tests.

The final grade is the arithmetic mean of the grades for the submitted project and the written test.

2.
GENERAL EXAM:
There will be an oral exam covering the entire course content (theory, UML, tools), to be taken during the exam sessions (February, June, July, September).

The oral exam includes questions on topics from the theory section (approximately 3), exercises related to the methods covered in this section (approximately 1), questions on formal aspects of UML (approximately 3), exercises related to UML diagrams (approximately 2), and questions on tools (approximately 1).

A question is worth approximately 3 points; an exercise is worth approximately 3 points.

The oral exam lasts approximately 30 minutes for each student.

During the exam, the use of any mobile devices (laptops, smartphones, smart glasses,
headphones, etc.) is prohibited.
The use of such devices will result in the immediate cancellation of the exam.

- Introduction to the Software Engineering and software process (software life-cycle)
- Requirements specification
- Specification using UML
- Architecture and behaviour design
- Design using UML
- From UML to Java code
- Verification and validation
- Maintenance
- Project management
- Traditional and agile software process models
- Design patterns
- Software tools (git, gradle, sqlite, swing)
- 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.