Learning objectives
The course starts from the basics of the well-know Software Crisis phenomenon. It then passes through the study of classic development models. It eventually ends to provide the basic of architectural aspects of modern software systems.
The course is structured into frontal lessons and a set of directed exercises on the construction of Java-based applications.
Taking Dublin Indicators into account:
Knowledge and understanding
The course introduces the first concepts related to software engineering. Particular emphasis is given to the understanding of the classical methodologies. The reference text is in Italian, but standard English terminology is commonly used during the lessons as goodwill to the consultation of the international scientific literature.
Applying knowledge and understanding
The knowledge presented is always applied to the resolution of specific problems. The exercises that accompany the course are focused on solving exercises and problems, particularly in the development of Java-based Web applications. Often the solution methods are presented in the form of an algorithm, developing in students the ability to structure procedures that are useful in many parts of computer science, and not only in the study of the computer architecture.
Making judgments
The exercises, which are proposed in relation to the theoretical part presented in class, can be solved individually or in groups. The comparison with classmates, work at home or in classroom, favors the development of specific skills in students to enable the explanation of arguments to fellows and teachers. Often the exercises can be solved in many different ways and listening to the solutions proposed by other allows students to develop the ability to identify common structures, beyond the apparent superficial differences.
Communication skills
The numerous discussions on the different methods to solve problems allow students to improve communication skills. Specific communication of computer technology is also usually used during classes and exercises.
Learning skills
The study of the origins of technological solutions and their introduction motivated by qualitative and quantitative considerations contributes to the students’ ability to learn in a deep way and not just superficial and repetitive. The knowledge acquired is never rigid and definitive, but it is adaptable to any evolution and change of perspective and context.
Prerequisites
Programming experiences in Java, C++ or C#.
Course unit content
Part 1 - Introduction to complex software systems and software engineering
Part 2 - Software configuration management
Part 3 - Concurrent software systems in Java
Part 4 - Tools and techniques for software reuse in Java
Part 5 - Structured and agile software development processes
Part 6 - Design for reuse and design patterns
Full programme
Lesson 1. Introduction to the course and exam with notes on the history of software engineering
Lesson 2. Syntax and semantics of propositional logic and exercises
Lesson 3. Syntax and semantics of linear temporal logic and exercises
Lesson 4. Reasoning on linear temporal logic and exercises
Lesson 5. Reasoning on linear temporal logic 1
Lesson 6. Reasoning on linear temporal logic 2 and exercises
Lesson 7. Software configuration management 1
Lesson 8. Laboratory session on software configuration management 1
Lesson 9. Management of software configurations 2
Lesson 10. Laboratory session on software configuration management 2
Lesson 11. Laboratory session on software configuration management 3
Lesson 12. Processes and threads in Java 1
Lesson 13. Processes and threads in Java 2
Lesson 14. Mutual exclusion in Java and the Java memory model 1
Lesson 15. Mutual exclusion in Java and the Java memory model 2
Lesson 16. Synchronized queues and exercises
Lesson 17. Lock, conditions 1
Lesson 18. Lock, conditions 2 and exercises
Lesson 19. Thread pools and examples
Lesson 20. Active objects and asynchronous invocations 1
Lesson 21. Active objects and asynchronous invocations 2
Lesson 22. Java reflection 1
Lesson 23. Java reflection 2 and exercises
Lesson 24. Exercises carried out on Java reflection and dynamic proxy
Lesson 25. Aspect-oriented programming 1
Lesson 26. Aspect-oriented programming 2
Lesson 27. Aspect-oriented programming 3 and exercises
Lesson 28. Evolution, maintenance and testing 1
Lesson 29. Evolution, maintenance and testing 2
Lesson 30. Notes on UML
Lesson 31. Design pattern 1 (creational GoF patterns)
Lesson 32. Design pattern 2 (structural GoF patterns)
Lesson 33. Design pattern 3 (behavioral GoF patterns)
Lesson 34. Design pattern 4 and exercises
Lesson 35. Exercises in preparation for exams 1
Lesson 36. Exercises in preparation for exams 2
Bibliography
C. Ghezzi, A. Fuggetta, S. Morasca, A. Morzenti, M. Pezze, Ingegneria del Software, Mondadori Informatica, II edition
Simon Bennett, John Skelton, Ken Lunn, UML, McGraw-Hill
Bruce Eckel, Thinking in Java, available at http://www.mindview.net, II edition
Bruce Eckel, Thinking in Patterns, available at http://www.mindview.net
E. Gamma, R. Helm, R. Johnson, J. Vlissides, Design Patterns, Addison-Wesley
Teaching methods
Classes and exercises
Assessment methods and criteria
Learning outcomes and methods of verification
Being able to understand and make appropriate use of techniques relating to the analysis, design, realization, testing and validation of software. Being able to work in the Java programming language in the realization of simple architectures. Knowing the basics of project management. Know and be able to use the main techniques of development of Java-based applications.
Learning assessment/examination
The exam consists of a written test and a laboratory test, which can be accessed only after a successful written test. After a successful laboratory test, the teacher or the student can ask for an oral session.
Other information
- - -
