These were originally posted on Blogspot under the name "Hassan Codes." Now that I have my own site, they've moved here. Time changes, haha.
What Java actually is, why it's a solid starting language, and how the JDK, compiler, and interpreter fit together, explained with a Dumbledore analogy.
Writing and running your first Java program, understanding the main method, file naming rules, and the structure of a basic Java class.
Understanding primitive and reference types, variable declaration, and type conversion in Java.
Arithmetic, relational, logical, and bitwise operators, with operator precedence and practical examples.
Taking user input using Scanner class and handling different data types from console input.
Printing to console using System.out.println(), System.out.print(), and formatting output.
Conditional branching with if, else if, and else statements for decision making in programs.
Using switch statements for multiple condition checking and when to use them over if-else chains.
Understanding while and do-while loops, loop conditions, and when to use each type.
Using for loops for iteration, understanding initialization, condition, and increment/decrement.
Using loops inside loops for pattern printing, matrix operations, and complex iterations.
Declaring and calling methods, understanding parameters, return types, and method structure.
Method overloading with different parameter lists and compile-time polymorphism.
Understanding recursive methods, base cases, and practical examples like factorial and Fibonacci.
Declaring, initializing, and working with single-dimensional arrays in Java.
Working with 2D and multi-dimensional arrays, matrix operations, and nested loops with arrays.
The app, the pivot from Java and JSON to Kotlin and Room, and real users on the Play Store.
What happens when an Android app runs, from DEX to ART to the sandbox.
The real package layout, what each file is for, and why the data package exists.
The identity document of the app, and what Android reads before running any code.
How source code becomes an APK, and what the build settings actually mean.
How a screen is described in XML and turned into pixels.
What an Activity is and why the lifecycle is the concept everything else builds on.
How Kotlin code talks to XML layouts, from view lookups to click listeners.
SharedPreferences and a JSON file, and why that setup eventually stopped being enough.
Why the move to a real database happened and how the migration was designed.
How a silent R8 stripping issue nearly destroyed a real upgrade, and how it was caught.
How light and dark mode work without a single manual toggle.
What signing means, what a keystore is, and why losing it is permanent.
The developer account, the store listing, and the closed testing gate.
Tooling, hello world, compiler errors and warnings, streams, and how core language, standard library, and STL relate.
Integer formats and modifiers, overflow and wrapping, floating point precision and setprecision, booleans, char and ASCII values, and type deduction with auto.
Operator precedence, prefix vs postfix, compound operators, comparison and logical operators, output formatting manipulators, numeric limits, math functions, and integer promotion.
If/else and nested conditions, switch statements and fall-through, and ternary expressions.
size_t as a loop counter, for loops, while loops, and do-while loops.
Declaring arrays, why stack array size must be compile-time, getting array size, and char arrays as C-strings.
Pointer declaration and dereferencing, pointers to pointers, the three const pointer variants, char pointers vs char arrays, the OS memory map, and stack vs heap.
Dangling pointers and the owner pointer pattern, handling allocation failure, null pointer safety, dynamic arrays, and pointer arithmetic including the stack array size trick.
Reference declaration and the three initialization syntaxes, const references, and how references compare to pointers.
cctype character checks and conversion, cstring length/comparison/search functions, concatenation and copying, and why std::string replaces all of it.
What a function is, the compilation model across multiple cpp files, the three ways to pass arguments, copy elision, and function overloading.
Lambda syntax and capture semantics, function templates and specialization, and C++20 concepts including the requires clause and constrained auto.
Classes and access levels, the member initializer list, creating stack and heap objects, destructors and their call order, the this pointer, method chaining, struct vs class, and object size and padding.
Protected members, public/protected/private inheritance types, construction and destruction order, copy constructors and slicing, inheriting base constructors, virtual destructors, and hiding vs overriding.
Static vs dynamic binding, virtual and override, overloading vs overriding vs hiding, vtables, object slicing, the final keyword, virtual destructors, dynamic_cast, and pure virtual functions and abstract classes.