• ES Español
• EN English

5.1. Introduction to Computing (Mandatory)

5.1.1. Justification ↑ Back to top

This is the first course in the sequence of introductory courses to Computer Science. This course introduces participants to the fundamental concepts of programming using Python. Topics include data types, control structures, functions, lists, recursion, and the mechanics of execution, testing, and debugging. Programming is one of the pillars of Computer Science; any professional in the area will need to program to materialize their models and proposals.

5.1.2. Generales Goals ↑ Back to top

1. Introduce the fundamental concepts of programming.
2. Develop the ability of abstraction using a programming language.
3. Develop problem-solving skills through algorithmic thinking.
4. Understand basic data structures and their applications.
5. Master the Python programming language for problem solving.

5.1.3. Contribution to Outcomes ↑ Back to top

AG-C08) Problem Analysis: Identifies, formulates, and analyzes complex computing problems. (Familiarity)

AG-C12) Applies computer science theory and software development fundamentals to produce computer-based solutions. (Usage)

5.1.4. Content ↑ Back to top

5.1.4.1. Introduction to Programming and History (4 hours) [Skills AG-C08,AG-C12] ↑ Back to top

Bibliography: (Zelle, 2010; Guttag, 2013; Brookshear and Brylow, 2019a)

Topics

1. Brief history of computing and programming languages.
2. Overview of Python programming language.
3. Programming environments and tools.
4. Basic program structure and execution.
5. Writing, running, and debugging simple programs.

Learning Outcomes

1. Identify important trends in the history of computing. [Familiarity]
2. Discuss the historical context of programming language paradigms. [Familiarity]
3. Compare daily life before and after personal computers and the Internet. [Assessment]
4. Write, compile, and run a simple Python program. [Usage]

5.1.4.2. Type Systems Fundamentals (6 hours) [Skills AG-C08,AG-C12] ↑ Back to top

Bibliography: (Zelle, 2010; Guttag, 2013)

Topics

1. A type as a set of values together with a set of operations:
2. Primitive types (e.g., numbers, Booleans)
3. Compound types built from other types (e.g., records/structs, unions, arrays, lists, functions, references using set operations) enumerate
4. Type safety and errors caused by using values inconsistently given their intended types
5. Goals and limitations of static and dynamic typing: detecting and eliminating errors as early as possible.
6. Primitive data types in Python (int, float, str, bool).
7. Type conversion and casting.

Learning Outcomes

1. Describe, for both a primitive and a compound type, the values that have that type [Familiarity]
2. Describe examples of program errors detected by a type system [Familiarity]
3. Use types and type-error messages to write and debug programs [Usage]
4. Explain Python's dynamic typing system. [Familiarity]

5.1.4.3. Object-Oriented Programming Fundamentals (14 hours) [Skills AG-C08,AG-C12] ↑ Back to top

Bibliography: (Zelle, 2010; Guttag, 2013; Brookshear and Brylow, 2019a)

Topics

1. Imperative programming as a subset of object-oriented programming.
2. Definition of classes: fields, methods, and constructors.
3. Dynamic vs static properties.
4. Variables, expressions, and assignments.
5. Input and output operations.
6. Conditional statements (if, elif, else).
7. Iteration structures (for loops, while loops).
8. Nested loops and loop control statements.
9. Exception handling basics.

Learning Outcomes

1. Compose a class through design, implementation, and testing to meet behavioral requirements [Usage]
2. Predict and validate control flow in a program using dynamic dispatch [Assessment]
3. Use object-oriented encapsulation mechanisms such as interfaces and private members [Usage]
4. Implement programs using conditional and iterative structures. [Usage]
5. Debug programs with syntax and logical errors. [Usage]
6. Design and implement simple algorithms using loops. [Usage]

5.1.4.4. Functions and Parameter Passing (10 hours) [Skills AG-C08,AG-C12] ↑ Back to top

Bibliography: (Zelle, 2010; Guttag, 2013; Hunt and Thomas, 1999)

Topics

1. Function definition and invocation.
2. Parameter passing mechanisms (by value, by reference).
3. Return values and multiple returns.
4. Variable scope and lifetime (local, global, nonlocal).
5. Recursion fundamentals.
6. Lambda expressions and higher-order functions.
7. Functions as first-class objects.
8. Documentation and testing of functions.

Learning Outcomes

1. Define and implement functions with proper parameter passing. [Usage]
2. Explain the difference between pass-by-value and pass-by-reference. [Familiarity]
3. Implement recursive solutions to simple problems. [Usage]
4. Use lambda expressions for functional programming constructs. [Usage]
5. Design functions with appropriate scope and documentation. [Assessment]

5.1.4.5. Basic Data Structures (10 hours) [Skills AG-C08,AG-C12] ↑ Back to top

Bibliography: (Zelle, 2010; Guttag, 2013)

Topics

1. Lists and list operations (indexing, slicing, mutability).
2. Tuples and immutability.
3. Dictionaries and key-value mapping.
4. Sets and set operations.
5. Strings as sequences.
6. List comprehensions and generator expressions.
7. Basic searching and sorting algorithms.
8. Introduction to algorithmic complexity for basic operations.

Learning Outcomes

1. Implement programs using lists, dictionaries, and sets. [Usage]
2. Choose appropriate data structures for given problems. [Assessment]
3. Explain the trade-offs between different data structures. [Familiarity]
4. Implement basic search and sort operations on lists. [Usage]

5.1.4.6. Object-Oriented Programming Fundamentals (10 hours) [Skills AG-C08,AG-C12] ↑ Back to top

Bibliography: (Zelle, 2010; Guttag, 2013)

Topics

1. Subclasses, inheritance (including multiple inheritance), and method overriding.
2. Dynamic dispatch: definition of method-call.
3. Object-oriented idioms for encapsulation:
4. Privacy, data hiding, and visibility of class members.
5. Interfaces revealing only method signatures.
6. Abstract base classes, traits and mixins. enumerate
7. Classes and objects in Python.
8. Attributes and methods.
9. Inheritance and polymorphism basics.
10. Encapsulation and information hiding.

Learning Outcomes

1. Build a simple class hierarchy utilizing subclassing that allows code to be reused for distinct subclasses [Usage]
2. Explain the relationship between object-oriented inheritance (code-sharing and overriding) and subtyping (the idea of a subtype being usable in a context that expects the supertype) [Familiarity]
3. Compare and contrast the benefits and costs/impact of using inheritance (subclasses) and composition (specifically, how to base composition on higher order functions) [Assessment]
4. Design and implement simple classes in Python. [Usage]
5. Explain the benefits of OOP for code organization. [Familiarity]

5.1.4.7. Algorithmic Strategies (6 hours) [Skills AG-C08,AG-C12] ↑ Back to top

Bibliography: (Guttag, 2013; Cormen et al., 2009)

Topics

1. Paradigms:
2. Brute-Force (e.g., linear search, selection sort, traveling salesperson, knapsack)
3. Decrease-and-Conquer:
4. By a Constant (e.g., insertion sort, topological sort)
5. By a Constant Factor (e.g., binary search)
6. By a Variable Size (e.g., Euclid's) enumerate
7. Divide-and-Conquer (e.g., binary search, quicksort, mergesort, Strassen's)
8. Greedy (e.g., Dijkstra's, Kruskal's, Knapsack)
9. Transform-and-Conquer:
10. Instance simplification (e.g., find duplicates via list presort)
11. Representation change (e.g., heapsort)
12. Problem reduction (e.g., least-common-multiple, linear programming)
13. Dynamic programming (e.g., Floyd's, Marshall, Bellman-Ford) enumerate
14. Space vs time tradeoffs (e.g., hashing) enumerate
15. Iteration vs recursion (e.g., factorial, tree search)
16. Problem decomposition strategies.
17. Algorithm design techniques.
18. Debugging and testing strategies.
19. Tracing program execution.

Learning Outcomes

1. For each of the paradigms in this unit:
2. Explain its definitional characteristics
3. Explain an example that demonstrates the paradigm including how this example satisfies the paradigm's characteristics. enumerate [Familiarity]
4. Give examples of iterative and recursive algorithms that solve the same problem, explain the benefits and disadvantages of each approach [Usage]
5. Evaluate whether a greedy approach leads to an optimal solution [Assessment]
6. Apply systematic debugging techniques to locate and fix errors. [Usage]
7. Analyze algorithm complexity for simple problems. [Familiarity]

5.1.4.8. Modern Development Methods and Tool Usage (4 hours) [Skills AG-C08,AG-C12] ↑ Back to top

Bibliography: (Zelle, 2010; Hunt and Thomas, 1999)

Topics

1. Using modern programming environments (IDEs, notebooks).
2. Code search and reuse best practices.
3. Using standard libraries and APIs.
4. Debugging and testing techniques.
5. Version control basics.
6. Code documentation and style guidelines.
7. Virtual environments and package management.

Learning Outcomes

1. Use modern development tools effectively. [Usage]
2. Apply code reuse principles through libraries and APIs. [Usage]
3. Debug and test programs systematically. [Usage]
4. Follow coding standards and documentation practices. [Familiarity]
5. Manage Python packages and environments. [Familiarity]

5.1.5. Bibliography ↑ Back to top

Zelle, J. M. (2010). Python Programming: An Introduction to Computer Science. Franklin, Beedle & Associates Inc, 2nd edition.

Guttag, J. V. (2013). Introduction to Computation and Programming Using Python. MIT Press, 1st edition.

Brookshear, J. G. and Brylow, D. (2019a). Computer Science: An Overview. Pearson, global edition edition.

Hunt, A. and Thomas, D. (1999). The Pragmatic Programmer: From Journeyman to Master. Addison-Wesley, 1st edition.

Cormen, T. H., Leiserson, C. E., Rivest, R. L., and Stein, C. (2009). Introduction to Algorithms. MIT Press, 3rd edition.