C9000 - Elements of Informatics (1) (LM)

Learning outcomes

At the end of the course, the student has a basic understanding of computational tools and terminology. He is able to: - understand the basic functioning principles of modern computers - understand computational thinking - reason algorithmically to solve computational problems - use the Python programming language to write simple programs - understand programs written by others

Course contents

No prior knowledge of programming is required. Students are expected to be familiar with the basic use of a personal computer, including working with files and folders and using a web browser.

The course provides the shared computational vocabulary and practical programming foundations required to engage with the technical components of the Digital Minds curriculum.

The fundamental concepts of informatics and programming are introduced through Python. Students work with code from the beginning and progressively learn to formulate computational problems, design simple solutions, and read, test, complete, and write short programs.

The course covers the following topics:

1. Computers, programs, and computational problem solving
   • the distinction between hardware and software
   • the basic functioning principles of modern computers and the hierarchy of abstract machines
   • operating systems, file systems, programming languages, and programming tools
   • computational problems and algorithmic problem solving
   • data, algorithms, and the step-by-step formulation of solutions
2. Python foundations
   • running Python interactively and executing programs
   • values, basic data types, names, expressions, and statements
   • input and output
   • Boolean expressions and conditional execution
   • errors, debugging, and simple testing practices
3. Functions and iteration
   • defining and calling functions
   • parameters and return values
   • iteration with for and while loops
   • tracing program execution and reasoning about program behaviour
   • a basic introduction to recursion and its relationship with iteration
4. Structured data and files
   • strings, lists, and dictionaries
   • a brief overview of tuples and sets
   • selecting, traversing, and transforming data
   • reading from and writing to text files
   • representing and processing simple tabular data in CSV files
5. Libraries and object-oriented
   • importing and using modules from the Python standard library
   • reading simple documentation and using library APIs
   • using objects and understanding the basic object-oriented programming needed to work with library APIs, including objects, classes, attributes, and methods
6. Computational limits
   • an introduction to time and space complexity by comparing simple alternative solutions
   • an introduction to the limits of computability

Readings/Bibliography

Required study materials

The materials needed to prepare for the examination are the slides and the source code for the programs discussed in class. They will be uploaded progressively to the course area on Virtuale. Students are required to enrol in the course area and consult it regularly.

Because programming is a practical skill, students should devote most of their independent study time to solving exercises and to reading, tracing, testing, debugging, and writing code. Studying the theoretical concepts remains necessary for understanding the subject and preparing for the theoretical part of the examination, but practical work with programs is the principal means of achieving the course learning outcomes.

Recommended readings

Introductory Python textbooks

• Charles R. Severance, Python for Everybody: Exploring Data in Python 3. Open online edition [https://www.py4e.com/html3/] . An accessible and practical introduction to Python for absolute beginners, with examples centred on processing data. Suggested chapters: 1-10 and 14.
• Allen B. Downey, Think Python: How to Think Like a Computer Scientist, 3rd ed. Open online edition [https://allendowney.github.io/ThinkPython/] . A concise introduction that places particular emphasis on reasoning about programs, decomposition, debugging, and the development of reliable mental models. Suggested chapters: 1-11, the sections on files in Chapter 13, and Chapters 14-16.
• John V. Guttag, Introduction to Computation and Programming Using Python: With Application to Computational Modeling and Understanding Data, 3rd ed. MIT Press, 2021. Publisher's page [https://mitpress.mit.edu/9780262363433/introduction-to-computation-and-programming-using-python/] . A more extensive and technical treatment, useful for deepening the programming foundations of the course and for preparing for later work involving data and machine learning. Suggested chapters: 1-8 and 10-11.
• John M. Zelle, Python Programming: An Introduction to Computer Science, 4th ed. Franklin, Beedle & Associates, 2024. Publisher's page [https://www.shroffpublishers.com/books/9789355424952] . A traditional introductory computer science textbook, rich in worked examples and programming exercises and particularly useful for systematic practice. Suggested chapters: 1-3, 5-10, and 12-14.

Problem-based and broader introductions to informatics

• Michael D. Smith, Problem Solving with Python: Using Computational Thinking in Everyday Life. MIT Press, 2026. Book website [https://ctps.io/] . A problem-driven introduction that connects Python programming with broader ideas in informatics and includes a critical discussion of generative AI in programming. Suggested chapters: 1-10 for the introductory progression, 12-16 for algorithms, errors, debugging, and testing, and Chapter 18 for the use of generative AI.
• Christine Alvarado, Zachary Dodds, Geoff Kuenning, and Ran Libeskind-Hadas, CS for All. Franklin, Beedle & Associates, 2024. Book website [https://www.cs.hmc.edu/csforall] . An introduction designed for students outside computer science that connects programming with broader foundational ideas about computation. Suggested chapters: 1 and 4-7.

Theoretical foundations

• John MacCormick, What Can Be Computed? A Practical Guide to the Theory of Computation. Princeton University Press, 2018. Book website [https://whatcanbecomputed.com/] . A rigorous and substantially more advanced resource, recommended only for students who wish to explore computational problems, computability, and complexity beyond the introduction provided in the course. Suggested chapters: 1, 3, 4, and 10.

Teaching methods

The course consists of 30 hours of in-person interactive lectures held in a computer laboratory. The instructor introduces concepts through short explanations, writes and executes Python code live, and discusses the behaviour of programs and possible alternative solutions with the class.

Students are encouraged to ask questions, predict the results of code execution, identify errors, and contribute to the collective analysis of programs.

Class meetings may also include short guided programming exercises, depending on the pace of the class.

Regular attendance is therefore strongly recommended.

Each week, students are assigned automatically assessed exercises for independent practice on Virtuale. The exercises provide automatic feedback and allow students to monitor their progress. Students who submit a non-empty attempt for every assigned exercise receive one additional point on the final examination mark, as detailed in the Assessment methods section.

The use of generative AI tools is encouraged during the learning process to obtain explanations, explore alternative solutions, and support debugging. Classroom activities also address how to evaluate AI-generated code and explanations critically. Students remain responsible for verifying the correctness of their work. The use of generative AI tools is not permitted during the examination.

In consideration of the type of activities and teaching methods adopted, attendance in this course requires all students to have previously completed Modules 1 and 2 of the e-learning training on safety in study environments [https://elearning-sicurezza.unibo.it/] .

Assessment methods

Assessment is based on a single, individual, computer-based written examination held in person in a computer laboratory.

The examination is delivered through EOL, and CodeRunner is used for the programming tasks. The examination lasts two hours.

The examination awards up to 33 points and comprises three components of approximately equal weight:

• closed-ended or open-ended questions assessing knowledge and understanding of the theoretical concepts and terminology covered in the course
• tasks requiring students to read, trace, explain, and complete Python programs
• tasks requiring students to write short Python programs to solve specified problems

Each component normally contributes up to 11 points. There is no negative marking: incorrect or unanswered questions receive no points, while partial credit may be awarded where appropriate.

Students may execute and test their programs during the examination and can see some of the automatic test results. CodeRunner provides automatic assessment, but the instructor reviews every submission. Partial credit may therefore be awarded to solutions that demonstrate a sound approach but do not pass all the automatic tests. Program correctness is the primary criterion; the appropriateness of the solution strategy, code readability, and overall code quality also contribute to the assessment to a lesser extent.

The examination is passed with a score of at least 18 points. After the examination has been passed, one additional point is awarded to students who submitted a non-empty attempt for every weekly automatically assessed exercise by the relevant deadline. No minimum level of correctness is required, but submissions may be subject to sample checks. Weekly deadlines cannot be extended because solutions are discussed in subsequent class meetings. The additional point remains valid for all examination sessions. Any final score above 30 is recorded as 30 cum laude.

During the examination, students may use Thonny [https://thonny.org/], EOL, and the official Python documentation [https://docs.python.org/3/] . Books, personal notes, previously prepared source code, and any other materials are not permitted. Blank paper is provided by the instructor. No other websites or digital tools may be accessed.

For the purposes of assessment, the use of generative AI is prohibited. Any use constitutes a breach of academic integrity.

The following criteria describe the overall level of achievement associated with the final grade:

• 18-20: essential knowledge of the concepts and terminology; ability to interpret straightforward code and produce simple programs addressing the basic requirements, although with inaccuracies, limited organisation, or incomplete handling of relevant cases
• 21-24: sound knowledge of the main concepts; generally correct reading, tracing, and completion of programs; ability to solve standard programming problems, with possible limitations in clarity, decomposition, or the handling of some cases
• 25-27: good command of the course content; accurate analysis of program behaviour; correct solutions to most programming tasks, with appropriate decomposition and generally clear and well-structured code
• 28-30: very good or excellent command of theoretical and practical aspects; precise explanations of program behaviour; correct, complete, and effective solutions, with clear structure and appropriate handling of relevant cases
• 30 cum laude: an overall score above 30, corresponding to excellent achievement across the assessed theoretical and programming skills

Students with specific learning disorders or temporary or permanent disabilities are advised to contact the relevant University office in good time. The office will propose any appropriate accommodations, which must be submitted to the instructor for approval at least 15 days before the examination. The instructor will assess their suitability in relation to the course learning outcomes. Further information is available on the University website [https://site.unibo.it/studenti-con-disabilita-e-dsa/en] .

Teaching tools

The following teaching tools and resources are used:

• A computer laboratory and a classroom projection system are used for live programming demonstrations, collective code discussion, and guided exercises.
• Thonny [https://thonny.org/], a Python editor and programming environment designed for beginners, is recommended for writing, executing, testing, and debugging programs. Students who already prefer another Python editor or programming environment are free to use it instead.
• Virtuale, the University's e-learning platform, is used for course communications, slides, the source code for programs discussed in class, and automatically assessed exercises with feedback.
• Generative AI tools may be used during classroom activities and individual study to request explanations, explore alternative solutions, support debugging, and carry out self-assessment activities.

The outputs of generative AI tools must be evaluated critically and verified by students. No specific generative AI product or paid service is required for the course. The use of generative AI tools is not permitted during the examination.

Office hours

See the website of Michael Lodi