Module 2: CS Fundamentals Overview

Primary text: Computer Science Distilled (Wladston Ferreira Filho)

This guide is the primary teacher. You do not need to read Computer Science Distilled front-to-back to complete the module. The main path builds a breadth-first map of core CS ideas, then asks you to explain, compare, and apply them. Source reading is only for clarification or extra depth.

---

Scope of This Module

This module is intentionally not a compressed rewrite of the whole book.

It uses Computer Science Distilled as a fast map of what computer science covers so later semesters feel connected instead of random. The target is not deep mastery of every area yet. The target is a coherent first-pass mental model.

What this module deliberately covers now:

• modeling problems as procedures, logic, and representations
• thinking about feasibility in terms of time, memory, and growth
• recognizing major algorithm strategy families
• separating data abstractions from data structures
• seeing how databases organize persistent information
• understanding the main machine layers beneath code
• recognizing programming paradigms as different ways to structure thought

What this module deliberately defers:

• formal proof work and heavier discrete-math depth
• detailed probability treatment
• full algorithm-design coverage such as branch and bound and operations research
• full database design and administration
• low-level optimization and compiler internals
• language-specific programming mastery

Those topics matter. They simply belong in later focused modules rather than in Semester 0's orientation sweep.

---

Before You Start

Close everything and answer these from your current understanding:

1. What is computer science about besides "writing code"?
2. Why can some problems become unrealistic even if a computer is very fast?
3. What is the difference between a data structure and a database?
4. When you run a program, what layers sit between your source code and the hardware?
5. Why do different programming languages make the same task feel different?

If your answers are vague, that is expected. This module is here to turn vague nouns into a usable map.

---

What This Module Is For

Module 1 gave you a first feel for algorithms. Module 2 zooms out and answers the bigger question: where do algorithms sit inside computer science as a whole?

By the end of this module, you should be able to place major topics on a map:

• problems become models
• models become algorithms
• algorithms operate on data
• data lives in memory and databases
• code is translated to run on machines
• languages and paradigms shape how you express the solution

That mental map matters because the rest of the degree will keep returning to these same layers with more depth.

---

Concept Map

The order matters. First understand what the problem looks like, then whether it is feasible, then which strategy and data choices fit it, then where the data lives, then how the program runs, and finally how language shapes the expression.

---

How To Use This Module

Use the concept pages first. They are the primary path. Then do the practice pages. Open the reference section only when a concept is still fuzzy or when you want the source-book framing behind the guide.

This module uses light cluster organization so the breadth-first map stays coherent instead of becoming a flat list of unrelated nouns.

Cluster 1: Models and Growth

Order	Concept	Type	Focus
1	Computer Science Starts With Models	PRIMARY	Flowcharts, pseudocode, logic, and why CS starts with representation
2	Feasibility Is About Growth	SUPPORTING	Time, memory, dominant growth, and why exponential work changes everything

Cluster mastery check: Can you turn a problem into a usable representation and explain why growth rate matters before implementation details?

Cluster 2: Strategy, Data, and Storage

Order	Concept	Type	Focus
3	Strategy Beats Blind Search	PRIMARY	Brute force, backtracking, heuristics, divide and conquer, and dynamic programming
4	Abstractions Hide Memory Details	SUPPORTING	ADTs, stacks, queues, maps, arrays, and linked lists
5	Databases Shape What Is Easy	SUPPORTING	Relational design, NoSQL tradeoffs, transactions, and serialization

Cluster mastery check: Can you name a problem signal, pick a fitting strategy, and then choose data and storage choices that match the workload?

Cluster 3: Execution and Expression

Order	Concept	Type	Focus
6	Your Code Runs Through Layers	PRIMARY	CPU, memory, compiler, operating system, and cache hierarchy
7	Languages Are Ways of Thinking	SUPPORTING	Variables, scope, types, and imperative vs declarative vs logic thinking

Cluster mastery check: Can you explain how a program moves from source code to hardware and how language design changes the way solutions are expressed?

Then work these:

Order	Practice path	Focus
1	Redraw the CS Map From Memory	Retrieval, comparison, and core vocabulary recall
2	Diagnose a Computing Approach	Match a problem to strategy, data, storage, and execution choices
3	Explain One Program Through the Stack	Trace one real program from source code down to hardware and back

Use Module Quiz after the concept and practice pages. Use Book Exercise Lanes when you need more guided repetition from the local book chunks. Use Learning Resources and Reference and Selective Reading only when you want targeted source support.

---

Learning Objectives

By the end of the module you should be able to:

1. Explain what computer science studies besides programming syntax.
2. Describe why input growth, not just raw CPU speed, determines whether an approach is practical.
3. Recognize when a problem suggests brute force, pruning, divide and conquer, memoization, or a heuristic shortcut.
4. Distinguish an abstract data type from a concrete data structure and choose one by the operations you need.
5. Explain the main tradeoff between relational and non-relational storage at a beginner level.
6. Describe the path from source code to compiler to operating system to CPU and memory.
7. Explain how variables, types, scope, and programming paradigms shape code organization.

---

Outputs

• one one-page CS map that links problems, algorithms, data, storage, machines, and languages
• one short note comparing two growth classes, such as O(n) vs O(n^2) or O(n^2) vs O(2^n)
• one strategy classification table for at least four problems
• one ADT vs data-structure choice table
• one storage comparison between a relational and non-relational design
• one explanation of a simple program through the compiler/OS/hardware stack
• one short Feynman-style explanation of "what computer science is"

---

Completion Standard

You have completed Module 2 when all of these are true:

• you can explain computer science as problem modeling plus computation, not just "coding"
• you can name why growth rate and memory access matter before implementation details
• you can distinguish at least three strategy families and say when each is a fit
• you can explain the difference between an ADT and a data structure with one concrete example
• you can compare relational and non-relational storage without turning either into a slogan
• you can explain what a compiler and operating system each do for a program
• you can describe how programming paradigms change the style of a solution
• you produced at least one real map, table, or written walkthrough instead of only reading

If the words feel familiar but you cannot draw the map or explain the stack in plain language, the module is not complete yet.

---

Reading Policy

• Read only if stuck means the guide should be enough for most learners.
• Optional deep dive means extra nuance, not required progress.
• If the concept pages and practice pages are complete, you have made real progress even without reading the full source text.

---

Suggested Weekly Flow

Day	Work
1	Concepts 1-2 and one quick CS map sketch
2	Concept 3 and a strategy comparison note
3	Concept 4 and one ADT/data-structure table
4	Concepts 5-6 and one program-stack walkthrough draft
5	Concept 7 and one language-paradigm comparison
6	Practice pages 1-3, refine one artifact, and open the reference section only where still needed

---

Reference

If you want targeted source chunks or a concept-to-source map, use Reference and Selective Reading.

---

Rich Learning Pages

Worked Examples | Guided Labs | Case Studies | Mistake Clinic | Reading Guide | Capstone Thread