Programming fundamentals

No recommended basic knowledge.

The following teaching methodologies are used in this course unit:

1. Expository method: explanatory method where theoretical foundations and concepts are presented by the teacher and discussed with the class. Concepts and information will be presented to students through, for example, slide presentations or oral discussions. It will be used in classes to structure and outline the information.

2. Demonstrative method: based on the example given by the teacher of a technical or practical operation that one wishes to be learned. It focuses on how a given operation is carried out, highlighting the most appropriate techniques, tools and equipment. It will be used, for example, in practical and laboratory classes.

3. Interrogative method: process based on verbal interactions, under the direction of the teacher, adopting the format of questions and answers. It allows for greater dynamics in the classroom and consolidates learning. It will be used, for example, to remember elements of previous classes and in revisions of the lectured content.

4. Active methods: pedagogical techniques will be used in which the student is the center of the learning process, being an active participant and involved in his own training. The teacher assumes the role of facilitator, stimulating critical thinking, collaboration, creativity and student autonomy. They will be applied in classes to achieve a dynamic and more lasting learning environment.

At the end of the course unit, the student will be able to:

1. Classify the different types of programming languages. Analyze their main characteristics. Justify the need for compilers.

2. Define algorithm. Analyze the approaches used to describe algorithms. Construct solutions using flowcharts and pseudo-code.

3. Analyze the main characteristics of a programming language. Explain the standardization process. Discuss the development cycle and the structure of a program.

4. Discuss the types and formats of variables. Illustrate the creation, initialization, and modification of variables. Demonstrate the usage of casting between variables.

5. Explain conditional and unconditional flow control. Identify the different types of conditional control structures. Illustrate the application and precedence of logical and relational operators. Create programs that demonstrate the usage of tests and conditions.

6. Identify structures for interactive conditional control. Justify the usage of operators for code optimization. Identify scenarios and usages for infinite loops. Create programs that demonstrate the usage of loops.

7. Define functions. Classify the types of functions. Explain the syntax of a function. Demonstrate the use of multiple files. Create programs that exemplify the functionality and utility of functions.

8. Explain the concept of arrays. Analyze how they are created, accessed, and manipulated. Demonstrate how constants can be created. Define String. Discuss how strings are created, accessed, and manipulated. Create programs that make usage of arrays and strings.

9. Define files. Classify the types of files and streams. Analyze the different operations associated with text files. Demonstrate the passing of parameters through the command line. Create programs that read and write to text files.

1. Programming languages. Language types. Low-level languages. Assembly language. High-level languages. Structured languages. Object-oriented languages. Data types, control structures (sequential, selection, repetition). Compilers (gcc) and assemblers.

2. Introduction to algorithms: flowcharts and pseudo-code. Definitions. Declaring variables and assigning values. Arithmetic, relational and logical operators. Conditional branch command. Repeat commands.

3. C programming language. Characteristics. Standardization (K&R C, ANSI C, C23). Development cycle: source code, preprocessor, compilation, linking, execution. Structure of a C program: #include, main(), blocks, comments (/* */, //).

4. Data types. Variables: definition, type, nomenclature, declaration, assignment, arithmetic. Integer variables: types (short, long, signed, unsigned), format. printf() and scanf() functions. Real variables: IEEE 754 standard, types, format. Characters: types, format. Casting: implicit, explicit.

5. Tests and Conditions. Logical Values. Relational Operators (<, <=, >, >=, ==, !=). Logical Operators (!, &&, ||). Operator Precedence. Conditional flow control. if…else statement: indentation, statement blocks, chained statements. Switch statement. Unconditional flow control: break.

6. Cycles. Optimization: increment/decrement operators (++, –), assignment operators (+=, -=). Iterative conditional flow control: while, for, do…while. Infinite Cycles. Unconditional flow control: continue.

7. Functions. Function types: predefined (stdio.h, string.h), user defined. Syntax: return type, name, parameters, body, return. Local variables. Function position: prototype. Multiple Files: header files (.h). Passing parameters by value and by reference.

8. Arrays. Definition. Classification: one-dimensional, multidimensional. Declaration, initialization and access to elements. Passing arrays to a function. Constants: #define, const. Strings: declaration, initialization, reading and writing (printf, puts, scanf, gets). Functions for manipulating strings.

9. Files. Definition. Stream types: stdin, stdout, stderr. File types: binary, text (EOL: \n, \n\r). Operations in text files: opening, reading, writing, closing. Opening modes: r, w, a, r+, w+, a+, b. EOF macro and end-of-file function (feof()). Passing arguments through the command line (argc(), argv()).

NAO