Objectives
Introducing concepts and techniques for collaborative development of large and complex software systems for industrial applications, including Java, functional programming, software development lifecycle, and good practices in software development such as code testing, versioning, and design patterns.

Knowledge and understanding
Students should be able to understand the relationships between different product development approaches, software development practices and the ability to make changes in a product. They should have a clear idea about how good practices help in developing software systems and improving their quality.

Applied knowledge and understanding
Students should learn how to use and adopt good software development practices. They should be able to perform test-driven development, refactoring, and continuous integration. The students also should learn functional programming techniques and be able to write Java programs that solve practical, real-world problems using object-oriented design techniques and data parallel functional programming.

Making judgments
Students should be able to recognize bad code, identify possible refactoring moves, and analyze a test suite.

Communication skills
Students should be able to effectively communicate their design decisions on production code and test code.

Learning skills
Students must demonstrate that they are comfortable with good software development practices. They should demonstrate an understanding of the basis of Agile Software Development and continuous integration. They should demonstrate a good understanding of functional programming, writing parallel functional programs in Java, and be able to analyze sequential and parallel time complexity in a small program.

Participants are required to have previous experience with software development and a solid understanding of basic programming topics like control flow structures and data types. Furthermore, is preferable but not mandatory to be comfortable with the use of an IDE and version control systems, like git for example.

● Fundamental Java: variables, expressions, control structures, arrays, objects, classes, instance variables, methods, initialization, constructors, exceptions, threads, packages, collections, generics
● OOP in Java: abstraction and inheritance, encapsulation and access control, polymorphism and interfaces, composition.
● Functional programming in Java: method references, lambdas, default methods, streams and optionals. Behavior parametrization. Functional interfaces. Lazy evaluation. Composition.
● Java Streams: main features, creation, filtering, extraction, grouping, mapping, partition and reducing patterns. Streams vs. Collections. Numeric streams specializations. Performance considerations. Default and custom parallel streams.
● Basic of I/O in Java: streams, text encoding.
● GUI programming in Java: basics of Swing, layout managers, components, custom components, testing of GUI applications.
● Agile Software Development: Manifesto for Agile Software Development, characteristics of Agile Software Development, Scrum.
● Build automation and version control: practice and tools.
● Test Driven Development: test infrastructure, TDD cycle, test characteristics.
● Refactoring: readability, code smells, coupling, cohesion, S.O.L.I.D. principles, simple design.
● Design patterns: creational, and structural patterns; role of patterns in refactoring.
● Test doubles: dummies, fakes, stubs, mocks.
● Acceptance testing.
● Continuous Integration: long-lived branches and their consequences, the practice of continuous integration, systems and tools.
● Static code analysis: practice and tools.

Recommended
● Java: The Complete Reference, Twelfth Edition, Herbert Schildt, McGraw-Hill Education, 2021.
● Modern Java in Action, Raoul-Gabriel Urma, Mario Fusco, Alan Mycroft, Manning, 2019.
● Agile Technical Practices Distilled, Pedro Moreira Santos, Marco Consolaro, and Alessandro Di Gioia, Packt Publishing, 2019
● Test-Driven Development: By Example, Kent Beck, Addison-Wesley Professional, 2002.

Other suggested books
● Growing Object-Oriented Software, Guided by Tests, Steve Freeman and Nat Price, Addison-Wesley Professional, 2009.
● Refactoring: Improving the Design of Existing Code, Martin Fowler, Addison-Wesley Professional, 1999.
● Refactoring to Patterns, Joshua Kerievsky, Addison-Wesley Professional, 2005.
● Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation, Jez Humble and David Farley, Addison-Wesley Professional, 2010.

.

Lectures are expected to be very interactive, with a mix of frontal lectures and hands-on sessions to immediately put into practice the notions, concepts, and techniques presented. The hands-on sessions will include software development exercises and working in pairs on code “katas”. Exercise solutions and “katas” will be discussed after the hands-on sessions. Similar activities may be left as homework and discussed during the next lecture.

Any changes to the methods described here, which may be necessary to ensure the application of the security protocols related to the COVID19 emergency, will be communicated on the website of the Department, the Degree Program, and the course.

Some hands-on sessions could require the usage of a laptop during the lesson, to be more effective. One laptop per pair/group will be enough when allowed by COVID-19 related restrictions. Required software: ● Any operating system supporting Java. Linux, Windows, and macOS are fine ● Java Development Kit ● Java IDE, we suggest using IntelliJ Idea Community or any other IDE you are familiar with. Plain text editors can be used for very basic examples only. ● Git version control system

The exam consists of two parts: 1. A project to be completed in a group of 2/4 students, using the development practices seen during the lectures. 2. An oral session composed of a presentation of the project, max 25 minutes, and an interview. During the presentation, the students discuss the challenges they faced, the practices they adopted, and the code. During the interview we will discuss the adopted practices, the code quality, the design decisions, and the considered trade-offs. The final mark is obtained by averaging the score for the project and the score for the oral session. To evaluate the project: We will read both the production and test code to understand how your software works. We will check the quality of your code by using code smells, S.O.L.I.D. principles, coupling, cohesion, and the application of object-oriented practices. We will check the conformance to the Java API specifications, and to any other used library or API. Laude can be given when the group presents a project without flaws and when the oral questions are correctly answered. In any type of content produced by the student for admission to or participation in an exam (projects, reports, exercises, tests), the use of Large Language Model tools (such as ChatGPT and the like) is allowed and it must be explicitly declared. This requirement must be met even in the case of partial use. Regardless of the method of assessment, the teacher reserves the right to further investigate the student's actual contribution with an oral exam for any type of content produced.