Tu sei qui: Home > Studiare > Insegnamenti, competenze trasversali, MOOCs > Insegnamenti > 2024/2025 SOFTWARE ENGINEERING

95627 - SOFTWARE ENGINEERING

Anno Accademico 2024/2025

  • Docente: Giovanni Ciatto
  • Crediti formativi: 6
  • SSD: ING-INF/05
  • Lingua di insegnamento: Inglese
  • Modalità didattica: Convenzionale - Lezioni in presenza
  • Campus: Cesena
  • Corso: Laurea Magistrale in Digital Transformation Management (cod. 5815)

Conoscenze e abilità da conseguire

Students will get acquainted with basic aspects of the following topics: - service-oriented architectures, API, microservices: principles, technologies, enterprise viewpoint - cloud computing: principles, technologies, enterprise viewpoint - agile development: principles and methodologies, the role of testing, the case of SCRUM - devops: DVCS, agile project management tools, continuous development/integration/delivery - intelligent systems: definitions, problems, applications - multi-agent systems for the engineering of intelligent systems: models, technologies, methodologies

Contenuti

  1. Introduction to software engineering

    • Basic definitions and concepts (computer science, algorithm, software, software engineering, etc.)
    • Role of software (engineering) in digital transformation
    • Software engineering phases
    • Software engineering methodologies (waterfall, agile, etc.)

  2. Recap of relevant background notions for software development (examples in Python)

    • Command-line interface, shells, terminals, and related aspects
    • Programs, processes, and commands
    • Code and project structure for software projects
    • Runtime, libraries, dependencies, package managers
    • Compiled vs interpreted languages
    • Basic principles: decomposition, modularity, abstraction, separation of concerns
    • Interfaces: graphical user interfaces (GUIs), command-line interfaces (CLIs), application programming interfaces (APIs)

  3. Decentralized version control (with Git) and team organization

    • (Distributed) Version control systems, history and motivation
    • Git basics: repositories, working trees, commits and commit references, branches, checkouts, merges
    • Git operations with the command line
    • Git configuration, .gitignore, and .gitattributes
    • Criteria and best practices for committing
    • The role of GitHub (and the alike) in distributed version control
    • GitHub notions: forks, pull requests, issues, wikis, organizations
    • Remote operations with git: pushing, pulling, fetching, merging
    • Teamwork with git: handling conflicts and divergent histories, branching strategies, etc.

  4. Object-oriented programming (OOP), in Python

    • Key differences among programming paradigms
    • Motivations for object-oriented programming
    • Key principles and ingredients of OOP (classes, objects, fields, methods, etc.)
    • Information hiding and encapsulation, APIs, visibility
    • Equality vs identity, hashing, and (im)mutability
    • String representation, formatting, and interpolation
    • Advanced aspects: operator overloading, inheritance, polymorphism, static vs. instance attributes

  5. Software Modelling with UML (and PlantUML)

    • Modelling in science and engineering
    • Many kinds of models in computer science
    • Modelling software with UML
    • Details about UML diagrams: class, sequence, activity, state, component, deployment, and use-case diagrams
    • PlantUML for generating UML diagrams

  6. Quality-assurance (QA), automated testing, test-driven development (TDD)

    • Definitions of quality for software projects
    • Types of testing: automated vs. manual, unit vs. integration vs. system testing, acceptance testing
    • Testing frameworks and tools (e.g., pytest, unittest ), and how to automatize test suites in Python
    • Purposes of testing: canaries to avoid regression, verification, specification, etc.
    • The test-driven development (TDD) approach
    • Key notions: technical debt, code coverage, and how to deal with them
    • Static analysis: linters, type checkers, etc.

  7. Build automation, packaging, and release (examples with Poetry)

    • Build life-cycle and the role of build automation
    • Build tools in the Python ecosystem (pip, venv, Poetry, etc.)
    • Basic concepts of Poetry: metadata and dependencies declaration (pyproject.toml ), etc.
    • Packaging and distributing Python projects with Poetry on PyPI and the alike

  8. Versioning, Conventional Commit

    • Versioning and most common versioning schemas in the real world
    • Semantic versioning (SemVer) and its relationship with API stability
    • Conventional-commit specification and its role in versioning via DVCS

  9. Overview on Distributed Systems Engineering

    • Definitions of distributed systems, and their key characteristics
    • Examples of real-world distributed systems
    • Impact of distribution on the software engineering process
    • Distributed infrastructures, infrastructural components, interaction patterns, and protocols
    • Distributed architectures, with a focus on layered and hexagonal ones
    • Basic mechanisms for distributed systems: overview

  10. WebServices and RESTful APIs

    • Definitions of "web services" and their role modern internet applications
    • RESTful APIs: principles, constraints, and best practices
    • Technological overview: HTML, HTTP, JSON, JavaScript, etc.
    • Designing and documenting RESTful APIs (e.g., OpenAPI/Swagger)
    • Implementing RESTful APIs in Python

  11. Domain Driven Design (DDD)

    • Main notions: domain, context, model, ubiquitous language, etc.
    • DDD philosophy and how to apply it
    • DDD building blocks: entities, value objects, aggregates, repositories, services, factories, etc.
    • DDD patterns: bounded contexts, anti-corruption layers, domain events, etc.

  12. Continuous integration (examples with GitHub Actions, GHA)

    • Integration in software engineering: activities involved
    • Integration hell: the risks of manual, late, or infrequent integrations
    • Continuous integration concepts: how to make integration continuous
    • Tools for continuous integration: GHA, and the alike; common concepts different names
    • Abstract CI pipeline design
    • Trivial to complex examples in GHA
    • Matrix build for fine-grained testing in GHA
    • Automating release and versioning with GHA + Conventional-commit
    • The role of secrets in CI/CD pipelines

  13. Software Licensing

    • What is a (software) licence, and why it is needed
    • Copyright vs. copyleft
    • Ownership vs. licensing
    • Proprietary vs. free software
    • Free as in speech vs. free as in beer
    • Common software licences: MIT, Apache, GPL, etc.
    • Criteria and practices for choosing and applying software licences

Testi/Bibliografia

1. Introduction to software engineering

2. Background notions for software development (Python)

  • Books:

    • The Pragmatic Programmer: Your Journey to Mastery by Andrew Hunt & David Thomas (includes software design and development principles)
    • Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin

  • Articles & Documentation:

3. Decentralized version control (Git)

  • Books:

    • Pro Git by Scott Chacon & Ben Straub (freely available online here)
    • Version Control with Git by Jon Loeliger

  • Online Resources:

4. Object-oriented programming (Python)

  • Books:

    • Python Object-Oriented Programming by Steven F. Lott & Dusty Phillips
    • Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma et al. (Gang of Four, classic patterns)
    • Effective Python: 90 Specific Ways to Write Better Python by Brett Slatkin
    • Clean Architecture: A Craftsman’s Guide to Software Structure and Design by Robert C. Martin

  • Essays:

5. Software Modelling with UML

  • Books:

    • UML Distilled: A Brief Guide to the Standard Object Modeling Language by Martin Fowler
    • Applying UML and Patterns by Craig Larman

  • Online Resources:

6. Quality-assurance (QA), automated testing, TDD

  • Books:

    • Test-Driven Development: By Example by Kent Beck
    • The Art of Software Testing by Glenford J. Myers, Corey Sandler, and Tom Badgett
    • xUnit Test Patterns: Refactoring Test Code by Gerard Meszaros

  • Articles:

7. Build automation, packaging, and release

  • Books:

    • Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation by Jez Humble & David Farley

  • Articles/Documentation:

8. Versioning, Conventional Commit 9. Overview on Distributed Systems Engineering

  • Books:

    • Designing Data-Intensive Applications by Martin Kleppmann (highly recommended)
    • Distributed Systems: Principles and Paradigms by Andrew Tanenbaum and Maarten van Steen (freely available online)

  • Essays/Articles:

10. WebServices and RESTful APIs 11. Domain Driven Design (DDD)

  • Books:

    • Domain-Driven Design: Tackling Complexity in the Heart of Software by Eric Evans (the original, foundational text)
    • Implementing Domain-Driven Design by Vaughn Vernon

  • Essays/Articles:

12. Continuous Integration

  • Books:

    • Continuous Integration: Improving Software Quality and Reducing Risk by Paul M. Duvall, Steve Matyas, Andrew Glover
    • Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation by Jez Humble & David Farley

  • Online Documentation:

13. Software Licensing Additional useful general software engineering resources:

Metodi didattici

Lectures and hands-on practical sessions in the lab. Lectures will be face-to-face, yet the whole course will be recorded and access to recording may be granted to students upon request, in case specific needs arise.

Modalità di verifica e valutazione dell'apprendimento

The exam consists of a written and an oral test.
In the written one, students will have to answer questions about the topics of the course.
In the oral one, students will have to present and defend a software project they developed, either individually or in a team.

Evaluation criteria and grading:

  • 18-23: the student shows sufficient knowledge about the basic concepts and a sufficient technical and methodological preparation;
  • 24-27: the student shows good knowledge about the conceptual part and adequate capabilities of applying concepts in practice;
  • 28-30: the student shows good knowledge about the conceptual part, good critical and analytical skills, a good capability of applying concepts in practice by means of a satisfactory technical and methodological preparation;
  • 30L: the student shows excellent knowledge about the conceptual part, extensive critical and analytical skills, remarkable abilities in applying concepts in practice by means of a robust technical and methodological preparation.

Strumenti a supporto della didattica

During the term of the lectures, material (both slides and lab exercises) will be available on Virtuale.

Link ad altre eventuali informazioni

https://github.com/unibo-dtm-se/

Orario di ricevimento

Consulta il sito web di Giovanni Ciatto