R

ou
ge
N
eu
ro
n
Ac
ad
em
y
Preface 4
Mathematics 6
Action Items 6
References 6
Topics to explore using ChatGPT/Gemini 8
Algorithms and Data Structures 10

y
Action items: 11
References 11

em
Topics to explore using ChatGPT/Gemini 12
Data Structures 12
Algorithms 14

ad
Computer Architecture 16
Action items 16
References 17
Topics to explore using ChatGPT/Gemini
Operating Systems
Fundamentals
Ac 18
20
20
n
Distros (Distribution) 20
Action Items 20
ro

References 21
Topics to explore using ChatGPT/Gemini 22
eu

Programming Language 24
Action items 24
References 25
N

Topics to explore using ChatGPT/Gemini 27

File Systems 29
ge

Action items 29
References 29
Topics to explore using ChatGPT/Gemini 30
ou

Networking 32
Action Items 32
R

References 33
Topics to explore using ChatGPT/Gemini 33
Databases 36
Action items 36
References 37
Topics to explore using ChatGPT/Gemini 37
Compiler Design 40
System Administration 40

© RougeNeuron Academy (www.rougeneuron.in)

 Programming Fundamentals 40
Why is learning Automata helpful theory? 40
Action items 41
References 41
Topics to explore using ChatGPT/Gemini 42
Distributed Systems 45
Action items 45
References 46
Topics to explore using ChatGPT/Gemini 47

y
General Programming and Design patterns 50

em
Action Items 50
References 50
Topics to explore using ChatGPT/Gemini 51

ad
Software Engineering 54
Actions items 54
References 54

Ac
Topics to explore using ChatGPT/Gemini 55
Security 58
Action items 58
References 58
n
Topics to explore using ChatGPT/Gemini 59
ro
eu
N
ge
ou
R

© RougeNeuron Academy (www.rougeneuron.in)

Preface
Give a man a fish, and you feed him for a day; teach a man to fish, and you feed him for a
lifetime - Anon

Software engineering has evolved beyond coding. Therefore, a long-lasting software career
demands more than the aspirants' programming skills. Moreover, with the increasing supply of
engineers, the bar for quality is dropping. So, the recruiters hire for the short term, and the
recruited stay for an even shorter time.

y
The market-dictated learning leads to a decaying career from the early stages. A decade-long

em
career cannot pay off a loan with a tenure of 30 years. As a result, most advice about software
engineering targets the top 10% of organizations that hire primarily from the computer science
departments of the top-ranked university graduate pools.

ad
What about the rest?

As one of the rest, I present this collection of resources that have helped me build a decent

with my contributions has a reach of a billion users.

Ac
career in the industry. I have never worked at a “famous” company. Still, at least one product

The references are for readers interested in scaling their careers. Getting a promotion or higher
salary is a short-term goal with short-term rewards. A 10x growth is only possible with mastery
n
of fundamentals.
ro

Fundamentals change slowly. The steady rate of change allows books to be relevant for
decades. The trends and applications using fundamental technologies are being replaced
rapidly. Spotting the fundamentals powering the trends is a sure-shot way of growing in the
eu

industry.
N

One must understand the difference between using, maintaining, and building technology. Each
demands a different degree of expertise. For example, using Spark to write tasks, maintaining a
ge

Spark cluster with a thousand nodes, and adding a new operator in Spark are very different
skills. In a startup, an engineer might try to do it all at once, but doing it well is what brings in the
revenue. And the success rate of startups describes the result of hyper-multitasking without a
ou

fundamental understanding of the context.

Reading the right book makes one wise; reading it at the right time can help you increase your
R

market price!

How do I use this book?

The sequence of chapters is a suggestion based on my experience. The recommendations are
reference books; hence, having to refer to them as you learn more is imminent. Each chapter

© RougeNeuron Academy (www.rougeneuron.in)

will give a brief reason for learning the topic, immediate action items, and a list of reference
books with the key reasons I recommend them.

As a student who has yet to start working full-time, this book is a peek into the depth of
knowledge they need to acquire to build a sustainable career in technology. Buy a book only
after you have exhausted the free online resources and are sure about the investment. Don’t
spend for the sake of being cool!

As an individual contributor, you may extend the lists to your friends and colleagues to build a

y
book club. The topics are too vast to cover alone.

em
As a manager, suggesting books to your mentees is a great way to add value to their careers.
For books like “Art of Computer Programming,” one needs a group to discuss and solve the
problems. Build a culture of learning. You may think about gifting books as rewards for smaller
amounts.

ad
YouTube channels where you should search for courses first

MIT OpenCourseWare - YouTube

Stanford Online - YouTube
CMU Database Group - YouTube
Ac
n
Steven Skiena - YouTube
Martin Kleppmann - YouTube
ro
eu
N
ge
ou
R

© RougeNeuron Academy (www.rougeneuron.in)

Applied Mathematics
Applied mathematics is the backbone of engineering. One can spot it easily in the software
industry. Applied mathematics covers complexity analysis, statistical data analysis for
performance, product management, project planning, etc.
Staying in touch with mathematics after starting a job is hard but necessary. Data science is
linear algebra and calculus wrapped into libraries exposed via Python. Your career will plateau
soon unless you can appreciate the algorithm's mathematics.

y
Don’t confuse mathematics with being theoretical and using expressions with Greek letters.

em
Being analytical in decision-making relies on mathematics, primarily statistics. The probability
theory is a handy tool in your skill set—capacity planning demands estimations based on
probability. For example, you cannot over-provision a system in the cloud in March, anticipating
the black Friday traffic, nor can you wait till the last moment. The auto scalers aren’t magic.

ad
They work with trends. Trends can be misleading, and identifying such patterns needs statistics.

Action Items
Ac
1. Identify the necessary mathematics for the next five years of your career.
2. Invest in learning the mathematics necessary for programmers. Books and blog posts
n
answering this question are available, but books are better from a completeness
ro

perspective.
3. Learn to express ideas regarding mathematical relations – ideally using the appropriate
symbols.
eu

4. Think in structured quantifiable steps. Focus on prerequisites for Algorithms and data
structures first.
5. Learn essential statistical functions in Excel. Of course, other processing and
N

visualization tools will do as well. But knowing at least one is the goal.
ge

References
ou

Elements of Programming by Alexander A. Stepanov and Paul McJones

The book presents programming as philosophy using mathematics.
R

The content demands a mathematical perspective on programming. Therefore, fluency in

discrete mathematics is necessary.

From Mathematics to Generic Programming by Alexander A. Stepanov, Daniel E. Rose

Mathematics is needed to understand generic programming. It is worth working through the
book to understand the nuances.

© RougeNeuron Academy (www.rougeneuron.in)

Concrete Mathematics by Graham, Knuth, and Patashnik
The book covers the discrete mathematics fundamentals needed to work through the proofs of
computer science theory. It is a prerequisite for Algorithms and data structures.

Elementary Calculus by Keisler

Understanding the calculus used in Deep Learning and artificial intelligence theory is applicable.
It will look familiar to readers with an electrical background.

Introduction to Linear Algebra by Gilbert Strang

y
Understanding the matrix transformations used in the Deep Learning theory is helpful.
It will look familiar to readers with an electrical engineering background.

em
Linear Algebra and its Applications by Gilbert Strang
Understanding the matrix transformations used in the Deep Learning theory is helpful.
It will look familiar to readers with an electrical background.

ad
Probability - Random Variables and Stochastic Processes by Athanasios Papoulis and S
Pillai

Ac
The book presents stochastics 101 – a building block for estimation and detection theory.

Probability and Statistics for Engineers and Scientists by Sheldon Ross

n
The book is a simplified introduction to probability theory with lots of exercises.
ro

A Course in Game Theory by Martin J. Osborne, Ariel Rubinstein

It understands the fundamental concepts of game theory.
eu

Stochastic Processes by Sheldon Ross

Simplified stochastics.
N

Mathematics for Computer Science by Eric Lehman and Tom Leighton

ge

This book is an excellent guide to quickly picking the necessary mathematics to answer
interview-related computer science questions.
It is limited in scope by design.
ou

Advanced Engineering Mathematics by Erwin Kreyszig

Standard text in university courses. It covers advanced calculus.
R

© RougeNeuron Academy (www.rougeneuron.in)

Topics to explore using ChatGPT/Gemini
Here are 25 foundational mathematical concepts beneficial for beginner programmers:

1. Arithmetic Operations: Master the basic operations - addition, subtraction, multiplication,

division, and modulo (%) - for numerical computations.

2. Variables and Expressions: Understand how variables store values and how expressions
combine them using operators.

y
3. Order of Operations (PEMDAS): Learn PEMDAS (Parentheses, Exponents, Multiplication,

em
Division from left to right, Addition and Subtraction from left to right) for accurate calculations.

4. Basic Algebra: Grasp solving linear equations for unknowns, which is crucial in programming
logic.

ad
5. Inequalities: Be comfortable working with inequalities (>, <, >=, <=) to define conditions in
programs.

Ac
6. Coordinate Systems: Work with 2D (x,y) and 3D (x,y,z) coordinate systems for representing
positions in graphics or game development.
n
7. Logic and Sets: Understand basic logic concepts (AND, OR, NOT) and set theory (union,
intersection) for making decisions in programs.
ro

8. Counting and Probability: Learn counting techniques (permutations, combinations) and

eu

introductory probability for simulations and game development.

9. Functions and Graphs: Grasp the concept of functions (mapping inputs to outputs) and how
to visualize them with graphs.
N

10. Lists and Arrays: Understand how to store and manipulate ordered collections of data
ge

using lists and arrays.

11. Matrices: Explore matrices for representing and manipulating data in a structured way
ou

(useful for linear algebra tasks).

12. Loops: Learn about for loops and while loops for repetitive tasks in programs.
R

13. Iteration: Grasp the concept of iteration, which is the repeated execution of a block of code.

14. Recursion: Understand recursion, a problem-solving technique where a function calls itself.

15. Conditional Statements: Master if-else statements for making decisions based on
conditions.

16. Big O Notation: Get familiar with Big O notation, a way to analyze algorithm efficiency.

© RougeNeuron Academy (www.rougeneuron.in)

17. Time Complexity: Understand how algorithms take time to execute based on input size.

18. Space Complexity: Learn how algorithms use memory based on input size.

19. Number Systems: Be comfortable with different number systems like binary (used by
computers) and hexadecimal (used in computer memory).

20. Bits and Bytes: Understand the concept of bits (0s and 1s) and bytes (collections of bits)
as the building blocks of computer data.

y
21. Data Types: Learn about different data types (integers, floats, booleans, strings) used in

em
programming languages.

22. Basic Statistics: Grasp concepts like mean, median, and mode for summarizing data sets
(useful for data analysis).

ad
23. Linear Algebra Basics: Explore basic linear algebra concepts like vectors and matrices for
solving systems of equations and geometric transformations (useful in graphics).

angles (useful in games or physics simulations).

Ac
24. Trigonometry Basics: Understand sine, cosine, and tangent for calculations involving

25. Discrete Mathematics: Get introduced to discrete mathematics, a branch that deals with
n
objects that can be counted (useful for algorithms and data structures).
ro

Remember, ChatGPT can provide basic explanations for these concepts. For a deeper
understanding, explore online resources, textbooks, or programming tutorials that delve into the
eu

details with exercises and examples.

N
ge
ou
R

© RougeNeuron Academy (www.rougeneuron.in)

Algorithms and Data Structures
“Anyone, from the most clueless amateur to the best cryptographer, can create an algorithm that
he can’t break.” – Bruce Schneier.

It sounds cliched, but data structures and algorithms constitute computer science fundamentals.
Learning data structures through programming makes the language a primary objective. This
reversed priority is one of the biggest challenges for non-computer science students starting

y
careers in the software industry.

em
The fundamentals of data structures and algorithms are mathematical. Therefore, complexity
analysis and mathematical induction should be mandatory prerequisites. The interview-oriented
introduction to the subject leaves a knowledge gap. The complexity analysis presents a

ad
theoretical limit. The performance is data-driven, and inefficient data structures require more
hardware resources. For example, a bubble of 10 elements in an array performs much faster
than a lookup in a map data structure!

Ac
Counting iterations of “for loops” is generalized as a complexity analysis of algorithms. The
method proves to be sufficient in most interview preparations. Still, it fails in production when the
variable nature of data leads to inconsistent performance measurements. Most data processing
n
in programs uses data structures, be it message bodies, instructions, service requests, or any
ro

other form of unstructured data. Data structure design dictates the storage requirements in
memory. Two separate problems are understanding the need for a data structure and then using
a language to execute it. Serialization of data structures is one of the critical areas of
eu

optimization. Understanding language’s storage strategy or memory model and implementing

the data structure becomes essential for performance.
N

Algorithms are the execution engines of programs. In simpler words, abstracting any repeatable
tasks becomes an algorithm. Searching and sorting dominate the application-level algorithms.
ge

The computationally heavy matrix mathematical algorithms are often abstracted into frameworks
and libraries. Hence, in general, reading data and performing data cleansing remains within the
scope of most developers. The master theorem dictates the operations complexities of
ou

algorithms. Master theorem proof is only taught in algorithm courses and has a prerequisite of
discrete mathematics. Algorithms are functional and consume data structures to communicate
with the rest of the program body.
R

The development of advanced algorithms is purely mathematical. Researchers rarely convert an

algorithm to a language. As a result, research implementations are rarely production-ready.

So, someone looking for a long career in the software industry as a developer must understand
the relationship between mathematics, algorithms, and data structures. For example, the time
complexity is the mathematical analysis, and the space complexity is much closer to runtime!
The NP-completeness analysis is another advanced topic most programmers should

© RougeNeuron Academy (www.rougeneuron.in)

understand. Unfortunately, discussing NP-completeness in detail beyond the traveling salesman
problems in an interview context is rare.

Action items:
Understand the basics; don’t get caught in details. Then, revisit once a couple of months till it
becomes obvious.
1. Number theory: Prime numbers, arithmetic, geometric progressions, etc.

y
2. Permutations and combinations
3. Basic mathematical induction

em
4. Set theory
5. Master Theorem: https://en.wikipedia.org/wiki/Master_theorem_(analysis_of_algorithms)
6. NP Completeness:https://en.wikipedia.org/wiki/NP-completeness

ad
References

Ac
Algorithms + Data Structures = Programs by Niklaus Wirth
Focuses on the fundamental aspect of programming, i.e., the relationship between data
n
structures and algorithms
Examples are in Pascal. Anyone familiar with at least one programming language can
ro

understand the code quickly.

eu

Data Structures and Algorithm Analysis in C and CPP by Mark Allen Weiss
The book is programmer-friendly. It doesn’t delve deep into mathematics.
Lots of code and assignments.
N

Algorithm Design by Jon Kleinberg, Eva Tardos

ge

It is a reference text in university courses.

A background in discrete mathematics will make things easier to understand in the first place.
ou

The Art Of Computer Programming (All Volumes) by Donald Knuth

Reading books requires a solid mathematical base.
It needs a lot of attention to subtle details. Therefore, discrete mathematics is a prerequisite for
R

the series. Working through all the volumes at least once is a bucket list item for me!

The Algorithm Design Manual by Steven S. Skiena

This book is a recommended text for many university courses.
Discrete mathematics prerequisites apply.

Programming Pearls by Jon Bently

Discusses problems that might seem straightforward at first glance.

© RougeNeuron Academy (www.rougeneuron.in)

The book is not a definitive reference but something one must understand thoroughly.

Algorithms by S. Dasgupta, C. H. Papadimitriou, and U. V. Vazirani

Available online for free. Covers the standard recommended topics according to university
coursework.

Topics to explore using ChatGPT/Gemini

y
em
Data Structures
Fundamental Concepts:

ad
1. Data Structures: Understand what data structures are and how they organize and store
data efficiently.
2. Abstract Data Types (ADTs): Learn about ADTs, which define a set of operations
without specifying implementation details.

Ac
3. Time vs. Space Complexity: Grasp the trade-off between time complexity (execution
speed) and space complexity (memory usage) when choosing data structures.
n
Basic Building Blocks:
ro

4. Variables and Data Types: Understand how variables store data of specific types
(integers, strings, booleans) relevant to data structures.
eu

5. Arrays: Master arrays, which store a fixed-size collection of elements accessed by

index.
6. Linked Lists: Explore linked lists, dynamic data structures where elements are
N

connected by links (nodes).

7. Stacks: Learn about stacks, LIFO (Last-In-First-Out) structures used for implementing
ge

undo/redo functionality.
8. Queues: Understand queues, FIFO (First-In-First-Out) structures used for task
scheduling or message passing.
ou

Intermediate Concepts:
R

9. Trees: Grasp the concept of trees, hierarchical data structures with a root node and child
nodes.
10. Binary Trees: Explore binary trees, special trees where each node has at most two
children (useful for searching and sorting).
11. Hash Tables: Learn about hash tables, efficient data structures for key-value pair lookup
based on hashing algorithms.
12. Heaps: Understand heaps, specialized tree-based structures used for implementing
priority queues.

© RougeNeuron Academy (www.rougeneuron.in)

 13. Graphs: Explore graph data structures consisting of nodes (vertices) and connections
(edges) that are valuable for modeling networks.

Advanced Concepts (Introduce Briefly):

14. Tries: Briefly introduce tries and specialized tree structures for efficient string searching
and prefix matching.
15. B-Trees and B+ Trees: Briefly explain B-Trees and B+ Trees, optimized tree structures
for large datasets used in databases.
16. AVL Trees and Red-Black Trees: Briefly mention AVL Trees and Red-Black Trees and

y
self-balancing binary search trees for guaranteed performance.

em
17. Skip Lists: Briefly introduce skip lists, probabilistic data structures offering faster search
than regular linked lists.
18. Bloom Filters: Briefly explain Bloom filters space-efficient data structures for checking if
an element might exist in a set.

ad
Applications and Problem-Solving:

Ac
19. Choosing the Right Data Structure: Learn how to select the most appropriate data
structure based on the problem you're trying to solve.
20. Searching and Sorting: Understand how data structures facilitate efficient searching
(finding elements) and sorting (organizing elements).
n
21. Algorithms and Data Structures: Explore how data structures play a crucial role in
implementing algorithms.
ro

22. . Dynamic Programming: Briefly introduce dynamic programming, an optimization

technique that leverages data structures.
eu

Beyond the Basics:

N

23. Performance Analysis: Learn how to analyze the performance of data structures using
Big O Notation.
ge

24. Memory Management: Understand memory management considerations when using

data structures.
25. Real-World Applications: Explore how data structures are used in various
ou

programming domains (web development, game development, machine learning).

Using AI ChatBots, you can ask detailed questions about each concept, get code examples for
implementing basic data structures in various programming languages, and even walk through
R

solving problems using specific data structures.

ChatBots can't directly execute code but can guide you through the logic and provide
explanations. To practice code implementation, refer to online coding platforms or tutorials in
your chosen programming language.

© RougeNeuron Academy (www.rougeneuron.in)

Algorithms
Problem-Solving & Design:

1. Problem Solving Techniques: Grasp standard techniques like breaking down

problems, identifying subproblems, and using recursion.
2. Algorithm Design: Understand how to design algorithms considering correctness,
efficiency, and readability.
3. Pseudocode: Learn how to express algorithms in a human-readable format

y
(pseudocode) before coding.
4. Algorithmic Thinking: Develop algorithmic thinking, designing solutions using

em
step-by-step instructions.

Fundamental Algorithms:

ad
5. Searching Algorithms: Master linear search, binary search, and their applications for
finding elements in data.
6. Sorting Algorithms: Explore sorting algorithms like selection, bubble, and insertion sort

Ac
and understand their time and space complexities.
7. Recursion: Deepen your understanding of recursion and its applications in algorithms
like divide-and-conquer.
8. Brute-Force vs. Efficient Algorithms: Learn to distinguish between brute-force
n
approaches and efficient algorithms.
ro

Control Flow & Logic:

eu

9. Conditional Statements: This section covers master if-else statements and switch
statements and their role in controlling program flow based on conditions.
10. Loops: Become proficient in using and while loops for repeated execution of code
N

blocks.
11. Iteration: Solidify the concept of iteration, which is the repeated execution of
ge

instructions.

Algorithmic Analysis:
ou

12. Time Complexity: Learn to analyze algorithms’ time complexity (execution speed) using
Big O Notation.
R

13. Space Complexity: Learn how to analyze algorithms’ space complexity (memory
usage) using Big O Notation.
14. Trade-offs: Grasp the trade-offs between time and space complexity when choosing
algorithms.

© RougeNeuron Academy (www.rougeneuron.in)

Advanced Concepts (Introduce Briefly):

15. Dynamic Programming: Briefly introduce dynamic programming, an optimization

technique that solves problems by breaking them into subproblems and storing
solutions.
16. Greedy Algorithms: Briefly explain greedy algorithms, which make the optimal choice
at each step without considering the future, practical for specific problems.
17. Backtracking: Briefly introduce backtracking, an algorithm for finding all possible
solutions to a problem by exploring all potential paths.

y
Searching & Sorting (More Advanced):

em
18. Merge Sort: Briefly explain merge sort, a divide-and-conquer sorting algorithm with a
time complexity of O(n log n).
19. Quick Sort: Briefly introduce fast sort, another efficient divide-and-conquer sorting

ad
algorithm with an average time complexity of O(n log n).
20. Hashing Algorithms: Briefly explore hashing algorithms used for efficient key-value pair
lookup in hash tables.

Algorithmic Paradigms:
Ac
21. Divide-and-Conquer: Understand the divide-and-conquer paradigm for solving
n
problems by recursively breaking them into smaller subproblems.
22. Brute-Force Search: Learn about brute-force search, a basic but inefficient approach
ro

that explores all possibilities.

23. Greedy Algorithms: Briefly revisit greedy algorithms and their applicability to specific
eu

problems.

Beyond the Basics:

N

24. Algorithm Animation: Explore using algorithm animation tools to visualize how
ge

algorithms work step-by-step.

25. Real-World Applications: Learn how algorithms are used in web development, data
analysis, and machine learning domains.
ou

Using AI ChatBots, you can ask in-depth questions about each concept, get explanations
tailored for beginners, and see code examples (without direct execution) for some core
algorithms. Using online platforms or tutorials, you can also practice implementing them in your
R

chosen programming language.

© RougeNeuron Academy (www.rougeneuron.in)

Computer Architecture
“The cheapest, fastest, and most reliable components are those that aren’t there.” – Gordon
Bell.

All programs execute on hardware or microcontrollers. Pseudo code is a tool for discussion.
Actual software becomes useful only once it runs. Higher-level languages abstract most
application developers away from the machine.
Hardware has its evolution journey. The software has to keep up with the changes. For

y
example, recent multicore systems changes demand a paradigm shift from concurrent to

em
parallel programming. Have you ever wondered why the integer size is 4 bytes? Could it have
been two as well?

Knowledge about instruction sets and clocks is crucial to performance engineering. The

ad
execution time of any program is the duration of running machine instructions.
Computer architecture is not limited only to assembly instructions. The arrangement of caches,
data exchange speed between cores, disk interactions, power consumption, and many other

Ac
factors become relevant to programs running on different architectures.
Before diving deeper into other architectures, one must understand the hardware they are
working on. Coincidentally, programmers from electronics backgrounds can appreciate this
subject better due to a massive overlap in curriculums around these topics.
n
Toolchain setups will vary with hardware. Cross-compilation will become part of the process and
ro

dictate the testing strategies.

Knowledge of computer architecture will save you from pitfalls like assuming the performance of
eu

a microbenchmark on your laptop will hold on a cloud instance. Data Science frameworks are
known to be sensitive to hardware performance when working at scale. Crunching terabytes of
data on a CPU vs. GPU data is an interesting problem statement.
N
ge

Action items
1. Explore the three mainstream processor architectures
ou

2. Identify the documentation for the one you use

3. Read more about superscalar architecture
4. Find out more about concurrent vs. parallel programming.
R

5. Explore more about cross-compilation

https://www.cs.utexas.edu/~lin/cs380p/Free_Lunch.pdf
https://www.youtube.com/watch?v=oV9rvDllKEg
https://en.wikipedia.org/wiki/Cache_coherence
https://en.wikipedia.org/wiki/Instruction_set_architecture
https://en.wikipedia.org/wiki/Reduced_instruction_set_computer

© RougeNeuron Academy (www.rougeneuron.in)

https://en.wikipedia.org/wiki/Complex_instruction_set_computer

References
Computer Architecture: A Quantitative Approach by John L. Hennessy
It is organized and rich with examples.
Covers standard topics recommended in university courses.

y
Computer Organization and Design: The Hardware/Software Interface by David A.
Patterson, John L. Hennessy

em
Part of The Morgan Kaufmann Series in Computer Architecture and Design
It delves deep into the subject and provides an efficient perspective.

ad
Computer System Architecture by M. Morris Mano
The book is a recommended text for many university courses.
It covers all the commonly discussed topics in great detail.

101 for learning programming on embedded systems

Lots of working examples.
Ac
ARM System Developer's Guide: Designing and Optimizing System Software by Sloss
n
Digital Design: With an Introduction to Verilog HDL by Morris Mano
ro

More hardware-oriented text. The book doesn’t click unless one has some background in
electronics and circuit design.
eu

Digital Logic and Computer Design by Morris Mano

More hardware-oriented text. This is for those who have some background in electronics and
N

circuit design.
ge

Microprocessors and Interfacing by Douglas Hall

More hardware-oriented text. This is for those who have some background in electronics and
circuit design. The book covers some fundamental topics related to microprocessors and
ou

peripheral device interfacing. It is a good starting point before delving into device driver
programming.
R

Computer Systems: A Programmer's Perspective by Randal E. Bryant and David R.

O'Hallaron
It must be read by all programmers. The book provides a relevant perspective needed for
performance engineering.

© RougeNeuron Academy (www.rougeneuron.in)

Topics to explore using ChatGPT/Gemini
Hardware Fundamentals:

1. Central Processing Unit (CPU): Grasp the role of the CPU as the brain of the
computer, responsible for processing instructions.
2. Memory (RAM): Understand Random Access Memory (RAM) as the temporary storage
for programs and data being actively used.
3. Storage Devices (HDD/SSD): Learn about permanent storage devices like Hard Disk

y
Drives (HDD) and Solid State Drives (SSD) for long-term data persistence.
4. Input/Output (I/O): Explore Input/Output devices (keyboard, mouse, monitor) for user

em
interaction and data exchange with external components.
5. Instruction Set Architecture (ISA): Understand the ISA, a set of instructions the CPU
understands to perform operations.

ad
Processing and Execution:

6. Machine Code vs. Assembly Language: Learn the distinction between machine code

machine code).
Ac
(understood by the CPU) and assembly language (human-readable instructions close to

7. Fetch-Decode-Execute Cycle: Grasp the CPU’s fundamental cycle: fetching

instructions from memory, decoding them, and executing the operations.
n
8. Clock Speed and Performance: Understand how clock speed (cycles per second)
ro

influences processing speed.

9. Instruction Pipelining: Briefly introduce instruction pipelining, a technique for
eu

overlapping instruction execution stages to improve performance.

Memory Management:
N

10. Address Space and Memory Hierarchy: Learn about address space (memory
locations) and the memory hierarchy (registers, cache, RAM, storage) with varying
ge

access speeds and capacities.

11. Virtual Memory: Explore virtual memory, a technique that creates the illusion of more
RAM by using storage for less frequently accessed data.
ou

12. Memory Access and Caching: Understand how caching (storing frequently used data
closer to the CPU) improves memory access speed.
R

Data Representation:

13. Number Systems: Grasp binary (base-2) number system, the foundation for
representing data in computers.
14. Data Types: Understand how data types like integers, floating-point numbers, and
characters are represented in memory.
15. Boolean Logic: Learn about Boolean logic (TRUE/FALSE) and its use in representing
data and performing operations.

© RougeNeuron Academy (www.rougeneuron.in)

Computer Components and Communication:

16. Motherboard: Explore the motherboard as the central circuit board connecting all
computer components.
17. Buses: Understand buses as pathways for data transfer between various components.
18. Input/Output (I/O) Controllers: Learn about I/O controllers that manage communication
between the CPU and peripheral devices.

Concepts for Further Exploration:

y
19. Arithmetic Logic Unit (ALU): Briefly introduce the ALU, the CPU part responsible for

em
performing arithmetic and logical operations.
20. Control Unit (CU): Briefly explain the CU, the CPU part that controls the instructions
flow.
21. Parallel Processing: Briefly introduce parallel processing, using multiple processors to

ad
perform tasks simultaneously.

Understanding the Programmer's View:

Ac
22. Impact on Programming: Learn how computer architecture concepts like memory
access times and data representation influence programming decisions.
23. Compiler and Interpreter Role: Understand how compilers and interpreters translate
n
code into machine code the CPU can understand.
ro

Connecting to the Real World:

eu

24. Performance Bottlenecks: Explore how to identify performance bottlenecks in a

computer system.
25. Modern Processor Architectures: Briefly introduce concepts like multi-core processors
and hyperthreading for improved performance.
N
ge
ou
R

© RougeNeuron Academy (www.rougeneuron.in)

Operating Systems
“The Linux philosophy is to laugh in the face of danger. Oops. Wrong one. Do it yourself. That’s
it.”–Linus Torvalds.

Operating systems are the core of programming. There are two perspectives for learning
operating systems, fundamentals and distros.

Fundamentals

y
em
The basics of operating systems haven’t changed for decades. The core components are
memory manager, device manager, virtual memory, etc. These concepts are implemented by
various vendors to create the distro ecosystem. The core concepts and implementation can look
very different. Knowledge of fundamentals will help you ask the right questions while designing

ad
your systems. For example, the idea of processes exists in all operating systems, but
concurrency and scheduling mechanisms vary according to implementation. Virtualization is
also an operating systems concept. Awareness about operating system design can help you

Ac
debug complex distributed systems. The errors are not always going to come from the code you
ship!
n
Distros (Distribution)
ro

The core components like kernel and drivers make up the heart of operating system distribution.
The window manager, package manager, standard line tools, etc., constitute the configurable
eu

aspect of the distro. Linux containers are also part of such tools. Knowing the development and
production distros will help you find the right debugging tools.
N

Action Items
ge

1. Explore the history of UNIX and Linux

2. Find the kernel source of the Linux kernel and scan the documents.
ou

3. Read about the GNU tools.

4. Read about memory management and virtual memory in depth.
5. Read about virtualization in depth.
R

6. Explore Linux containers and their history. They have been around for a long time!
7. Read about distributed operating systems.

https://en.wikipedia.org/wiki/Operating_system
https://en.wikipedia.org/wiki/Distributed_operating_system

© RougeNeuron Academy (www.rougeneuron.in)

References
Operating System Concepts by Silberschatz, Galvin, Gagne
OS 101. It covers all the fundamental concepts of a traditional operating system.

Operating Systems by William Stalling

The book covers the fundamentals—a standard coursework textbook.

Windows Internals by Mark E. Russinovich, David A. Solomon

y
A book for Windows developers getting their hands on device driver development. The latest
versions still need to catch up to the newest version of Windows. However, a lot of the ideas

em
explained still hold.

Modern Operating Systems by Andrew Tannenbaum

The book Covers all the fundamentals.

ad
Linux Kernel Development by Robert Love
This is an excellent guide to understanding kernel programming. Although it is outdated,

Ac
considering the rapid kernel development in recent years, it is worth a glance nonetheless.

Linux System Programming by Robert Love

n
An excellent guide to understanding programming with Linux API.
ro

UNIX Internals: The New Frontiers by Uresh Vahalia

The book contains many original OS design ideas that are available in detail.
eu

The Design of the Unix Operating System by Maurice Bach

This book is one of the early guides on OS design. Outdated but ideas are still worth
N

pondering—worth a glance.
ge

Advanced Programming in the UNIX Environment by Richard Stevens

UNIX tools and their usages are explained in detail. Proved very handy dealing with a Solaris
system during a project.
ou

Linux Device Drivers by Jessica Mckellar and Alessandro Rubini

Outdated. It was an excellent guide for the kernel versions it targeted—worth a glance and
R

mapping with the relevant kernel code.

Understanding the Linux Kernel by Daniel Bovet, Marco Cesati

Outdated. It was an excellent guide for the kernel versions it targeted—worth a glance and
mapping with the relevant kernel code.

© RougeNeuron Academy (www.rougeneuron.in)

The Linux Kernel Module Programming Guide by Peter Jay Salzman, Michael Burian, and
Ori Pomerantz
Short hands-on guide. The best starting point is to get started writing a Linux device driver.

Topics to explore using ChatGPT/Gemini

Core Functionality:

y
1. Process Management: Understand how the OS manages processes (running

em
programs), including creation, scheduling, and termination.
2. Memory Management: Learn how the OS allocates memory to processes and manages
virtual memory for efficient utilization.
3. Device Management: Explore how the OS controls and handles access to hardware

ad
devices like printers or disks.
4. File Management: Grasp how the OS organizes, stores, and retrieves files from storage
devices.

Ac
5. Security: Understand basic security concepts like user accounts, permissions, and
protection mechanisms implemented by the OS.

User Interaction:
n
6. User Interface (UI): Learn about different user interfaces (command line, graphical)
ro

used to interact with the OS.

7. System Calls: Explore system calls and the interface between programs and the OS
eu

kernel for requesting services.

8. Shells and Command Line: Understand how shells (command interpreters) allow users
to interact with the OS using commands.
N

Resource Management:
ge

9. Multitasking and Multiprogramming: Grasp the concepts of multitasking (running

multiple processes concurrently) and multiprogramming (having multiple programs in
memory for execution).
ou

10. Scheduling Algorithms: Learn about different scheduling algorithms (e.g.,

First-Come-First-Served, Round-Robin) used by the OS to allocate CPU time to
processes.
R

11. Deadlocks: Understand deadlocks, situations where processes are permanently waiting
for resources held by each other, and how the OS can prevent them.

System Administration Basics:

12. Booting Process: Explore the booting process and the sequence of events that start
the computer and load the operating system.

© RougeNeuron Academy (www.rougeneuron.in)

 13. Device Drivers: Learn about device drivers software programs that allow the OS to
communicate with specific hardware devices.
14. System Utilities: Understand essential system utilities the OS provides for tasks like
managing files, users, and processes.

Concepts for Further Exploration:

15. Virtualization: Briefly introduce virtualization, the technology that allows multiple virtual
machines to run on a single physical machine.
16. Interrupts and Exceptions: Briefly explain interrupts and exceptions, as well as

y
mechanisms for handling asynchronous events and errors in the system.

em
17. Memory Protection: Briefly introduce memory protection mechanisms that prevent
processes from accessing each other's memory space.

Understanding the Programmer's View:

ad
18. System APIs: Learn about operating system APIs (Application Programming
Interfaces), which provide programmers with access to system resources and

Ac
functionalities.
19. I/O Models: Understand different I/O (Input/Output) models (e.g., blocking,
non-blocking) used for interacting with devices from a program's perspective.
n
Operating Systems in the Real World:
ro

20. Types of Operating Systems (Desktop, Mobile, Embedded): Explore different

operating systems designed for various purposes (desktops, mobile devices, embedded
eu

systems).
21. Open-Source vs. Proprietary OS: Understand the distinction between open-source
operating systems (whose code is publicly available) and proprietary ones.
N

Beyond the Basics:

ge

22. Security Threats: Briefly introduce common security threats like malware and viruses
and how the OS helps protect against them.
23. Performance Optimization: Explore basic techniques for optimizing program
ou

performance by understanding how the OS interacts with processes and memory.

Connecting to Other Concepts:

R

24. Operating Systems and Computer Architecture: Learn how operating systems rely on
underlying computer architecture for memory management, process execution, and
device interaction.
25. Operating Systems and Networking: Briefly introduce the role of the operating system
in network communication and resource sharing.

© RougeNeuron Academy (www.rougeneuron.in)

Programming Language
“There are only two kinds of languages: the ones people complain about and the ones nobody
uses.” ― Bjarne Stroustrup.

Knowing at least one programming language well is vital to a sustainable career in the software
industry. In addition, the language expertise will help you get things done efficiently, giving you
ample time to understand the business aspect.
As discussed, the programming languages abstract hardware through a type system. Statically

y
and dynamically typed systems pose different challenges from a software engineering

em
perspective. As a programmer, the choice of language will not be your responsibility in the initial
years. However, selection will be a crucial parameter in later years of technical leadership.
Many people need clarification on the relationship between framework expertise and language
expertise. For example, knowing how to boost libraries well is not the same as knowing C++

ad
in-depth, and knowing Spark doesn’t make one a proficient Scala programmer. Another case is
people mistaking Pandas expertise for data science or Python expertise.

Ac
Ideally, one should know around five different languages well enough. Master one, be hands-on
with the rest. Every language has a set of core features where it excels. Using those features
optimally makes your system perform at a high level from the start. Knowledge about various
languages also helps in designing domain-specific languages.
n
Programming languages provide basic types and some data structures. Some basic algorithms
ro

are also present in most languages. Using this essential toolkit can quickly start building
complex programs and systems. Third-party frameworks soon become part of the ecosystem,
but understanding their code is a massive asset to productivity.
eu

A language’s memory model is crucial to performance. Understanding the language design also
helps in designing robust programs. In-depth knowledge of the language benefits
object-oriented programming the most.
N

Data translations also rely heavily on your knowledge of the type system. Unnecessary
conversions and unintentional casting can lead to bugs. Finally, the toolchains and testing
ge

frameworks depend on the language; please learn all three simultaneously.

Note: Try to build a career as a software engineer, not a programming language fanatic.
ou

Programming languages are tools. Focus on getting the problems solved efficiently. Using more
than one language to build sustainable software signifies a healthy career.
R

Action items
1. Understand the terms strongly typed, weakly typed, statically typed, dynamically typed,
and duck typing.
2. Understand the nuances of type systems in your language, specifically string data types.
3. Spend time on getting good at using collections and built-in algorithms.

© RougeNeuron Academy (www.rougeneuron.in)

 4. Identify the file access and network APIs in the language or third-party libraries that
provide it.
5. Understand and master the build system of the language of your choice, including the
unit testing frameworks.

Note: Sharing C++ references since I use it most for professional work.

References

y
The C++ Programming Language by Bjarne Stroustrup

em
The book is the best source of the design aspect of the language. The examples illustrate
nuances of the language, something reading hundreds of blogs can never provide.

ad
A Tour of C++ by Bjarne Stroustrup
The book starts at an elementary level and generously explains the finer aspects of the
language with elaborate coding examples. It is structured almost like a textbook for formal

Ac
classroom teaching. Part of the C++ In-Depth Series.

Thinking in C++ (All Volumes) by Bruce Eckle

A good 101 for starting with the language. Versions with Modern C++ (> C++11) might not be
n
available.
ro

Accelerated C++: Practical Programming by Example by Andrew Koenig and Barbara E.

Moo
eu

Hands-on and focuses on the frequently used features of the language.

C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and
N

Beyond, Portable Documents by David Abrahams and Aleksey Gurtovoy

The book covers niche ideas regarding meta-programming.
ge

It requires at least an intermediate level of programming expertise with the language.

Modern C++ Design: Generic Programming and Design Patterns Applied by Andrei
ou

Alexandrescu
It predates C++-03; hence, it might seem outdated today.
The design ideas and concerns discussed in the book are relevant even today.
R

Exceptional C++: 47 Engineering Puzzles, Programming Problems, and Solutions by Herb

Sutter
Hands-on and application design-oriented discussions.
Fluency with the language before taking up this book is necessary.

© RougeNeuron Academy (www.rougeneuron.in)

More Exceptional C++: 40 New Engineering Puzzles, Programming Problems, and
Solutions by Herb Sutter
Hands-on and application design-oriented discussions.
Fluency with the language before taking up this book is necessary.

C++ Coding Standards: 101 Rules, Guidelines, and Best Practices by Andrei
Alexandrescu and Herb Sutter
Hands-on and rich with code.
Fluency with the language before taking up this book is necessary.

y
C++ Primer by Lippman, Moo

em
Standard language reference manual.

C++ Concurrency in Action by Anthony Williams

The book covers the concurrency primitives introduced in the language as part of C++11.

ad
It has practical and relevant topics for any C++ developer.

C++ by Dissection by Ira Pohl

It is a deep dive into the language.
Ac
The book also provides a perspective. It’s not for someone looking for tricks and quick code
snippets to learn the language.
n
Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14 by
ro

Scott Meyers
Useful for developers who want to catch up with the new standards.
eu

Hands-on and expects an intermediate fluency with the language.

Programming: Principles and Practice Using C++ by Bjarne Stroustrup

N

The book contains insights into the language design of the creator himself.
One should read it after getting decent fluency in the language—it is more of a reference
ge

manual.

The C Programming Language by Brian W. Kernighan, Dennis M. Ritchie

ou

It presents a great way to extend C++ using the underlying interface with C.
Efficient guide to the language. Very easy to miss subtleties in the code snippets! Even though
C is not the language of choice in many new projects, this book remains a great sample of
R

structuring technical books.

The C++ Standard Library - A Tutorial and Reference by Nicolai M. Josuttis

In-depth coverage of the standard library features.
The book provides many examples to practice—an excellent guide to catching up with Modern
C++.

© RougeNeuron Academy (www.rougeneuron.in)

Topics to explore using ChatGPT/Gemini
Problem-Solving & Algorithmic Thinking:

1. Problem Decomposition: Learn how to break down complex problems into smaller,
manageable subproblems.
2. Algorithmic Design: Understand the process of designing efficient and well-structured
solutions using algorithms.
3. Algorithmic Thinking: Develop the ability to think in terms of step-by-step instructions

y
and computational processes.
4. Debugging Strategies: Master techniques for identifying and fixing errors in your code

em
(goes beyond syntax errors).

Programming Paradigms:

ad
5. Imperative Programming: Grasp the concept of imperative programming, where you
give explicit instructions to the computer. (Most beginner languages fall under this)
6. Object-Oriented Programming (OOP): Explore the principles of OOP, where programs

OOP)
Ac
are built around objects that encapsulate data and behavior. (Not all beginners start with

7. Functional Programming: Briefly introduce functional programming, where programs

are built by composing pure functions without mutable states. (May not be covered in all
n
beginner courses)
ro

Programming Fundamentals:
eu

8. Variables and Data Types: Understand how variables store data of specific types
(integers, strings, booleans) and their impact on program behavior.
9. Operators: Master the different operators (arithmetic, comparison, logical) used to
N

perform calculations and make decisions in your code.

10. Expressions: Learn how to combine variables, operators, and values to create
ge

meaningful expressions that evaluate to a result.

11. Control Flow Statements: Understand how to control the flow of your program using
conditional statements (if-else) and loops (for, while).
ou

Beyond Syntax - Program Structure & Readability:

R

12. Code Formatting and Indentation: Learn the importance of proper code formatting and
indentation for readability and maintainability. (Often overlooked in syntax-focused
courses)
13. Meaningful Variable and Function Names: Grasp the importance of choosing clear
and descriptive variable and function names to improve code understanding.
14. Commenting Your Code: Understand the value of adding comments to explain the
purpose of different code sections. (Crucial for collaboration and future reference)

© RougeNeuron Academy (www.rougeneuron.in)

 15. Modularization and Functions: Learn how to break down complex programs into
smaller, reusable functions for better organization and testability.

Program Testing & Debugging:

16. Testing Strategies: Understand different testing strategies (unit testing, integration
testing) to ensure your code works as expected.
17. Debugging Tools: Explore how to use debugging tools (printers, debuggers) to identify
and fix errors in your code.
18. Error Handling: Learn how to handle errors gracefully using try-except blocks to prevent

y
program crashes.

em
Beyond Syntax - Program Design & Efficiency:

19. Algorithmic Complexity: Grasp basic concepts of algorithmic complexity (Big O

ad
Notation) to understand how program performance scales with input size. (Not always
covered in syntax-focused courses)
20. Space vs. Time Complexity: When choosing algorithms and data structures,

Ac
understand the trade-off between space complexity (memory usage) and time
complexity (execution speed).
21. Memory Management: Learn basic principles of memory management to avoid memory
leaks and improve program efficiency. (May not be covered extensively in beginners
n
courses)
ro

Beyond Syntax - Programming Culture & Best Practices:

eu

22. Version Control Systems (VCS): Briefly introduce version control systems (Git) for
tracking code changes and collaboration.
23. Clean Code Principles: Explore the principles of clean code (meaningful names, single
N

responsibility, etc.) for writing maintainable and well-structured code.

24. Documentation: Understand the importance of writing clear and concise documentation
ge

for your code.

Connecting Programming to the Real World:

ou

25. Real-World Applications: Explore how programming concepts are used to solve
problems in various domains (web development, game development, data science).
R

© RougeNeuron Academy (www.rougeneuron.in)

File Systems
“Not all roots are buried in the ground; some are at the top of a tree.” - Anon.

Persisting state and data are necessary for most applications. File systems are the backend of
the backend. Databases use storage engines to abstract the file systems. Operating systems
use drivers and tools to abstract away the intricate file system APIs.
As a programmer, understanding the nuances of storage at the software level are a huge asset.
File operations are one of the slowest operations. Efficient data access mechanisms need

y
significant engineering efforts. Using a file system optimally improves performance for all

em
applications using that particular operating system instance!
Writing filesystems is tricky. There is no single efficient file system for kind of file sizes. Access
times, indexing, CRUD operations, etc., are data size dependent. The file system as a subject is
available as a course in computer science departments. The knowledge of data structures and

ad
operating systems would be a prerequisite. File system design is a data structure problem at
heart. Searching and sorting are the primary operations.
The multi-user aspect of the operating system also demands a fundamental knowledge of the

Ac
filesystem. Unfortunately, detailed books about file systems are rare. However, some
suggestions will be made available in the final link of the course.
n
Action items
ro

1. Learn about the history of file systems

2. Try out a few file systems on VMs.
3. Get your hands on some file system design blogs and resources.
eu

4. Parse some file system implementation code.

5. Identify the data structure and algorithms in the code.
N

https://en.wikipedia.org/wiki/File_system
ge

https://www.kernel.org/doc/html/latest/filesystems/ext4/index.html
ou

References
R

Practical File System Design: The Be File System by Dominic Giampaolo

Analysis of the fundamental issues discovered while implementing the BeFS.
The author was one of the lead engineers who designed this system.

Operating Systems: Three Easy Pieces by Remzi H. Arpaci-Dusseau and Andrea C.

Arpaci-Dusseau
The book provides a detailed analysis of file system design.

© RougeNeuron Academy (www.rougeneuron.in)

File Structures: An Object-Oriented Approach with C++ by Michael J. Folk, Bill Zoellick,
Greg Riccardi
This book is a rare hands-on guide to file system data structures. Fluency with C++ will help you
read it efficiently. It deals with UNIX ideas, but mapping to Linux provides more learning.

Topics to explore using ChatGPT/Gemini

File System Fundamentals:

y
em
1. Hierarchical Structure: Grasp the concept of a hierarchical directory structure for
organizing files and folders within a file system.
2. File System Abstractions: Understand how file systems provide an abstraction layer,
hiding the complexities of physical storage from programs.

ad
3. File Attributes: Explore various file attributes, such as name, size, permissions, and
timestamps, and their role in managing files.

Ac
Beyond Basics - Understanding File System Operations:

4. File Creation and Deletion: Learn how file systems handle file creation, including
allocating storage space and managing directory entries.
n
5. File Opening and Closing: Understand the process of opening and closing files, which
establishes a connection for reading/writing data.
ro

6. File Permissions and Access Control: Grasp how file systems enforce access control
using permissions (read, write, execute) for users and groups.
eu

7. File Sharing and Locking: Explore mechanisms for sharing files between users or
processes and how locking prevents conflicts during concurrent access.
N

Data Storage & Organization:

8. File Allocation Strategies: Learn about different file allocation strategies (contiguous,
ge

indexed, linked allocation) and their impact on performance and fragmentation.

9. Directories and Inodes: Understand how directories manage file information and how
inodes (index nodes) store file metadata in some systems.
ou

10. Disk Formatting and Partitioning: Explore how disks are formatted and partitioned to
create logical file systems on physical storage devices.
R

Advanced Concepts - Beyond Basic Usage:

11. Journaling File Systems: Learn about journaling file systems that maintain a log of
changes to improve file system integrity in case of crashes.
12. File System Performance: Understand factors affecting file system performance, like
access times, seek times, and caching mechanisms.
13. File System Consistency: Explore how file systems maintain consistency in the face of
errors or power failures.

© RougeNeuron Academy (www.rougeneuron.in)

 14. Special File Systems (e.g., tmpfs): Briefly introduce specialized file systems like tmpfs
for temporary storage in RAM, understanding their use cases.

Security and Reliability:

15. File System Security: Explore file system security features like access control lists
(ACLs) and encryption for protecting sensitive data.
16. File System Recovery: Understand basic file system recovery techniques used to
restore data after accidental deletion or corruption.
17. Disk Defragmentation: Learn about disk defragmentation and its role in optimizing file

y
system performance by reducing fragmentation.

em
Understanding Programmer Interaction:

18. System Calls for File I/O: Explore system calls used by programs to interact with file

ad
systems for reading, writing, and managing files.
19. File Path Resolution: Understand how file paths are resolved by the operating system
to locate specific files within the directory structure.

Ac
20. Standard Streams (stdin, stdout, stderr): Grasp the concept of standard streams
(standard input, output, error) for basic file I/O operations in many programming
languages.
n
Connecting File Systems to Other Concepts:
ro

21. File Systems and Operating Systems: Learn how file systems interact with the
operating system for process management, memory management, and device access.
eu

22. File Systems and Databases: Understand the distinction between file systems and
databases. File systems offer a simpler structure for general-purpose storage.

Beyond the Basics - Modern File Systems:

N

23. Copy-on-Write (COW) File Systems: Briefly introduce copy-on-write file systems used
ge

in virtual machines and containers for efficient snapshotting.

24. Distributed File Systems (DFS): Briefly explain distributed file systems that allow
access to files across a network of computers.
ou

The Future of File Systems:

R

25. Flash Storage and File Systems: Explore how file systems are evolving to adapt to the
characteristics of flash storage (e.g., wear leveling).

© RougeNeuron Academy (www.rougeneuron.in)

Networking
Networking enables planet-scale operations. It drives the ecosystem even in private clouds or
within a data center. Advanced networking has made distributed systems possible.

Understanding networking is the key to building scalable systems. Programming with

y
networking libraries demands knowledge of the layers of networking. Rarely do people get to
work across all the layers of the network model. Products like software-defined networks overlap

em
hardware and software. Also, a lot of networking is part of IoT ecosystems.
Networking implementations are hardware and operating system-dependent. However, all
operating systems provide tools for network monitoring, and there are also off-the-shelf software

ad
tools for monitoring networks.

As a programmer, one must understand the protocols and behaviors while using them.
Debugging network issues in clouds can become challenging. Knowledge about tools and

Ac
network stacks is a survival skill for a career in distributed systems.

This topic covers the internal workings of the Internet. DNS, BGP, ISP, ARP, RARP, TCP, UDP,
n
SNMP, SMTP, etc., are frequently used. The more you understand networking, the more
accessible building scalable systems will become.
ro

Your career trajectory will define the depth of your understanding, but knowing more than
eu

necessary will always help. Understanding the complexity of networking will help you appreciate
distributed systems more.
N

Action Items
ge

1. Find a crash course for networking on YouTube.

2. Start using command line tools on your operating system for network monitoring.
3. Invest time exploring Wireshark.
ou

4. If interested, start a minor assignment on network programming using system APIs.

5. Understand the network model and DNS.
R

https://en.wikipedia.org/wiki/Network_model
https://en.wikipedia.org/wiki/Software-defined_networking
https://www.ietf.org/standards/rfcs/

© RougeNeuron Academy (www.rougeneuron.in)

References

C++ Network Programming (All Vols) by Schmidt, Huston

Hands-on. This book is only for C++ programmers but is a great way to gain hands-on
knowledge of C++ and networking fundamentals.

Computer Networks by Tannenbaum

The book presents theories about the networks operating in the real world. Not coding-oriented

y
but provides an excellent big picture.

em
UNIX Network Programming (All Volumes) by Richard Stevens
It must be read by all native programmers. It covers a lot of fundamentals with examples.

TCP IP Illustrated (All Volumes)by Richard Stevens

ad
Very practical and relevant for all systems programmers.
Fluency with Linux systems via the command line will be needed.

Telephone Network by Keshav

Ac
An Engineering Approach to Computer Networking: ATM Networks, the Internet, and the

Implementation level analysis of real-life networks.

n
ro

Topics to explore using ChatGPT/Gemini

eu

Core Networking Principles:

1. Network Topologies: Grasp the different network topologies (bus, star, mesh) and their
N

impact on communication flow and scalability.

2. Network Devices: Understand the role of various network devices like routers, switches,
ge

and firewalls in data transmission and network security.

3. The OSI Model: Learn about the Open Systems Interconnection (OSI) model, a
conceptual framework for understanding network communication across layers.
ou

Beyond Basics - Demystifying Data Transmission:

R

4. Packet Switching: Understand packet switching, where data is broken down into
packets for efficient network transmission.
5. Addressing Schemes (IP & MAC): Explore IP addresses for identifying devices on a
network, and MAC addresses for identifying network adapters.
6. Subnetting: Learn about subnetting, a technique for dividing an extensive network into
smaller logical subnets for better organization and security.

Network Protocols and Communication:

© RougeNeuron Academy (www.rougeneuron.in)

 7. TCP vs. UDP: Understand the differences between TCP (reliable, connection-oriented)
and UDP (unreliable, connectionless) protocols for different communication needs.
8. DNS (Domain Name System): Learn how DNS translates human-readable domain
names (like [invalid URL removed]) into machine-readable IP addresses.
9. HTTP and HTTPS: Explore HTTP (Hypertext Transfer Protocol) for web communication
and HTTPS, the secure version using encryption.

Advanced Concepts (Introduce Briefly):

10. Routing Protocols: Briefly introduce routing protocols the mechanisms routers use to

y
determine the best path for data packets to reach their destination.

em
11. Firewalls and Network Security: Briefly explain firewalls, which act as security barriers
to control incoming and outgoing network traffic.
12. Virtual Private Networks (VPNs): Briefly introduce VPNs, which create secure tunnels
over public networks for private communication.

ad
Understanding Programmer Interaction:

Ac
13. Sockets Programming: Explore socket programming, a fundamental technique for
creating network applications that can send and receive data.
14. Network APIs: Learn about network APIs (Application Programming Interfaces)
provided by programming languages to simplify network programming tasks.
n
15. Error Handling in Network Communication: Understand how to handle errors that can
occur during network communication, like timeouts and connection failures.
ro

Network Performance and Optimization:

eu

16. Latency vs. Bandwidth: Grasp the difference between latency (communication delay)
and bandwidth (data transfer rate) and their impact on network performance.
N

17. Network Performance Tools: Explore tools for measuring and analyzing network
performance, such as ping and traceroute.
ge

18. Network Optimization Techniques: Learn about techniques like caching and content
delivery networks (CDNs) to improve network performance and user experience.
ou

Connecting Networking to Other Concepts:

19. Networking and Operating Systems: Understand how operating systems handle
network communication and provide network services to applications.
R

20. Networking and Security: Explore the interplay between networking and security,
where secure communication protocols and network segmentation are crucial.

The Future of Networking:

21. Software-Defined Networking (SDN): Briefly introduce SDN, a new networking

paradigm that separates the control plane from the data plane for more flexible network
management.

© RougeNeuron Academy (www.rougeneuron.in)

 22. Network Virtualization: Briefly explain network virtualization techniques that allow the
creation of multiple virtual networks on a single physical network infrastructure.

Real-World Applications:

23. Client-Server Architecture: Understand the client-server architecture, a fundamental

model for network applications where clients request services from servers.
24. Network Programming for Web Development: Explore how network programming is
used to build interactive web applications.
25. Network Programming for Distributed Systems: Learn about network programming

y
for building distributed systems where tasks are spread across multiple machines.

em
ad
Ac
n
ro
eu
N
ge
ou
R

© RougeNeuron Academy (www.rougeneuron.in)

Databases
“Database schemas are notoriously volatile, extremely concrete, and highly depended on. This
is one reason why the interface between OO applications and databases is so difficult to
manage, and schema updates are generally painful.” ― Robert C. Martin.

Using, maintaining, and building databases are very different skills. For example, when
accessing a database through a connector library, you are unaware of the installation and the
destination database’s operating environment—in contrast, while maintaining one, you don’t

y
need to know actual application data processing. And while you are building one, you must care

em
about where the installation happens and the methods to access data.
The steepest learning curve is the database aspect of programming. This is because you must
address several permutations before making them available to the end user. Building a simple
in-memory database can teach you much about query parsing and concurrency. Taking it to the

ad
storage level will teach you about storage engines and file systems. You may start with SQLite.

In short, databases build a mirror operating system to manage all their resources! However,

Ac
building a storage engine is one of the niche problems in the industry. Therefore, invest time in
understanding the design decision needed to create a database.
n
Action items
ro

1. Try to get the SQL specification

2. Read the API docs for the database you use.
eu

3. Get an open-source database and parse its code for concurrency, memory
management, and query parsing.
4. Try to write an in-memory key-value store with a simple CRUD language. Make sure to
N

use the unit test suite from the start.

ge

5. Extend your key-value store to have persistence.

https://en.wikipedia.org/wiki/ACID
ou

https://github.com/sqlite/sqlite
R

© RougeNeuron Academy (www.rougeneuron.in)

References

SQL and Relational Theory: How to Write Accurate SQL Code by C.J Date
The book presents a formal introduction to the SQL paradigm.

Database Design and Relational Theory: Normal Forms and All That Jazz by C.J Date
The book is DB Design 101. It focuses on RDBMS, as the name suggests. Predates the market

y
of distributed database systems becoming mainstream.

em
Fundamentals of Database System by Ramez Elmasri, Shamkant Navathe
The book is a recommended text for many university courses.
It covers all the fundamentals for RDBMS, and the latest editions also discuss the design
challenges in the distributed case.

ad
Ac
Topics to explore using ChatGPT/Gemini
Data Modeling Fundamentals:
n
1. Entity-Relationship Model (ERM): Understand the ERM, a conceptual data modeling
tool for representing entities, relationships, and attributes.
ro

2. Data Normalization: Grasp the concept of data normalization, a process of organizing

data to minimize redundancy and improve data integrity.
eu

3. Relational Model: Explore the relational model, the foundation for most popular
databases, where data is organized in tables with relationships.
N

Beyond Basics - Understanding Database Design:

ge

4. Functional Dependencies: Learn about functional dependencies, a concept used to

identify potential anomalies in database design.
5. Data Integrity Constraints: Understand data integrity constraints (primary keys, foreign
ou

keys) that enforce data consistency and accuracy.

6. Database Schema Design: Explore schema design principles for creating efficient and
maintainable database structures.
R

Query Processing and Optimization:

7. Query Languages (Beyond SQL): Briefly introduce other query languages like XQuery
for specific purposes (won't go into details).
8. Query Optimization: Understand query optimization techniques that improve the
performance of database queries.
9. Indexing Strategies: Learn about indexing strategies for faster data retrieval in
relational databases.

© RougeNeuron Academy (www.rougeneuron.in)

Concurrency Control and Transactions:

10. Concurrency Control Mechanisms: Explore concurrency control mechanisms (locking)

that ensure data consistency when multiple users access the database.
11. ACID Properties: Understand ACID properties (Atomicity, Consistency, Isolation,
Durability) that guarantee data integrity in transactions.
12. Transactions and Rollbacks: Learn about transactions, a set of database operations
treated as a single unit of work, and how rollbacks undo uncommitted changes.

Database Management Systems (DBMS):

y
em
13. DBMS Architecture: Explore the layered architecture of a Database Management
System (DBMS) and its core components.
14. Query Processing Engine: Understand the role of the query processing engine in
interpreting and executing user queries.

ad
15. Storage Management: Learn about storage management techniques used by DBMS to
efficiently store and retrieve data.

Ac
Advanced Concepts (Introduce Briefly):

16. NoSQL Databases: Briefly introduce NoSQL databases as alternative data storage
solutions for specific use cases with relaxed consistency models.
n
17. Distributed Databases: Briefly explain distributed databases, where data is stored
across multiple servers for scalability and high availability.
ro

18. Database Security: Briefly introduce database security concepts like access control and
encryption to protect sensitive data.
eu

Connecting Theory to Practice:

19. Database Design for Different Applications: Explore how database design principles
N

differ for various applications (e.g., transactional systems vs. analytical systems).
ge

20. Normalization in Practice: Learn how to apply data normalization techniques to

real-world database design scenarios.
21. Database Performance Optimization: Understand how to optimize database
ou

performance by analyzing queries and using indexing effectively.

The Database Ecosystem:

R

22. Database Administration (DBA): Briefly introduce the role of a Database Administrator
(DBA) in managing and maintaining databases.
23. Database Backup and Recovery: Explore strategies for backing up databases and
recovering data in case of failures.

© RougeNeuron Academy (www.rougeneuron.in)

The Future of Databases:

24. Cloud Databases: Briefly introduce cloud databases, where database management is
handled by a cloud service provider.
25. Big Data and Databases: Briefly explain the role of databases in handling big data,
where traditional relational databases may not be suitable.

y
em
ad
Ac
n
ro
eu
N
ge
ou
R

© RougeNeuron Academy (www.rougeneuron.in)

Compiler Design
“Cheatham’s amendment of Conway’s Law: If a group of N persons implements a [COBOL]
compiler, there will be N-1 passes. Someone in the group has to be the manager.”-Tom
Cheatham.

Compiler design is a great learning opportunity for anyone serious about a 10+ years career as
a programmer. Automata theory is complex and does not have a mathematical background.
Unfortunately, the steep learning curve removes many self-learners from the compiler design.

y
Programming without compilers/interpreters is impossible. The basic necessity is sufficient to

em
investigate the inner workings of the tools. Let’s look at the two critical aspects of compilers from
a career journey perspective, system administration, and programming fundamentals.

ad
System Administration
Starting learning by installing your setup is the best way to start any programming language.

Ac
Installing compilers or tool chains provides you with the environmental dependencies of the
programs you will ship. Spend time understanding the nuances. Installation of any software, in
general, will provide this information. Don’t confuse the toolchain with IDE. Editors are only
using a cosmetic aspect of language. Translation of human-readable code to machine-readable
n
code is the responsibility of toolchains.
ro

Programming Fundamentals
eu

Compiler design regularly deals with parsers, graphs, trees, and dynamic programming. For
example, garbage collection is a traversal problem. Symbol resolution and syntax parsing
N

employ dynamic programming!

Fundamentals of query processing, like SQL parsers, use the same logic as a programming
ge

language parser. One doesn’t need expertise in automata theory to implement basic compilers.
The automata theory will become relevant in certain places. Still, thankfully, enough resources
are available to guide you in understanding and moving on. The goal is to work with the
ou

compiler as a piece of software instead of a black box. Most mainstream languages are open
source. Check out a compiler or runtime and compile it on your local machine!
R

Why is learning Automata helpful theory?

Domain-specific languages are potent tools for abstract business logic. For example, SQL
abstracts common data handling tasks as keywords and provides a unified query language.
Many domain-leader companies prefer to build their domain-specific languages on top of
higher-level languages like Scala to improve operational efficiency. Knowledge of compilers will
put you in the spotlight!

© RougeNeuron Academy (www.rougeneuron.in)

Action items
1. Explore the basics of automata theory. At least understand what it teaches and why it is
essential in designing compilers.
2. Find the source code of the compiler of any language you are using
3. Explore the parser code.
4. Explore the basics of garbage collection
5. Loop unrolling
6. Expression trees.

y
https://en.wikipedia.org/wiki/Automata_theory
https://www.eclipse.org/Xtext/

em
References

ad
Compilers: Principles, Techniques, and Tools by Aho, Ullman, Sethi, Lam (The Dragon
Book)
The ultimate compiler design guide. It can sometimes get very cryptic; hence, it is best used

Ac
along with some standard university courses. Best understood with the simultaneous
implementation of some sort. MOOCs have a few classes, but being a niche subject is rarely
available.
n
Engineering a Compiler by Cooper and Torczon
ro

The book covers the most commonly discussed topics in compiler design.
The book doesn’t cover all topics like the Dragon Book. It’s best to have it as a supplement to
eu

the Dragon Book.

Modern Compiler Implementation by Appel, Palsberg

N

There are versions of this book tailored to C and Java, as well as ML (not machine learning).
Implementation-oriented and suggested as a subsequent step to the compiler design theory
ge

books.

Modern Compiler Design by D. Grune, K. van Reeuwijk, H.E. Bal, C.J.H. Jacobs,K.
ou

Langendoen
The book details the commonly discussed design theory. It could supplement the Dragon Book.
R

C and C++ Compiling by Milan Stevanovic

The book is a must-read book for native developers.
It provides some key insights that will help you understand static analysis tools.

© RougeNeuron Academy (www.rougeneuron.in)

Linkers and Loaders by John R Levine
The book provides a good overview of the linking and loading steps w.r.t binaries.
Though a little dated, the concepts are still good, like the ELF format, which is an excellent
supplement to understanding compilers’ code generation stage.

Parsing Techniques. A Practical Guide by Grune, Dick, and Jacobs, Ceriel

The book is an excellent supplement to understanding compilers' parsing stage.
It covers a lot of parsing subtleties.

y
The Elements Of Computing Systems Noam Nisan, Shimon Schocken
The book is a complete overview of building computer systems.

em
Content covers a lot of components; hence, it needs to be more detailed about any particular
topic.

Structure and Interpretation of Computer Programs Abelson, Sussman, and Sussman

ad
Fundamentals of design. Available online for free.

Writing an interpreter in Go by Thorsten Ball.

Ac
It will be very hands-on. Language design prerequisites will be needed. Learning Go and
working on an exciting side project is a good starting point.
n
Writing a compiler in Go by Thorsten Ball.
It will be very hands-on. Language design prerequisites will be needed. Learning Go and
ro

working on an exciting side project is a good starting point.

eu

Topics to explore using ChatGPT/Gemini

N

Compiler Fundamentals:
ge

1. Programming Languages vs. Machine Code: Understand the role of compilers in

translating human-readable code (like Python or Java) into machine code that the
computer can understand. (Relates to choosing the right tool for the job - high-level for
ou

readability, low-level for performance)

2. Compilation Stages: Explore the different stages of compilation (lexical analysis, syntax
analysis, semantic analysis, code generation) and how they work together. (Similar to
R

breaking down a complex task into smaller steps)

3. Lexical Analysis (Scanning): Learn how lexical analysis breaks code into tokens
(keywords, identifiers, operators) - like identifying different parts of speech in a sentence.

Beyond Basics - Understanding Compilers:

© RougeNeuron Academy (www.rougeneuron.in)

 4. Syntax Analysis (Parsing): Understand how syntax analysis checks whether the code
follows the grammar rules of the programming language, such as checking sentence
structure.
5. Semantic Analysis: Explore semantic analysis, which verifies the meaning and usage
of code elements (e.g., type checking) - like ensuring logical coherence in a sentence.
6. Intermediate Representation (IR): Briefly introduce intermediate representation (IR), an
internal format compilers use for further optimization. (Similar to using sketches or
outlines before final writing)

Code Optimization (Connect to Application Performance):

y
em
7. Optimization Techniques: Learn about compiler optimization techniques (e.g., constant
folding, loop unrolling) that improve the efficiency of the generated code. (Relates to
fine-tuning a recipe for better results)
8. Code Generation: Explore how code generation translates the optimized IR into

ad
machine code specific to the target processor architecture. (Similar to translating a
recipe into steps for a specific kitchen appliance)
9. Just-In-Time (JIT) Compilation: Briefly introduce JIT compilation, where code is

save time baking)

Error Handling and Debugging:

Ac
compiled at runtime for potential performance benefits. (Like using pre-made dough to
n
10. Lexical Errors: Understand how compilers identify lexical errors (e.g., typos,
ro

unrecognized symbols) during the scanning stage. (Relates to catching spelling mistakes
in writing)
eu

11. Syntax Errors: Explore how compilers detect syntax errors (e.g., missing semicolons,
mismatched brackets) during the parsing stage. (Similar to identifying grammatical errors
in a sentence)
N

12. Semantic Errors: Learn about semantic errors (e.g., type mismatches, undeclared
variables) identified during semantic analysis. (Relates to logical inconsistencies in
ge

writing)

Compiler Design and Application Development:

ou

13. Compiler Design Tools (Lexers, Parsers): Briefly introduce tools like lexers and
parsers used for building compilers. (Similar to using libraries or frameworks to simplify
R

development)
14. Impact on Programming Languages: Understand how compiler design choices can
influence the features and syntax of programming languages. (Relates to how tools can
shape the creative process)
15. Error Reporting for Programmers: Explore how compilers provide informative error
messages to help programmers identify and fix issues in their code. (Similar to getting
feedback on your writing to improve clarity)

© RougeNeuron Academy (www.rougeneuron.in)

Connecting Compilers to Other Areas:

16. Interpreters vs. Compilers: Briefly explain interpreters, which translate and execute
code line by line, and how they differ from compilers. (Relates to different approaches for
following instructions - all at once vs. step-by-step)
17. Assembly Language: Briefly introduces assembly language, a low-level language
closer to machine code, and how it relates to compilers. (Similar to understanding
machine parts when working with a complex tool)

The Role of Compilers in Development:

y
em
18. Cross-Platform Compilation: Explore how compilers can generate code for different
platforms (desktop vs. mobile) from the same source code. (Relates to writing a recipe
that can be adapted for different kitchens)
19. Development Tools and Compilers: Understand how Integrated Development

ad
Environments (IDEs) often use compilers behind the scenes for features like syntax
highlighting and error checking. (Similar to spell checkers and grammar tools used in
writing)

Beyond the Basics - Compiler Optimizations:

Ac
20. Data Flow Analysis: Briefly introduce data flow analysis, a technique used for compiler
n
optimizations to understand how data values flow through the code. (Similar to following
the flow of ingredients in a recipe)
ro

21. Loop Optimizations: Explore loop optimizations that compilers can perform to improve
the efficiency of loops in the generated code. (Relates to streamlining repetitive tasks in
eu

a process)
22. Dead Code Elimination: Briefly explain dead code elimination, an optimization that
removes code that is unreachable or has no impact on the program's output. (Similar to
N

removing unnecessary steps in a recipe)

ge

Connecting Compilers to Software Engineering:

23. Compiler Bugs and Security: Understand how compiler bugs can introduce security
ou

vulnerabilities into the generated code. (Relates to the importance of quality control in
any development process)
24. Impact on Programmer Productivity: Explore how well-designed compilers can
improve programmer productivity by providing clear error messages and optimizations.
R

(Similar to how good tools can make development faster and easier)
25. The Evolution of Compilers: Briefly introduce how compiler technology is constantly
evolving to support new programming languages, architectures, and optimization
techniques. (Relates to the ongoing development and improvement of tools in any field)

© RougeNeuron Academy (www.rougeneuron.in)

Distributed Systems
“A distributed system is one in which the failure of a computer you didn’t even know existed can
render your computer unusable.”- Leslie Lamport.

From a programming perspective, distributed systems are the trinity of storage, computing, and
networking. Everything revolves around three pillars. A deeper dive will bring computer
architecture, data storage, operating systems, network protocols, design patterns, etc., into the
equation.

y
em
Using a distributed system is different from building one—please don’t confuse the two!
Implementing the CAP theorem is hard. The Paxos and raft protocols can look easy until you
execute distributed transactions. Building distributed databases or storage is the building block
for any planet-scale product.

ad
You can rent such services through AWS, GCP, or Azure or build intermediate solutions using
edge computing frameworks like Cloudflare, Cloud Workers, etc. But none of these solutions

Ac
work in private data centers! The private cloud demands different answers. There are products
to solve this problem, but what if you are the one building that solution? Data engineering has
become crucial for most businesses with the explosion of AI/ML frameworks. Data engineering
is about dealing with distributed systems. The horizontal and vertical scaling ideas on interview
n
portals are only helpful in interviews. Reality is complex and demands learning a lot more.
ro

Tracing, monitoring, and observability of distributed systems is a dedicated universe of products.

However, even then, the entire complexity boils down to storage, computing, and network.
eu
N

Action items
ge

1. Please read the Paxos and Raft papers. Unfortunately, Paxos is more complicated to
understand, so Raft was invented.
2. Find and follow some distributed system products engineering blogs
3. Clearly understand public cloud, private cloud, edge computing, and hybrid
ou

infrastructure.
4. Read papers from the early days of cloud research. Distributed storage is vital to
planet-scale problems. GFS paper should provide you a good start.
R

5. Identify the role of distributed systems in your career roadmap. For example, do you
want to be part of a team that builds or uses one?
6. Spend time learning about tools for monitoring and managing distributed systems in the
cloud, both vendor–provided and third–party.

https://en.wikipedia.org/wiki/Distributed_computing

© RougeNeuron Academy (www.rougeneuron.in)

https://en.wikipedia.org/wiki/CAP_theorem
https://kubernetes.io/
https://opentelemetry.io/

References

Guide to Reliable Distributed Systems by Kenneth P Birman

y
Design constraints and solutions for the fundamental components of a distributed system. It
includes some mathematical notation.

em
Distributed Systems: Principles and Paradigms by Andrew Tannenbaum
covers most of the commonly discussed topics of distributed systems design.

ad
Distributed Operating Systems by Andrew Tannenbaum
The book addresses all components of the operating systems from a distributed operation

Ac
perspective. As a result, many non-obvious subtleties and bottlenecks are part of the
discussions.

Elements of Distributed Computing by Vijay K. Garg

n
The book presents a formal representation and explanation of distributed systems.
Mathematical in nature.
ro

Programming in Scala by Martin Odersky, Lex Spoon

eu

Scala manual. The book is a stepping stone toward the Big Data framework, Spark and
functional programming.
N

Spark: The definitive guide by Matei Zaharia, Bill Chambers

This book doesn’t get into design details too much.
ge

Uses Spark 2.2 for code examples used to showcase the features.

The Go Programming Language by Alan A. A. Donovan, Brian W. Kernighan

ou

Another language built to cater to distributed systems is the primary problem.

The book provides good examples and discussions about language design philosophy.
However, the latest online documentation should be preferred for syntax.
R

Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and
Maintainable Systems by Martin Kleppmann
This book is an excellent guide to learning the working details of modern distributed systems.
As promised, the author explains enough to grasp the topics but not master them. The book is
rich with references and resources to follow up. It is a must-read for all software professionals.

© RougeNeuron Academy (www.rougeneuron.in)

Systems Performance: Enterprise and the Cloud by Brendan Gregg
This book is an in-depth study of performance engineering. It is a must-read for engineers
planning on working in startups. Performance is necessary to beat the competition at every
stage.

Topics to explore using ChatGPT/Gemini

Core Concepts and Challenges:

y
em
1. What are Distributed Systems? Understand the definition of distributed systems,
where software components run on multiple interconnected computers.
2. Transparency: Explore the concept of transparency in distributed systems, the degree
to which users are aware of the system’s distributed nature.

ad
3. Scalability: Learn about scalability, the ability of a system to handle increasing load or
data by adding more resources.
4. Concurrency: Grasp the concept of concurrency, where multiple tasks or processes can

Ac
execute seemingly simultaneously in a distributed system.
5. Consistency: Understand the challenges of maintaining consistency in a distributed
system, ensuring all nodes have the same data view.
n
Communication and Coordination:
ro

6. Inter-Process Communication (IPC): Explore different techniques for communication

between processes in a distributed system (e.g., Remote Procedure Calls (RPC),
eu

message queues).
7. Distributed Consensus: Learn about distributed consensus algorithms mechanisms for
nodes in a distributed system to agree on a single value or state.
N

8. Leader Election: Briefly introduce leader election, where one node is chosen as the
leader to coordinate tasks in a distributed system.
ge

Fault Tolerance and Reliability:

9. Failures in Distributed Systems: Understand different types of failures that can occur
ou

in a distributed system (hardware failures, network failures, software bugs).

10. Replication: Explore data replication as a technique for fault tolerance, storing data
copies on multiple nodes for redundancy.
R

11. Fault Detection and Recovery: Learn about mechanisms for detecting failures and
recovering from them in a distributed systems environment.

© RougeNeuron Academy (www.rougeneuron.in)

Distributed Data Management:

12. Distributed Databases: Explore distributed databases, where data is stored and
managed across multiple nodes in a network. (Relates to managing a large dataset
across different teams or locations)
13. Data Partitioning: Learn about data partitioning techniques for distributing data across
nodes in a distributed database. (Similar to dividing work responsibilities among team
members)
14. Distributed Transactions: Understand the challenges and approaches for managing
transactions (data updates) across multiple nodes in a distributed system. (Relates to

y
ensuring coordinated changes across different parts of a project)

em
Concepts for Further Exploration:

15. Distributed File Systems: This section briefly introduces distributed file systems, which

ad
provide access to a shared file system across a network of computers.
16. Cloud-Based Distributed Systems: Briefly explain cloud-based distributed systems,
where resources and services are delivered on-demand over the internet.

Understanding the Programmer's View:

Ac
17. Distributed System APIs: Learn about APIs (Application Programming Interfaces)
n
designed for building distributed applications, providing abstractions for communication
and coordination. (Similar to using libraries or frameworks that simplify development)
ro

18. Designing for Distribution: Explore design patterns and best practices for developing
applications that can leverage distributed systems effectively. (Relates to considering
eu

team structure and communication when planning a project)

Real-World Applications:
N

19. Microservices Architecture: Understand how distributed systems principles are applied
ge

in microservices architecture, where applications are built as small, independent

services. (Relates to modular design in software development)
20. Large-Scale Web Applications: Explore how distributed systems power large-scale
ou

web applications with high availability and scalability. (Similar to handling a large influx of
users on a website)

The Future of Distributed Systems:

R

21. Distributed Machine Learning: Briefly introduce distributed machine learning, where
training data and models are spread across multiple machines for faster processing.
22. The Internet of Things (IoT): Briefly explain the role of distributed systems in managing
and coordinating interconnected devices in the IoT.

© RougeNeuron Academy (www.rougeneuron.in)

Connecting to Other Concepts:

23. Distributed Systems & Operating Systems: Understand how operating systems
provide fundamental building blocks for distributed systems (e.g., networking, process
management).
24. Distributed Systems & Security: Explore security considerations in distributed
systems, including authentication, authorization, and data encryption.

Beyond the Basics - Advanced Topics:

y
25. Distributed Hash Tables (DHTs): Briefly introduce DHTs, a data structure and algorithm

em
for storing and retrieving data across a distributed system based on a hash function.
(Similar to a distributed filing system with intelligent organization based on content)

ad
Ac
n
ro
eu
N
ge
ou
R

© RougeNeuron Academy (www.rougeneuron.in)

General Programming and Design patterns
“Any fool can write code that a computer can understand. Good programmers write code that
humans can understand.” – Martin Fowler.

Programming originated from the need to perform mathematical tasks using machines. The idea
of programming hasn’t changed a lot; syntaxes and languages have. The early days of
programming, when C and UNIX design was ongoing, can still teach some of the core
programming ideas. Simpler hardware meant smaller programs. The Linux command line tools

y
are a great example of such modular programs. Over the years, the complexity of system

em
design has seeped into implementation, leading to complicated code bases and various schools
of thought defending them.
The ability to write an algorithm has nothing to do with language expertise. Breaking down
complex tasks into modules also doesn’t need a language in particular. Once the program

ad
structure is ready, the language is the tool to implement it.
Design patterns introduce the idea of providing a higher-level abstraction for programs using a
framework independent of higher-level programming languages. Over the years, the picture has

design patterns are tools, not the goal.

Ac
taken a form of its own and dominates many software engineering discussions. But again,

Writing clean programs sticking to the basics will lead to clean code. On the other hand,
production pressure can lead to suboptimal code. You will only get one chance to write code, do
n
it right.
ro
eu

Action Items
1. Read old articles about programming by scientists from AT&T labs.
2. Listen to a discussion about programming styles
N

3. Do not invest in defending any style.

ge

4. Find opportunities in your codebase to apply the advice.

5. Read more books about programming in general.
ou

References
R

Working Effectively with Legacy Code by Micheal Feathers

The book educates the reader about one of the most crippling issues. It deals with topics in
detail.

Design Principles and Design Patterns by Robert C Martin

Relevant and relatable for most programmers working with application code daily.

© RougeNeuron Academy (www.rougeneuron.in)

Head First Design Patterns by Eric Freeman and Elisabeth Robson
An introduction to design patterns. The utility of the content has drastically changed due to the
evolution of the software development ecosystem—worth a glance.

Thinking In Patterns With Java by Bruce Eckel

A friendly tool to learn Java as well as practice some design patterns.

Head First Object-Oriented Analysis and Design by David West and Brett McLaughlin

y
Worth a glance.

em
Design Patterns by Erich Gamma
It could be considered outdated—worth a glance.

Beautiful Code: Leading Programmers Explain How They Think by Andy Oram, Greg

ad
Wilson, Andy Oram, Greg Wilson
Nothing to do with hands-on coding as such. A collection of conversations with programmers
from different domains.

Topics to explore using ChatGPT/Gemini

Ac
n
ro
Core Design Pattern Concepts:

1. What are Design Patterns?: Grasp the concept of design patterns as templates for
eu

solving recurring problems in software design.

2. Benefits of Design Patterns: Understand how design patterns promote code
reusability, maintainability, and communication between developers.
N

3. Types of Design Patterns: Explore the different categories of design patterns, such as
creational, structural, and behavioral patterns.
ge

Creational Design Patterns:

ou

4. Singleton: Learn about the Singleton pattern, which ensures only a single instance of a
class exists. (Relates to having one central location for specific data or functionality)
5. Factory Method: Understand the Factory Method pattern, which creates objects without
R

exposing creation logic to the client.

6. Builder: Explore the Builder pattern, which helps create complex objects step-by-step.

Structural Design Patterns:

7. Adapter: Learn about the Adapter pattern, which allows incompatible interfaces to work
together.
8. Facade: Understand the Facade pattern, which provides a simplified interface to a
complex system.

© RougeNeuron Academy (www.rougeneuron.in)

 9. Decorator: Explore the Decorator pattern, which dynamically adds new functionalities to
an object.

Behavioral Design Patterns:

10. Observer: Learn about the Observer pattern, where one object (subject) notifies multiple
objects (observers) about changes.
11. Strategy: Understand the strategy pattern, which allows for the choice of an algorithm at
runtime.
12. Template Method: Explore the Template Method pattern, which defines the steps of an

y
algorithm in an operation and allows subclasses to provide specific implementations.

em
Learning Through Examples (Focus on Understanding, Not Code):

13. Avoid Diving Deep into Code: While AI ChatBots can't write code for you, they can

ad
explain design patterns in a way that beginners can understand without complex code
examples.
14. Real-World Analogies: Use real-world analogies to illustrate the concepts. (e.g.,

Ac
Observer pattern - a doorbell notifying residents of visitors)

Beyond the Basics:

n
15. Benefits and Trade-offs: Explore the benefits and trade-offs of using design patterns in
different scenarios. (Similar to considering the pros and cons of using a particular spice
ro

in a dish)
16. When to Use Design Patterns: Understand when design patterns are appropriate
eu

solutions and when more straightforward approaches might suffice.

17. Anti-Patterns: Briefly introduce anti-patterns common design mistakes to avoid.

Connecting Design Patterns to Programming:

N

18. Applying Design Patterns in Code: Explain how design patterns can be applied in
ge

pseudocode or simple code snippets to illustrate the concepts without overwhelming

beginners.
19. Benefits for Beginners: Highlight how design patterns can improve a beginner's code
ou

by making it more organized, readable, and maintainable.

Exploring Specific Design Patterns:

R

20. Iterator: Briefly introduce the Iterator pattern for accessing elements of a collection
object in a sequential manner.
21. Command: Briefly explain the Command pattern for encapsulating a request as an
object, allowing for flexible queuing and logging of actions.
22. State: Briefly explore the State pattern for allowing an object to alter its behavior when
its internal state changes.

© RougeNeuron Academy (www.rougeneuron.in)

Beyond the Basics - Advanced Topics:

23. Choosing the Right Pattern: Explore strategies for choosing the right design pattern for
a specific problem.
24. Combining Design Patterns: Understand how design patterns can be combined to
create more complex solutions.

The Future of Design Patterns:

25. Adapting to New Technologies: Briefly discuss how design patterns can be adapted to

y
new programming languages and paradigms.

em
ad
Ac
n
ro
eu
N
ge
ou
R

© RougeNeuron Academy (www.rougeneuron.in)

Software Engineering
Software engineering is a lot more than coding. Getting code to the end user is a chain of
processes. Understanding the value of these processes helps you become a better professional
in the industry. Knowing the impact of your role on the end-to-end process is critical.
Understanding software engineering is a must regardless of the technical or management
roadmap. Agile, scrum, etc., are execution methods. The methodologies for project
management are part of software engineering, not the complete picture.

y
Knowing an idea's end-to-end lifecycle enables you to estimate the appropriate effort.

em
Therefore, a clear understanding of software engineering is critical to work-life balance.
Unfortunately, software engineering is rarely a dedicated subject. Most people end up imitating
the managers they liked the most.

ad
Most social media has boiled down software engineering to setting unrealistic goals and
motivating teams through the struggle. A better solution is needed. If you are reading this, it
means you, too, realize it. Do something about it.

Actions items
Ac
n
1. Read the books about software engineering that answer “why,” not “how.”
ro

2. Spend time understanding the project estimation.

3. Check if your estimates are accurate.
4. Take 1-1s with managers seriously.
eu

5. Think from a long-term career perspective.

N

References
ge

Software Engineering: A Practitioner's Approach by Roger Pressman

Provides an overview of the big picture of software as a practice. Touches on issues and details
ou

of software development that define the efficiency of production environments.

It was one of the earliest software-related books I read. As a non-computer science engineer
working in the industry, I find this book provides an engineering perspective that no other has.
R

The Practice of Programming by Brian W. Kernighan and Rob Pike

It is a set of guidelines from two seasoned programmers.

The Architecture of Open Source Applications by Multiple authors, at least one per
chapter.
Available online. A collection of experiences from the field. Proven ideas.

© RougeNeuron Academy (www.rougeneuron.in)

Mature Optimization Handbook by Carlos Bueno
The book is a collection of reminders about avoiding over-optimizations.

The Mythical Man-Month, Essays On Software Engineering by Frederick P. Brooks Jr.

A collection of anecdotes highlights software engineering practices' limitations when it comes to
implementation in the real world.

Robert C Martin Series

y
Relevant and relatable for most programmers working with application code daily. Suitable for
mentoring new programmers as well.

em
Refactoring by Kent Beck, Martin Fowler
The book is a collection of advice that makes dealing with existing code bases easier.

ad
The Effective Engineer: How to Leverage Your Efforts In Software Engineering to Make a
Disproportionate and Meaningful by Edmond Lau
Advice from the field. It might take some time to apply to you, but it is always suitable to have it
in your arsenal when the time comes.
Ac
Software Engineering at Google: Lessons Learned from Programming Over Time by Titus
n
Winters, Hyrum Wright, and Tom Manshrek
It is an excellent insight into how software engineering is a very different set of decisions beyond
ro

programming—filled with specific problems and advice to tackle them. Many issues only exist at
a particular scale, and the book highlights the fact at the beginning—worth the time.
eu

Topics to explore using ChatGPT/Gemini

N

Foundational Concepts:
ge

1. Software Development Life Cycle (SDLC): Understand the different phases of the
SDLC, like planning, development, testing, deployment, and maintenance.
ou

2. Version Control Systems (VCS): Learn about using tools like Git for version control,
tracking code changes, and collaboration.
3. Integrated Development Environments (IDEs): Understand how IDEs like Visual
R

Studio Code or PyCharm provide features like code editing, debugging, and project
management.
4. Debugging Techniques: Explore different debugging techniques like print statements,
breakpoints, and debuggers to identify and fix errors in code.

© RougeNeuron Academy (www.rougeneuron.in)

Building Maintainable Code:

5. Clean Code Principles: Learn about clean code principles like meaningful variable
names, proper formatting, and modularity for better code readability and maintainability.
6. Unit Testing: Understand the concept of unit testing, writing small tests to verify the
functionality of individual code units.
7. Code Documentation: Explore the importance of code documentation, explaining the
purpose and functionality of code for future reference.

Understanding Programming Paradigms:

y
em
8. Imperative vs Declarative Programming: Grasp the difference between imperative
programming (focusing on how to achieve a result) and declarative programming
(focusing on what needs to be achieved).
9. Object-Oriented Programming (OOP): Learn the core concepts of OOP, such as

ad
objects, classes, inheritance, and polymorphism, to structure code.

Beyond the Basics:

Ac
10. Data Structures and Algorithms: Explore fundamental data structures (arrays, linked
lists, stacks, queues) and algorithms (sorting, searching) for efficient data organization
and manipulation.
n
11. Time and Space Complexity: Learn to analyze algorithms’ time and space complexity
and understand how they affect program performance.
ro

Software Engineering Practices:

eu

12. Agile Development: Explore agile methodologies like Scrum for iterative and
incremental software development with continuous feedback.
13. Testing Strategies: Understand different testing strategies like unit testing, integration
N

testing, and system testing for comprehensive software validation.

ge

14. Software Design Principles: Learn about software design principles like SOLID (Single
Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency
Inversion) for creating well-structured and maintainable code.
ou

Building User Interfaces:

15. User Interface (UI) Design Principles: Explore UI design principles like usability,
R

consistency, and user experience (UX) for creating user-friendly interfaces.

16. Front-End Development Technologies: Briefly introduce front-end development
technologies like HTML, CSS, and JavaScript for building interactive web interfaces.

© RougeNeuron Academy (www.rougeneuron.in)

Connecting Software Engineering to the Real World:

17. Software Engineering in Different Domains: Explore how software engineering

principles are applied in various domains like web development, mobile app
development, and embedded systems.
18. Open-Source Software (OSS): Briefly introduce the concept of open-source software
and its role in software development and collaboration.

Looking Ahead:

y
19. The Future of Software Development: Briefly discuss emerging trends in software

em
development like artificial intelligence (AI) and machine learning (ML).
20. Continuous Learning: Emphasize the importance of constant learning in software
engineering to stay updated with new technologies and best practices.

ad
Ac
n
ro
eu
N
ge
ou
R

© RougeNeuron Academy (www.rougeneuron.in)

Security
“Data is the pollution problem of the information age, and protecting privacy is the environmental
challenge.” ― Bruce Schneier.

Security is ingrained in all layers of software systems, including hardware. Your career trajectory
might only demand knowing a little about safety since frameworks take care of it. But when
issues like a HeartBleed, Meltdown, Spectre, or log4j vulnerability show up, you should know
the impact on your system.

y
Knowledge about cryptography is mathematical. Spend some time understanding the basics.

em
The production setups will rely on frameworks. You may get interested in pursuing it full-time.
As an application programmer, I have fundamental knowledge about SELinux, encryption,
DDoS attacks, phishing, etc., which is always helpful. Data is always vulnerable to malicious
actors. Bot automation makes accidental access easy. Malicious actors might stumble on your

ad
system. So, spend time understanding the security aspects to be considered by your system’s
design.

Action items
1. Read more about SELinux
Ac
n
2. Read more about encryption
ro

3. Find tools to secure your workstation

4. Explore authentication protocols
5. Read more about programming language exploits that affect your stack.
eu

6. Subscribe to security researcher posts and engineering blogs.

https://www.schneier.com/
N

https://googleprojectzero.blogspot.com/
ge

References
ou

Applied Cryptography by Bruce Schneier

R

Cryptography 101.
Mathematically demanding.

Cryptography and Network Security: Principles and Practice by William Stalling

It covers commonly discussed concepts regarding the subject.

Network Security Essentials: Applications and Standards by William Stalling

It covers commonly discussed concepts regarding the subject.

© RougeNeuron Academy (www.rougeneuron.in)

Hacker's Delight by Henry S. Warren
Very Hands-on book regarding hacking.

Hacking: The Art of Exploitation by Jon Erickson

Very Hands-on book regarding hacking.

Network Security with OpenSSL by Pravir Chandra, Matt Messier, John Viega
A hands-on guide to SSL programming.

y
Secure Programming Cookbook by Matt Messier, John Viega
This is a hands-on guide to programming practices with security as a primary objective and

em
functional specifications. It outlines subtle steps that can make a huge difference in product
security.

ad
Topics to explore using ChatGPT/Gemini
Core Security Principles:

Ac
1. CIA Triad: Understand the CIA triad (Confidentiality, Integrity, Availability) - the core
security objectives of protecting data confidentiality, ensuring data integrity, and
n
guaranteeing system availability.
ro
2. Threat Modeling: Learn about threat modeling, the process of identifying potential
threats and vulnerabilities in a system.
3. Secure Coding Practices: Explore secure coding practices, such as input validation,
eu

proper data handling, and avoiding common coding vulnerabilities.

Understanding Security Threats:

N

4. Injection Attacks: Learn about injection attacks, where malicious code is injected into
ge

user input to manipulate applications.

5. Buffer Overflows: Understand buffer overflows, a memory corruption vulnerability that
attackers can exploit to execute malicious code.
ou

6. Cross-Site Scripting (XSS): Explore Cross-Site Scripting (XSS) attacks, where

malicious scripts are injected into web pages.
R

Securing Web Applications:

7. Session Management: Learn about secure session management practices to protect

user sessions from unauthorized access. (Relates to keeping track of user identity
securely)
8. Authentication and Authorization: Understand the concepts of authentication
(verifying user identity) and authorization (controlling user access) in web applications.
(Similar to checking ID and access cards before entering a restricted area)

© RougeNeuron Academy (www.rougeneuron.in)

 9. HTTPS: Explore the importance of HTTPS (Hypertext Transfer Protocol Secure) for
secure communication over the Internet.

Cryptography and Encryption:

10. Basic Cryptography Concepts: Learn about basic cryptographic concepts like
encryption (transforming data into an unreadable format) and decryption (reversing the
encryption process).
11. Hashing: Understand hashing functions, which generate unique fingerprints for data and
are used for data integrity verification.

y
em
Security Practices for Beginners:

12. Strong Passwords: Explore the importance of using strong passwords and proper
password management practices.

ad
13. Software Updates: Understand the importance of keeping software up-to-date to patch
security vulnerabilities.

Ac
Beyond the Basics:

14. Secure Coding Standards: Briefly introduce secure coding standards and guidelines
for writing secure code.
n
15. Security Testing: Briefly explain security testing methodologies to identify vulnerabilities
in applications.
ro

Connecting Security to Software Development:

eu

16. Security in the SDLC: Understand how security considerations are integrated
throughout the Software Development Life Cycle (SDLC).
17. Secure Coding Tools: Briefly introduce secure coding tools that can help identify and
N

prevent vulnerabilities in code.

ge

Real-World Security Issues:

18. Social Engineering: Learn about social engineering attacks, where attackers
ou

manipulate users into divulging sensitive information or performing actions.

19. Phishing Attacks: Understand phishing attacks, where attackers send fraudulent emails
or messages to trick users into revealing personal information.
R

Looking Ahead:

20. The Evolving Security Landscape: Briefly discuss the ever-evolving security
landscape and the importance of staying informed about new threats and vulnerabilities.

© RougeNeuron Academy (www.rougeneuron.in)