- 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)
-
dal 18/02/2025 al 05/06/2025
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
-
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.)
-
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)
-
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.
-
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
-
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
-
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.
-
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
-
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
-
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
-
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
-
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.
-
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
-
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
-
Books:
- Software Engineering: A Practitioner’s Approach by Roger S. Pressman
- Software Engineering by Ian Sommerville
- The Mythical Man-Month: Essays on Software Engineering by Frederick P. Brooks Jr.
-
Essays/Articles:
- “No Silver Bullet—Essence and Accident in Software Engineering” by Fred Brooks (seminal paper)
-
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:
- “The Twelve-Factor App” – methodology on best practices for modern software
- Python official documentation (reference sections on environment management, packages, modules, etc.)
-
Books:
- Pro Git by Scott Chacon & Ben Straub (freely available online here)
- Version Control with Git by Jon Loeliger
-
Online Resources:
-
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:
- “SOLID Principles” by Robert C. Martin (aka Uncle Bob, various summaries available online)
- “SOLID Principles: Improve Object-Oriented Design in Python” by Leodanis Pozo Ramos
-
Books:
- UML Distilled: A Brief Guide to the Standard Object Modeling Language by Martin Fowler
- Applying UML and Patterns by Craig Larman
-
Online Resources:
- PlantUML documentation
- UML Reference (OMG standard)
-
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:
- “What is Unit Testing?” by Martin Fowler
- “Continuous Delivery” article by Martin Fowler
-
Books:
- Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation by Jez Humble & David Farley
-
Articles/Documentation:
-
Specifications & Articles:
- Semantic Versioning (SemVer)
- Conventional Commits Specification
-
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:
- “Fallacies of Distributed Computing” by Peter Deutsch and James Gosling (classic brief essay)
- “CAP Theorem” by Eric Brewer
-
Books:
- RESTful Web APIs by Leonard Richardson, Mike Amundsen, and Sam Ruby
-
Articles:
- “Architectural Styles and the Design of Network-based Software Architectures” (REST dissertation) by Roy Fielding (seminal)
-
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:
- “Domain Driven Design Reference” by Martin Fowler (collection of short articles)
- “Ubiquitous Language” by Martin Fowler
-
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:
-
Books & Essays:
- Understanding Open Source and Free Software Licensing by Andrew M. St. Laurent
- “The Cathedral and the Bazaar” by Eric S. Raymond (classic essay on OSS culture, partially covers licenses)
-
Online Resources:
-
Websites & Blogs:
- Martin Fowler’s blog: insights on software design, architecture, and development practices
- Joel on Software: insights on software development and management
- ThoughtWorks Technology Radar: a report on emerging technologies and practices in software development
- The Missing Semester of Your CS Education: MIT notes on practical software engineering skills
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