Agile Software Development and Design Patterns

Agile development is the ability to develop software quickly, in the face of rapidly changing requirements. By following agile principles and practices, a software development team is encouraged to evolve into a self-organizing and cross-functional group, thus improving the quality of the code, the quality of deliveries and in the end the customer satisfaction. In general, agile concepts promote adaptive planning, evolutionary development and delivery, a time-boxed iterative approach, and encourage rapid and flexible response to change. Design principles described during the course will help to keep the software flexible and maintainable, while design patterns will represent some practical tools to balance those principles for specific problems. Agile principles, patterns and practices will be described and then applied through several different case studies.

Inspiring principles for agile framework were introduced through the Agile Manifesto in 2001, focusing on individuals and interactions within a software development team, working software from the early stages of the development process, open and continuous collaboration with the customers and the ability to quickly respond to requests for changes in requirements even late in development.

There exist several processes trying to put in practice those inspiring principles, being the eXtreme Programming (XP) one of the most famous and widely adopted. XP concentrates on short development cycles, acceptance tests and test-driven development. Simple design is usually favored in contrast of needless complexity and overdesign.

Six fundamental principles of software engineering are described in details that help developers eliminate the symptoms of poor design. The Single-Responsibility Principle (SRP), the Open/Closed Principle (OCP), the Liskov Substitution Principle (LSP), the Dependency-Inversion Principle (DIP) and the Interface Segregation Principle (ISP) are the hard-won product of decades of experience in software engineering. They are not the product of a single mind but represent the integration of the thoughts and writings of a large number of software developers and researchers. Although they are presented here as principles of object-oriented design, they are really special cases of long-standing principles of software engineering.


- Agile manifesto and practices

- Overview of Extreme Programming

- Software development planning

- Test-driven development

- Refactoring

- Principles of agile design

    - Single-Responsibility Principle (SRP)

    - Open/Closed Principle (OCP)

    - Liskov Substitution Principle (LSP)

    - Dependency-Inversion Principle (DIP)

    - Interface Segregation Principle (ISP)

- UML overview

    - Object diagrams

    - Use cases

    - Sequence diagrams

    - Class diagrams

- Design patterns

    - Template method and Strategy

    - Facade and Mediator

    - Singleton and Monostate

    - Null Object

    - Factory

    - Observer

    - Proxy and Gateway

    - Visitor

    - State


  • Course notes

Further reading:

  • "Manifesto for Agile Software Development", Agile Alliance, 2001, webpage:
  • Robert C. Martin and Micah Martin. 2006. Agile Principles, Patterns, and Practices in C# (Robert C. Martin). Prentice Hall PTR, Upper Saddle River, NJ, USA.
  • Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. 1995. Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley Longman Publishing Co., Inc., Boston, MA, USA.
  • Robert C. Martin. 2008. Clean Code: A Handbook of Agile Software Craftsmanship (1 ed.). Prentice Hall PTR, Upper Saddle River, NJ, USA.
  • Kent Beck, extreme Programming explained: Embrace change Addison-Wesley, 2000.

Additional Info

  • Location: Ex-CNR building, Via all'Opera Pia 11, 16145 Genova
  • Instructor: Lucio Marcenaro
  • Calendar:

    Course dates: July 23 to 27 from 9am to 1pm