FONDAMENTI DI PROGRAMMAZIONE A - E

Module PROGRAMMAZIONE I

Module Description

The Programming I module of the Foundations of Programming course focuses on training students to become proficient in Python programming (with a procedural approach), capable of tackling moderately complex challenges, evaluating, selecting, and designing algorithms, and communicating using appropriate techniques and computer science terminology.The module includes introductory topics on error detection and correction strategies (syntactic, semantic, and runtime), information representation, computer architecture, and operating systems.

By the end of the module, students will be able to develop and describe algorithms for problem-solving and will have a solid understanding of the procedural features of the Python language.

Knowledge and Understanding

The main objective is to provide students with knowledge of algorithmic techniques and the Python programming language, including its syntax, semantics, and applications. The module focuses on developing simple algorithms and understanding datatypes, variables, operators, control structures, and functions.

Required knowledge and understanding:

• basic knowledge of number systems and information representation
• basic understanding of computer architecture and operating system principles
• knowledge of problem-solving techniques and computer science fundamentals
• familiarity with main algorithm representation techniques
• introduction to procedural programming using Python
• conceptual tools for solving computational problems
• basic computer science concepts: algorithms, data structures, computer architecture
• ability to develop computational thinking and design algorithmic solutions
• understanding of Python syntax and semantics
• basic techniques for debugging and error detection in programs

Applying Knowledge and Understanding

Students will develop the ability to apply acquired knowledge through exercises, both on paper and using a computer, allowing them to practice problem-solving through algorithms and their implementation in Python.The module aims to make students proficient in using available resources, including Python’s standard libraries and their practical applications, with particular focus on:

• input/output functions
• string manipulation
• handling basic data structures
• elementary memory and file management
• solving numerical problems

Skill developed:

•  ability to solve basic problems, write the corresponding algorithm, and implement it in Python 
• ability to analyze code, debug, and produce a working application
• ability to use a development environment (IDE)

Learning Skills

Students will be able to analyze and evaluate moderately complex problems such as sequence handling, sizing, and numerical challenges, applying Python programming to solve them using development environments and debugging tools effectively.Skill developed:

• understanding and applying control structures (conditions, loops, functions)
• using primitive data types and basic data structures
• reading and writing functional, structured, and readable Python code
• tackling increasingly complex problems through algorithmic problem-solving techniques
• understanding the general functioning of a computer (memory, CPU, input/output)
• ability to learn new languages, programming paradigms, and manipulate data structures

Communication Skills

This course will introduce students to computer science terminology, enabling them to communicate effectively using mathematical and programming language, and to share programming solutions and ideas. Skill developed:

• computer science language and technical terminology

The course is primarily delivered through lectures to acquire theoretical knowledge and syntactic elements, and through exercises, both in class and independently, proposed by the instructor to develop problem-solving skills, error correction, knowledge application, and use of development environments and methodologies.The instructor also assigns individual exercises that involve solving a problem independently, which are later reviewed or discussed in class.If the course is delivered in blended or remote mode, necessary adjustments may be introduced to ensure the syllabus is followed asplanned.

Attendance is not mandatory, although it is strongly recommended in order to successfully pass the exam.If the course is delivered in blended or remote mode, the requirements for participation in midterm assessments may be subject to change.

PRELIMINARY CONCEPTS

Algorithms

• Basic concepts of information processing and algorithms 
• Properties of an algorithm
• Textual and graphical notations for expressing algorithms
• Development of simple algorithms

• Number systems and conversions between them
• Binary number system
• Operations on binary numbers
• Representation of integers, including signed numbers
• Handling overflow and underflow
• Fixed-point and floating-point representation
• Character encoding and representation
• Boolean algebra, logic functions, logical expressions, and applications of Boolean algebra

• Structure of a computer: CPU, main memory, input/output units, mass storage
• Basic functioning of a computer
• Introduction to operating systems: structure and functionality
• Programming languages: types, translation, and execution of programs
• Compilers and interpreters

Introduction to Python

• Development environment

Data Types and Basic Operations

• Primitive types: int, float, str, bool
• Arithmetic, logical, and comparison operators
• Input/output
• Type conversions

• Conditionals: if, elif, else
• Loops: while, for
• Iteration over strings and range
• Debugging and using print to trace execution

• Lists: indexing, slicing, methods
• Tuples and dictionaries
• Sets
• Iteration over lists and dictionaries
• Nested lists
• Data manipulation exercises
• Common iteration patterns

• Function definition: def
• Parameters and return values
• Scope and variable binding
• Recursion (introduction)
• Examples of functional decomposition

• Divide and conquer 
• Backtracking (overview)
• Algorithm convergence
• Convergence in iterative loops: when a sequence of values (e.g., a series or approximation) tends toward a final value
• Program termination strategies: guess and check, approximation, bisection

• Program efficiency and basic evaluation of algorithm efficiency
• Search and sorting algorithms

Kenneth A. Lambert, Programmazione in Python, Maggioli Editore (Apogeo Education)

Lecture notes and exercises provided by the instructor via the Studium UniCT platform and/or Microsoft Teams

Programming I Module

The final assessment for Module 1 consists of:

1. A questionnaire with open and/or closed questions on the course content (graded out of 10), focusing on:

• Computer system architecture
• Number systems
• Boolean algebra
• Algorithms and programs
• Memory management
• Programming language concepts, including Python

2. A computer-based test, involving writing Python code, debugging, and verifying its functionality (graded out of 20)The overall test duration is 90 minutes and is graded out of 30 points (sum of both parts).The test is considered passed if the student scores at least 18/30, with a minimum of 5/10 on the questionnaire and 10/20 on the computer-based test.

This test contributes proportionally to the final grade of the course.

Final Exam of the Course

The final exam consists of passing both Module 1 and Module 2 assessmentsThe assessments for both modules may be taken during the same exam session or in separate sessionsPassing the Module 1 assessment is a prerequisite for passing the Module 2 assessment, even if taken in the same sessionIf the Module 2 assessment is taken in the same session as Module 1, it will be considered valid only if Module 1 is passed. The final grade is calculated as the average of the scores obtained in both modules

No midterm assessments are scheduled

Examples of typical questions and exercises

Examples of questions and exercises are available on the Studium UniCT platform and/or Microsoft Teams.