JCL

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Description of Course Unit ======

**Master in Informatics and Computing Engineering\\
  Programming Fundamentals\\
  Instance: 2020/2021**
\\
---
\\

[[https://sigarra.up.pt/feup/en/UCURR_GERAL.FICHA_UC_VIEW?pv_ocorrencia_id=459463|Institutional page]] | 
[[ficha|[Portuguese] ]]

===== General information =====

**Course Unit**: Programming Fundamentals\\
**Acronym**: FPRO\\
**Course**: MIEIC\\
**Curricular Years**: 1º\\
**Official website**: [[https://sigarra.up.pt/feup/en/UCURR_GERAL.FICHA_UC_VIEW?pv_ocorrencia_id=459463|Sigarra]]\\
**Credits ECTS**: 6\\
**Contact hours**: 70\\
**Total Time**: 162\\
**Instance**: 2020/2021\\
**Semestre**: 1S\\
**Lectures** (2x1,5h): João Correia Lopes ([[https://sigarra.up.pt/feup/en/func_geral.formview?p_codigo=230756|JCL]]) \\
**Recitations** (8x2h): João Correia Lopes ([[https://sigarra.up.pt/feup/en/func_geral.formview?p_codigo=230756|JCL]]), Rui Camacho ([[https://sigarra.up.pt/feup/en/func_geral.formview?p_codigo=209847|RCS]]), Ricardo Cruz ([[https://sigarra.up.pt/feup/pt/func_geral.formview?p_codigo=552793|RPMC]]), Nuno Moreira Macedo \\
**Attendance** (2x1h): 

===== Teaching language =====

Portuguese.

===== Objectives  =====

1. BACKGROUND

Fluency in the process of software development is a basic prerequisite to the work of Informatics Engineers. 
In order to use computers to solve problems effectively, students must be competent at reading and writing programs using higher-order programming languages.

2. SPECIFIC AIMS

The global aim of this Unit is to give the student the ability to create algorithms, and to use a programming language to implement, test, and debug algorithms for solving simple problems.

The student will be able to understand and use the fundamental programming constructs, and the functional approach to programming, specifically effect-free programming where function calls have no side-effects and variables are immutable, and contrast it with the Imperative approach.

3. PERCENT DISTRIBUTION

Scientific component: 40%\\
Technological component: 60%

===== Learning outcomes and competences =====

At the end of the course, the student is expected to handle programming problems of medium complexity, using the imperative or functional programming approaches or paradigms.

More specifically, the student will be able to: 

  - Design, implement, test and debug a program that uses the fundamental programming constructs, basic computations, standard conditional and iterative structures, simple Input/Output, persistence and exceptions.
  - Understand Data Abstraction and use simple and aggregate data types.
  - Understand Procedural Abstraction and use the definition of functions, parameter passing, recursion.
  - Write useful functions that take and return other functions.
  - Implement basic algorithms that avoid assigning to mutable state or considering reference equality.
  - Correctly reason about variables and lexical scope in a program using function closures.
  - Define and use iterators and other operations on aggregates, including operations that take functions as arguments (especially map, reduce/fold and filter).
  - Use the programming tools that help writing, testing and documenting computer programs according to the programming best practices.

===== Working method =====

Presential.

===== Pre-requirements (prior knowledge) and co-requirements (common knowledge) =====

No previous knowledge is required.

===== Programme =====

  * Introduction to Computational Thinking, algorithms and programming with Python.
  * Fundamental programming concepts: simple data types; variables, expressions and statements; program flow, conditionals, iteration; functions, parameter passing, recursion; persistence; functions, parameter passing and recursion
  * Working with aggregate data types: strings, tuples, sets, lists, dictionaries.
  * Effect-free programming by using function calls without side effects and immutable variables.
  * First-class functions and closures.
  * Utility higher-order functions: map, reduce/fold and filter.
  * Generators and list comprehensions.
  * Problem-solving strategies.
  * Programming tools, debugging, exceptions.

===== Mandatory literature =====

  * Peter Wentworth, Jeffrey Elkner, Allen B. Downey, and Chris Meyers, //How to Think Like a Computer Scientist — Learning with Python 3//, Release 3rd Edition, 2020 [[https://media.readthedocs.org/pdf/howtothink/latest/howtothink.pdf|[PDF] ]][[http://openbookproject.net/thinkcs/python/english3e/|[HTML] ]] [[http://catalogo.up.pt/F/?func=direct&doc_number=000469776&local_base=UPB01|[Library] ]]

===== Complementary bibliography =====

  * Steven F. Lott, Building Skills in Python - A Programmer's Introduction to Python, FreeTechBooks, 2010 [[http://www.freetechbooks.com/building-skills-in-python-a-programmer-s-introduction-to-python-t687.html|HTML]]
  * Allen Downey, Think Python — How to Think Like a Computer Scientist, 2nd Edition, Version 2.2.23, Green Tea Press, 2015 [[http://greenteapress.com/thinkpython2/html/index.html|HTML]] [[http://greenteapress.com/thinkpython2/thinkpython2.pdf|PDF]] [[https://github.com/AllenDowney/ThinkPython2|code]]
  * David Mertz, Functional Programming in Python, O’Reilly Media, 2015 
  * Ernesto Costa, Programação em Python – Fundamentos e Resolução de Problemas. FCA – Editora de Informática, 2015. ISBN: 978-972-722-816-4 [[http://catalogo.up.pt/F/-?func=find-b&local_base=FEUP&find_code=SYS&request=000585384|[Library] ]]

===== Teaching methods and learning activities =====

The continuous enrolment of the student in the course is promoted, through the study and discussion of the course topics, previously distributed in Jupyter Notebooks, that will later be used in lectures.

The student is motivated to find the best ideas to solve specific problems, execute them and implement the programming solutions, in an elegant, legible and efficient (time and space) mode using the Python programming language.

Automatic correction tools are used to increase the efficiency of the feedback given to the students.

Lecture classes (T) are used to present and discuss the topics of the program, using a computer connected to a multimedia projector.

Recitation classes (TP) are used to help students understand the topics of the program and solve the weekly programming assignments.

In-class and away programming assignments are given on a weekly basis, to improve the regular and effective development of autonomous learning processes and are tested and graded using Moodle assignments.

In-class assignments are used for summative evaluation at the end of each lecture class using Moodle quizzes.

Students are encouraged to use the Play Web App (https://fpro.fe.up.pt/play) containing programming exercises selected by theme: "easy"to perform before the theoretical class, "of average difficulty" to perform before the weekly assignments (RE) and "difficult" to perform before the practical tests in a computer (PE).

In the classroom, the students use the same working environment that is used later in the individual assessments (PE) — IDE Spyder3, Test web app (https://fpro.fe.up.pt/test) to develop and submit the weekly assignments.

Whenever deemed necessary in the classroom, especially during the first month of classes, students are encouraged to go to the "Clinic", supervised by student assistants, to get help.

===== Software =====

  * Anaconda Distribution 2020.07 for Linux (https://www.anaconda.com)
  * Spyder3 (also included in Anaconda)
  * Python 3.8 (also included in Anaconda)
  * Jupyter Notebooks

===== Keywords =====

Physical sciences > Computer science > Programming

===== Type of assessment =====

Distributed evaluation without final exam.

===== Assessment Components =====

^ Designation                ^  Weight (%) ^
| Test                       |          80 |
| Practical or project work  |          20 |
|                     Total: |         100 |

===== Amount of time allocated to each course unit =====

^ Designation       ^  Time (hours) ^
| Autonomous study  |            92 |
| Class frequency   |            70 |
|            Total: |           162 |

===== Eligibility for exams =====

Students are eligible for the final theory evaluation (TE), if they do not exceed the absences limit (25% of the total number of estimated recitation classes) and if they obtain a minimum of 40% in the last practical on computer evaluation (PE04).

===== Calculation formula of final grade =====

The evaluation will be based on the following components:

**LE** = **L**ecture in-class **e**valuation: Multiple-choice questions about programming concepts, to be answered on an individual basis in the theoretical classroom (the best 20 from a total of 24 are selected)// [5 questions, 5 minutes]//\\
**RE** = **R**ecitation and away weekly **e**valuation: Weekly recitation classes and away programming assignments (the best 10 out of 12 are selected)// [5 questions, --]//\\
**PE** = **P**ractical on computer **e**valuation: Individual programming assignments in Moodle (the best 3 from a total of 4 are selected)// [5 questions, 90 minutes]//\\
**TE** = **T**heory **e**valuation: Multiple-choice questions about programming concepts, to be answered on an individual basis in Moodle with the consultation of one book// [50 questions, 90 minutes]//

**Final classification** = 10% LE + 10% RE + 50% PE + 30% TE

**Observations**:
  - A minimum classification of 40% in the component TE is required.
  - A minimum mark of 40% is required for the last  practical on computer evaluation (PE04).
  - There will be another PE (PE05) for students that miss the PE04 examination with proper justification, or students that did not obtain the minimum required. In the later case, the grade is limited to 50%.
  - There will be another TE (TE02) for students, eligible for the assessment, that miss the evaluation with proper justification, or students that did not obtain the minimum required in the component; in the later case, the grade is limited to 50%.
  - If the final classification is greater than 17, the student may be submitted to an oral examination and the final grade is the average of both grades.
  - Students which achieve at least 90% in the in-class, weekly programming, and practical in computer assignments (LE + RE + PE), by the middle of the course, may opt to retain the grades LE & RE and do a small project to achieve the maximum grade (100%) on these two components.

===== Examinations =====

The evaluation of this course uses four types of examinations:

  * In lecture classes, multiple-choice questionnaires in Moodle to assess students' comprehension on the exposed concepts (LE).
  * In-class and away programming assignments related to the current topics, to be submitted in Moodle and automatically graded (RE).
  * Practical on computer evaluation of programming assignments, to be submitted in Moodle and automatically graded, with the consultation of given languages reference texts (PE).
  * Theory evaluation with one book consultation using one multiple-choice questionnaire in Moodle to assess students ability to use and discuss the best algorithms and data structures for specific problems (TE).

===== Classification improvement =====

In the following academic year, the student can request improvement of classification that includes the practical evaluation in computer PE04 and the theoretical evaluation TE01, with the consultation of only one book, the same as for the regular students.

**Final classification** =  60% PE + 40% TE

**Observations**:
  - A minimum classification of 40% of each component, PE and TE, is required.
  - If the final classification is greater than 17, the student may be submitted to an oral examination and the final grade is the average of both grades.

===== Special evaluation (TE, DA, ...) =====

In the case of students who do not attend classes and go without the weekly evaluation (LE and RE), the final classification will be the average of the classification of two evaluation components: Practical on computer evaluation (PE) and Theory evaluation (TE), as of the regular students.

**Final classification** =  60% PE + 40% TE

**Observations**:
  - A minimum classification of 40% of each component, PE and TE, is required.
  - A minimum mark of 40% is required for the last practical on computer evaluation (PE04)
  - There will be another PE (PE05) for students that miss the PE04 examination with proper justification, or students that did not obtain the minimum required. In the later case, the grade is limited to 50%.
  - There will be another TE (TE02) for students, eligible for the evaluation, that miss the examination with proper justification, or students that did not obtain the minimum required in the component. In the later case, the grade is limited to 50%.
  - If the final classification is greater than 17, the student may be submitted to an oral examination and the final grade is the average of both grades.

===== Observations =====

No individual component grades (LE((**LE** = Read the book (and understand) + See good programming examples)), RE, PE, TE((**REPETE** = Repeat work with programs and exercises given or found elsewhere))) can be reused in another enrolment in the course.

Due to the rules imposed upon us after the publication of this document, namely the delay of 3 weeks in the beginning of the classes, this year it is not possible to complete the PE recovery PE05 before the TE01, as planed.

Thus, all students that do not have the RFF classification, for having exceeded the limit of absences, are eligible for the theoretical test TE01.

Note that the minimum grade requirement of 40% for each component (PE, TE) is maintained.

\\
 --- //[[jlopes@fe.up.pt|Correia Lopes]], 01/08/2020 08:42//