OVERVIEW

The teaching unit provides advanced methodologies and tools for the design, development, and verification of software systems for digital signal processing. Through the study of object-oriented programming and the use of the C++ language, students acquire the skills to create modular, efficient, and maintainable applications, addressing typical issues in telecommunications and information processing systems.

The teaching unit also introduces the principles of software engineering, UML modeling, the use of Git-based version control systems, and fundamental unit testing techniques. Laboratory activities enable the application of acquired knowledge through the development and validation of complex software applications, fostering the acquisition of design and operational skills required in professional and industrial contexts.

AIMS AND CONTENT

LEARNING OUTCOMES

The student who has successfully followed this teachning unit will be able to design, create and verify the operation of a complex system for signal processing. Students will acquire advanced skills in object-oriented programming and softwtention are design with particular atto the UML methodology.

AIMS AND LEARNING OUTCOMES

Attending lectures and laboratory activities, combined with individual study, will enable students to acquire advanced knowledge and skills for the design, development, and verification of signal processing software systems, applying modern software engineering and object-oriented programming methodologies.

At the end of the course, students will be able to:

• describe the principles of object-oriented programming and software engineering applied to the development of signal processing systems;
• use the C++ language to develop modular and reusable applications using classes, inheritance, polymorphism, templates, and standard libraries;
• design the architecture of a software system using the UML methodology and related diagrams to represent system requirements, structure, and behavior;
• use Git-based version control systems to manage source code evolution and support collaborative development activities;
• design and implement unit tests to verify the correct functioning of software components and contribute to the quality of the developed code;
• apply debugging, testing, and validation techniques to identify and correct errors and verify compliance with design specifications;
• develop software applications for digital signal processing by integrating programming, design, and verification skills;
• critically evaluate developed solutions in terms of correctness, efficiency, modularity, maintainability, and software quality, using appropriate technical terminology to describe their features and performance.

PREREQUISITES

To effectively address the teaching unit content, basic knowledge of procedural programming is required, with particular emphasis on control structures, functions, data types, fundamental data structures, and algorithms. Familiarity with the use of a software development environment and the main concepts of computer architecture is also required.

Basic knowledge of signals and systems acquired in telecommunications and electronics courses is also useful, as it allows for a more comprehensive understanding of the applications developed during the laboratory activities.

TEACHING METHODS

The teaching unit includes 40 hours of lectures and 20 hours of computer lab work.

Lectures are aimed at acquiring theoretical knowledge related to object-oriented programming in C++, the principles of software engineering, UML modeling, version control systems, and testing methodologies. Application examples and case studies from the field of signal processing will be presented during the lectures.

Lab work will allow students to apply the knowledge acquired through practical exercises and project activities. Specifically, students will use Git-based version control tools, develop software applications in C++, implement unit tests, and model software systems using UML. The lab work will focus on: Laboratory activities also include the design, implementation, and testing of software components for digital signal processing.

During the course, teaching materials, code examples, exercises, and supporting documentation will be made available via AulaWeb. Students will be required to complete individual study and in-depth analysis of the topics covered in class and laboratory.

Students with valid certifications for Specific Learning Disabilities (SLD), disabilities, or other educational needs are invited to contact the teacher and the School Disability Coordinator at the beginning of the course to discuss possible teaching methods that, while respecting the course objectives, take into account individual learning styles. The contact details of the School Disability Coordinator are available at are available at the following link University Committee for the inclusion of students with disabilities or with DSA | UniGe | University of Genoa

SYLLABUS/CONTENT

The course covers the main tools and methodologies for designing, developing, and testing signal processing-oriented software systems.

1. Introduction to software development tools
   • Software life cycle.
   • Integrated development environments.
   • Version control systems.
   • Introduction to Git.
   • Local and remote repositories.
   • Commit, branch, merge, and conflict management.
   • Main collaborative development workflows.
2. Object-oriented programming in C++
   • Procedural programming references.
   • Classes and objects.
   • Encapsulation and information hiding.
   • Constructors and destructors.
   • Operator and function overloading.
   • Inheritance.
   • Static and dynamic polymorphism.
   • Abstract classes and interfaces.
   • Exception handling.
3. Generic programming and standard libraries
   • Function and class templates.
   • Standard Template Library (STL).
   • Containers, iterators, and algorithms.
   • Smart pointers and memory management.
   • Modular software organization.
4. Quality Software Engineering and Unit Testing
   • Principles of Software Verification and Validation.
   • Functional and Structural Testing.
   • Unit Testing.
   • Test Case Design.
   • Introduction to Unit Testing Frameworks for C++.
   • Debugging and Error Analysis.
5. Software Engineering and UML Modeling
   • Requirements Analysis.
   • Principles of Object-Oriented Design.
   • Unified Modeling Language (UML).
   • Use Case Diagrams.
   • Class Diagrams.
   • Sequence Diagrams.
   • From Design implementation.
6. Signal Processing Applications
   • Software architecture of signal processing systems.
   • Design and development of software components for digital signal processing.
   • Organization and integration of software modules.
   • Verification of the performance and correctness of developed applications.

Laboratory Activities
Laboratory activities include the use of Git for source code management, development of C++ applications, creation of unit tests, UML modeling of case studies, and the progressive implementation of a signal processing software project.

RECOMMENDED READING/BIBLIOGRAPHY

The slides used during lectures, code examples, laboratory exercises, and any supplementary material will be made available via AulaWeb. The material provided by the instructor is an integral part of the teaching materials.

Main reference text:

• B. Stroustrup, Programming: Principles and Practice Using C++, Addison-Wesley.

Additional readings:

• B. Stroustrup, The C++ Programming Language, Addison-Wesley.
• S. Lippman, J. Lajoie, B. Moo, C++ Primer, Addison-Wesley.
• E. Gamma, R. Helm, R. Johnson, J. Vlissides, Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley.
• G. Booch, J. Rumbaugh, I. Jacobson, The Unified Modeling Language User Guide, Addison-Wesley.

Lecture notes and additional technical documentation may be provided during the course for topics related to version control systems, testing, and software development tools.

Non-attending students may use the teaching materials available on AulaWeb and are encouraged to contact the instructor for any additional information.

TEACHERS AND EXAM BOARD

LESSONS

LESSONS START

https://corsi.unige.it/corsi/11911/studenti-orario

Class schedule

The timetable for this course is available here: Portale EasyAcademy

EXAMS

EXAM DESCRIPTION

The exam consists of a written test and an oral exam.

The written exam includes theoretical questions and exercises covering the topics covered in the course, with particular emphasis on object-oriented programming in C++, software design using UML, version control systems, testing methodologies, and the development of signal processing applications.

Access to the oral exam is contingent upon passing the written exam. The oral exam covers the topics covered in the course and may include a discussion of the solutions proposed in the written exam and the activities performed during the laboratory.

The final grade is determined based on the results of both exams.

Non-attending students take the exam using the same procedures as attending students.

ASSESSMENT METHODS

The written exam is designed to assess the acquisition of knowledge and operational skills related to object-oriented programming in C++, software design using UML, version control systems, and testing methodologies. The ability to analyze problems, design software solutions, and develop correct and effective code will be assessed through theoretical questions and practical exercises.

The oral exam is designed to assess the student's understanding of the topics covered in the course, the ability to justify the design choices made, and the ability to connect the various concepts covered during lectures and laboratory activities. The oral exam will also assess the student's ability to correctly use the technical terminology specific to software engineering and object-oriented programming.

Overall, the assessment will allow To assess the student's ability to:

• apply the principles of object-oriented programming in the development of software applications;
• use the main advanced features of the C++ language to create modular and reusable solutions;
• design software systems using UML diagrams;
• use version control tools for source code management;
• design and interpret unit tests to verify the correct functioning of the software;
• critically analyze the quality, correctness, and maintainability of the solutions developed.

The assessment will take into account the correctness of the proposed solutions, the ability to apply the acquired knowledge to problem solving, independent reasoning, completeness of answers, and clarity of presentation.

FURTHER INFORMATION

The software tools and development environments used during the course will be announced at the beginning of the course and made available via AulaWeb. Any updates regarding course materials, laboratory exercises, and supplementary activities will be communicated via AulaWeb.

Students are encouraged to bring a laptop to actively participate in laboratory activities and practical exercises.