Sefism Programming Foundations Cheat Sheet

What this cheat sheet is

The Programming foundations cheat sheet is the quick-revision companion to the Programming foundations roadmap. It covers language basics, collections and errors, Git, how computers run code, data structures, clean design, testing and shipping projects. Each concept is a short entry that says what it is and why it matters, often with an example or the classic beginner mistake.

Use it to check you still remember something, not to learn it the first time. Skim a chapter before a project, an exam or a technical conversation, and open the one concept you half remember.

Editions

The sheet follows the roadmap's five languages: Python, JavaScript, Java, C++ and C#. Eight chapters are shared by every edition, and each edition adds one chapter of essentials for its language, so you read nine chapters and about 76 to 77 concepts. A few shared entries also change with the language, such as garbage collection (not in the C++ edition) and the package tool in the projects chapter: pip, npm, Maven and Gradle, CMake or NuGet.

Chapter by chapter

1. Language basics (9 concepts). Variables and types, static and dynamic typing, conditionals, loops, functions, scope, strings and formatting, null and missing values, and reading and validating input.
2. Collections, errors and files (8 concepts). Lists and dynamic arrays, dictionaries and maps, sets, mutability and copying, exceptions, reading files and cleaning up, modules and imports, and reading errors and debugging.
3. Your language's essentials (7 concepts, one chapter per edition).
   • Python: comprehensions, generators and yield, truthiness and is None, mutable default arguments, type hints, dataclasses and the main guard.
   • JavaScript: let, const and var, === and ==, closures, destructuring and spread, the event loop, promises and async/await, and this.
   • Java: JDK, JVM and bytecode, primitives and wrapper types, equals and hashCode, records, generics, checked and unchecked exceptions, and streams and lambdas.
   • C++: compiling and linking, references and const, pointers, RAII, smart pointers, undefined behaviour and move semantics.
   • C#: the dotnet CLI, value and reference types, nullable reference types, properties, records, LINQ, and async and await.
4. Command line and Git (11 concepts). Shell navigation, repositories and commits, the staging area, .gitignore, branches, merging and rebasing, merge conflicts, remotes, pull requests, undoing mistakes and commit messages.
5. How computers run your code. Bits, bytes and binary, text encoding and Unicode, how the CPU runs a program, compiled and interpreted code, stack and heap, passing arguments to functions, garbage collection, floating point, integer overflow, and processes and threads.
6. Data structures and Big-O (10 concepts). Big-O, arrays and amortised growth, linked lists, stacks, queues and deques, how hash tables work, trees and binary search trees, graphs, recursion and binary search.
7. Object-oriented design and clean code (10 concepts). Classes and objects, encapsulation, inheritance and composition, interfaces and polymorphism, separation of concerns, DRY, KISS and YAGNI, naming and small functions, SOLID, code smells and refactoring, and comments, docstrings and READMEs.
8. Testing your code (5 concepts). Unit tests, test-driven development, test doubles, edge cases and the test pyramid.
9. Build and ship projects. Scoping a small project, reading and writing JSON, calling a public API, your language's package tool, configuration and secrets, writing a README and publishing on GitHub.

Tips worth pinning

The sheet closes with short rules, including:

• Read the first error message fully before changing anything; later errors are often caused by the first.
• Commit small working steps with messages that say why, and push at least once a day.
• When you find a bug, write a failing test that reproduces it before you fix it.
• Never compare floating point numbers with ==, and keep money in integer cents or a decimal type.
• Ask AI to explain an error or quiz you, not to write the logic you are trying to learn.

Each edition adds one of its own, such as passing a compare function when sorting numbers in JavaScript, or comparing strings with equals in Java.

How to use it with the roadmap

• After each roadmap stage, read the matching chapter and try to explain every concept aloud. Anything you cannot explain is the topic to revisit.
• Before you start a project, reread the testing and shipping chapters so the README, tests and secrets are planned from day one.
• When a bug confuses you, check the language essentials chapter first. Most beginner bugs live there: mutable defaults in Python, == in JavaScript and Java, undefined behaviour in C++.

How it works on Sefism

Everything on Sefism is free to learn from. The public page at Programming foundations cheat sheet shows every chapter title, with the first two chapters open in full. Later chapters show their title, a short introduction and how many concepts they hold.

Keeping the sheet uses credits, and it is yours for good after that. Adding the Programming foundations roadmap to your dashboard also opens this sheet, so if you plan to follow the roadmap you do not need to keep the sheet separately. New members get starting credits when they join, and the first roadmap is free. Create a free account to get started, and if a concept still does not make sense after reading it, ask Tauseef a question.

Related on Sefism

• Which programming language to learn first
• How to take notes and remember what you learn in programming
• Git: the model behind the commands
• The DSA and problem solving cheat sheet, for when data structures need more depth

Frequently asked questions

Can I learn to code from a cheat sheet? Not on its own. It is for revising and checking. The roadmap is where the practice happens.

Which edition should I choose? The language you are learning. Eight chapters are the same in every edition, so switching later costs little.

Does it cover Git? Yes, a full chapter of eleven concepts, from the staging area to undoing mistakes and writing commit messages.