CS50x 2026 – Lecture 1 – C

Introduction to Computer Science and C Programming

CS50 Lecture 1 serves as the foundation for Harvard University's renowned introduction to computer science. This comprehensive 150-minute lecture introduces beginners to the C programming language, one of the most influential and widely-used languages in software development. The session bridges the gap between computational thinking and practical programming, establishing essential concepts that learners will build upon throughout the course. Through hands-on demonstrations and clear explanations, instructor David J. Malan guides students from the very basics of source code to more complex programming constructs, creating an accessible entry point for anyone interested in understanding how computers work and how to communicate with them through code.

Understanding Source Code and Development Environments

The lecture opens by demystifying source code—the human-readable instructions that form the foundation of all software. Rather than viewing programming as an intimidating discipline, the session frames it as a practical skill rooted in clear logical thinking. Visual Studio Code for CS50 is introduced as the primary development environment, providing students with a professional-grade editor configured specifically for the course. This setup ensures that learners focus on understanding programming concepts rather than wrestling with complex tool configurations. The environment includes helpful extensions and pre-configured settings that make writing, testing, and debugging C code straightforward and intuitive.

First Steps: Hello World and Basic Syntax

Traditional programming education begins with the iconic "Hello, World" program, and CS50 follows this proven approach. However, the lecture goes deeper than simply printing text to the screen. Students explore what happens behind the scenes when code runs, connecting the written C syntax to the actual operations the computer performs. The transition from block-based visual programming (like Scratch) to C demonstrates how the same logical concepts manifest in a compiled language. This progression helps learners appreciate both the simplicity of their first programs and the power that C unlocks. By writing and executing their first working program, students gain confidence and concrete evidence that they can instruct computers to perform meaningful tasks.

Data Types, Variables, and Conditional Logic

Moving beyond simple output, the lecture introduces fundamental programming concepts like data types, which determine what kinds of information a program can work with. Students learn about integers, floating-point numbers, and strings, understanding how computers represent and manipulate different forms of data. Conditionals—statements that allow programs to make decisions based on logical conditions—form the next critical concept. Through practical examples like the compare.c and agree.c programs, viewers see how conditional statements enable programs to respond differently based on user input or calculated results. These building blocks are essential for creating any useful software, as almost every program needs to handle different scenarios and react accordingly.

Control Flow: Loops and Iteration Patterns

Loops represent one of the most powerful programming constructs, allowing code to repeat operations without requiring identical instructions to be written multiple times. The lecture covers loop mechanisms that enable programs to process collections of data, count iterations, or repeat actions until a condition changes. The cat.c example demonstrates practical loop usage, while the Mario example shows how loops can generate visual patterns—an engaging way to see programming abstractions produce tangible results. Understanding loops is crucial because they drastically reduce code repetition and make programs more flexible and maintainable. By the time students work through these examples, they begin to see how small programming concepts combine to create meaningful functionality.

Functions, Abstraction, and Code Organization

As programs grow more complex, functions become indispensable for organizing code into manageable, reusable pieces. A function encapsulates a set of instructions that perform a specific task, which can then be called multiple times throughout a program. This concept of abstraction—hiding complexity behind a well-defined interface—is fundamental to professional software development. The calculator.c example illustrates how functions break down a problem into logical steps, making the overall program easier to understand and maintain. Functions also represent humanity's natural way of organizing complex tasks: a chef doesn't memorize every motion of making a dish; they follow a recipe with clearly-defined steps. Similarly, programmers use functions to structure their instructions in ways that mirror logical problem-solving.

Code Quality: Correctness, Design, and Style Standards

Beyond making programs work, the lecture emphasizes that code must be correct, well-designed, and formatted consistently. Correctness means the program produces the intended output without errors. Design refers to the overall structure and organization—how cleanly the code solves the problem. Style encompasses naming conventions, indentation, and formatting that make code readable for both the original author and others who maintain it later. These standards matter because professional software is rarely written and forgotten; it is read, modified, and extended by multiple people over years or decades. By establishing good habits early, students develop practices that scale from small homework assignments to large-scale systems used by millions of people. The lecture reinforces that well-written code is not just technically superior—it demonstrates respect for future readers and maintainers.

Advanced Considerations: Type Safety and Data Representation

The final segments address more subtle but crucial concepts: integer overflow, type casting, floating-point precision, and how computers actually represent numbers in memory. The Boeing example vividly illustrates why these details matter—a real-world incident where overflow in fuel calculations contributed to a serious flight incident. These topics reveal that programming is not abstract; it has tangible consequences. Type casting allows programmers to convert between different data types, but doing so carelessly can lose information or produce unexpected results. Floating-point imprecision exists because computers represent decimal numbers as approximations, which can cause subtle bugs if not understood. By exploring these concepts, students move beyond "hello world" tutorials toward a deeper comprehension of how computers actually process information and why programmers must think carefully about implementation details.