Learn & Review: Lecture 1: Introduction to CS and Programming

Course Introduction and Fundamentals of Programming

This lecture introduces the 6.100L course, outlining administrative details and diving into the fundamental concepts of how computers work and the basics of Python programming. The core idea is to learn programming as a skill through practice, focusing on computational thinking, problem-solving, and understanding computer science concepts.

Course Administration and Learning Approach

• Instructor: Anna Bell, with extensive experience in introductory computer science courses.
• Course Structure: Full semester version of 6.100L.
• Lecture Format: A mix of teaching, opportunities for questions, and interactive "You Try It" breaks for hands-on coding practice.
• Learning Emphasis: Programming is a skill that requires consistent practice, similar to math or reading. Passive observation is insufficient for mastery.
• Key Takeaways:
  • Knowledge of computer science concepts.
  • Programming skill development.
  • Problem-solving abilities.
• Practice Opportunities: Lectures, handouts, and various resources are provided for practice at different levels.

Core Concepts in Computer Science

• Computational Thinking: Shifting the problem-solving approach from manual or purely mathematical methods to leveraging computation.
• Imperative vs. Declarative Knowledge:
  • Declarative Knowledge: A statement of fact (e.g., the definition of a square root). Computers cannot directly act on this.
  • Imperative Knowledge: A recipe or a set of instructions on how to do something. This is what computers execute.
• Algorithms: A sequence of steps with flow of control and a stopping condition.
  • Example: A simple algorithm for finding the square root of a number by iterative guessing and averaging.
  • Characteristics: Sequence of steps, flow of control (if/else, loops), and a termination condition.
• Computers as Machines:
  • Computers are machines that execute algorithms.
  • They are not inherently smart; they follow instructions precisely.
  • Strengths: Storing vast amounts of data and performing operations very quickly.
  • Big Idea: A computer only does what you explicitly tell it to do.

History and Low-Level Computer Operations

• Fixed Program Computers (Pre-1940s): Limited functionality, requiring re-input of operations for each task (e.g., pocket calculators).
• Stored Program Computers (Post-1940s): Capable of storing instructions as data, executed by an interpreter.
• Basic Computer Components:
  • Memory: Stores data and instructions.
  • Arithmetic Logic Unit (ALU): Performs calculations (addition, subtraction) and comparisons.
  • Control Unit: Manages the execution flow of instructions.
• Low-Level Programming: Writing programs using basic operations like addition, comparison, and data movement is tedious.

The Power of Programming Languages and Abstraction

• Turing Completeness: Alan Turing demonstrated that any computable problem can be solved with a very basic set of primitives, implying that any program computable in one language is computable in any other.
• Python Primitives: Python offers more convenient primitives (numbers, characters, operators) that allow for more complex operations in less time compared to fundamental Turing machine primitives.
• Analogy with English:
  • Primitives: Letters/Characters -> Words -> Sentences -> Stories -> Books.
  • Programming: Numbers/Characters/Operators -> Expressions -> Programs.
• Syntax and Semantics:
  • Syntax: The rules governing the structure of statements (e.g., "noun verb noun" is valid English syntax). In Python, object operator object is a common syntactical structure.
  • Static Semantics: Rules that govern meaning beyond basic structure (e.g., "I are hungry" is syntactically correct but semantically incorrect). In Python, using an operator between incompatible types (like + between a string and a number) results in a static semantic error.
  • Semantics: The actual meaning and execution of a program. Programming languages aim for unambiguous meaning, unlike natural languages which can have multiple interpretations. Errors often arise from the difference between intended and actual program meaning.

Working with Objects and Types in Python

• Core of Programming: Creating and manipulating objects.
• Objects and Types: Every object has a type, which dictates the operations that can be performed on it.
  • Example: An integer (30) supports mathematical operations, while a string ("Anna") supports operations like finding its length or accessing characters.
• Scalar Objects (Primitives):
  • Integers (int): Whole numbers (e.g., 5, -100).
  • Floats (float): Real numbers with decimal points (e.g., 3.14, 2.0).
  • Booleans (bool): Truth values (True, False - capitalization matters).
  • None Type (NoneType): Represents the absence of a value (None).
• Type Command: Used to determine the type of an object (e.g., type(7) returns <class 'int'>).
• Type Casting: Creating a new object of a different type from an existing one (e.g., float(3) creates 3.0, int(5.9) truncates to 5). Note that casting does not modify the original object.
• Rounding: The round() function can implicitly cast to an integer.

Expressions and Their Evaluation

• Expressions: Combinations of objects and operators that evaluate to a single value (e.g., 3 + 2).
• Evaluation: Python evaluates expressions, producing a single resulting value, which is then stored, not the expression itself.
• Operator Precedence: Rules that determine the order of operations (exponentiation > multiplication/division/modulo > addition/subtraction). Parentheses can override precedence.
• Type Rules for Operations:
  • Addition, subtraction, multiplication: Yield int if both operands are int; otherwise, float.
  • Division (/): Always yields a float.
  • Floor Division (//): Yields the integer part of the division.
  • Modulo (%): Yields the remainder of the division.
  • Exponentiation (**): Similar type rules to multiplication; if either operand is float, the result is float.

Variables and Assignment

• Purpose of Variables: To give meaningful names to objects (values), making code more readable and manageable.
• Assignment Statement: Uses the = operator to bind a name (variable) to a value.
  • Syntax: variable_name = value_or_expression
  • Key Difference from Math: The left side of = is a variable name, not an expression. The operation is assignment, not equality testing.
• Evaluation Order: The right-hand side of an assignment is evaluated first, and its resulting value is then bound to the variable name on the left.
• Variable Naming Rules: Variable names must start with a letter or underscore, followed by letters, numbers, or underscores. They are case-sensitive.
• Code Style: Choosing descriptive variable names and using comments (#) significantly improves code readability and maintainability.
• Rebinding Variables: A variable name can be reassigned to a new value. This does not change the original object but creates a new binding.
• Sequential Execution: Programs are executed line by line in order, unless control flow structures (introduced later) alter this sequence.
• Debugging Tools: Tools like Python Tutor can help visualize code execution step-by-step, showing variable changes and aiding in debugging.
• Swapping Values: A common programming task that often requires a temporary variable to correctly swap the values of two variables.