C++ for Middleware Engineers

Object Oriented Programming - Under the Hood

Note: This is a Partner Course and NOT included in the Library Access!

This course unpacks the complete compilation pipeline, memory layout, symbol resolution, object lifetime, abstraction mechanisms, and performance behavior. You will analyze real binaries, inspect assembly output, and use professional tools like nm, objdump, and profilers to understand how design choices affect execution.

By connecting theory with system-level realities, this course builds strong mental models that help you write efficient, maintainable, and production-grade C++ code—especially for embedded systems, middleware, and performance-critical software.

Bestseller Beginner Intermediate

(4.9)

Last updated: 8 February 2026 | English | 365 days Access.


includes

~ 13.6 hrs  of recorded video lectures.
50+  lessons.
 based experiments.
Certificate  on completion of course.
Cheat sheets and/or quick reference guides.
Case studies based on open-source code.
Coding exercises and challenges.
50+ demonstrations.
New content regularly added!

what you will master through the journey

Understand how C++ source code is transformed into an executable at every stage.
Analyze preprocessing, compilation, assembly, and linking in real-world toolchains.
Inspect binaries using professional tools like nm, size, objdump, and readelf.
Interpret symbol tables, relocation entries, and memory maps.
Understand stack, heap, data, BSS, and text segment behavior in depth.
Monitor memory usage and detect leaks using system-level debugging tools.
Master compiler optimization flags and their impact on performance and size.
Understand loop unrolling, vectorization, and volatile behavior at assembly level.
Analyze how values, references, and pointers are implemented internally.
Build efficient ownership models using RAII, move semantics, and RVO.
Understand object construction, destruction, and lifetime management.
Master virtual functions, vtables, and runtime polymorphism internals.
Analyze name mangling, templates, and function overloading resolution.
Implement callback systems using function pointers and functors.
Design C-style and C++ abstractions for middleware and embedded systems.
Understand weak symbols, LMA/VMA, and advanced linker behavior.
Debug linker errors, ODR violations, and symbol conflicts confidently.
Evaluate shallow vs deep copy and design safe copy/move strategies.
Write cache-friendly, low-latency C++ code for real-time systems.
Translate high-level C++ constructs into assembly-level mental models.

contents and preview lectures ...

Birth of an Executable : Under-the-Hood

Introduction to the Course
Example Codes - Used in this Course
Evolution of C++
Toolchain Installation
C++ Compilation Pipeline
Preprocessing Stage
Compilation Stage
Assembler and Linker Role
GCC Utilities - 'nm' and 'size'
Stack and Heap Monitoring Tools
'objdump' utility
Significance of LMA and VMA
'weak' attributes in Linking
Compile Time Vs Link Time Decisions
Caveats in Linker
Useful Tools- To Learn C++ Under the hood
Tools for Performance Analysis
Compiler optimization Flags and its Effects
Loop unrolling, Vectorization and 'volatile' usage

C++ - Values, References, and Efficiency :Under-the-Hood

'const' Type Qualifier
'constexpr' usage
'C' Style Array and Pointer Arithmetic Basics
Dynamic Arrays and Memory Management Challenges
C-String Vs std::string in C++
Range Based For Loop in C++
L-Values and R-Values at Assembly Level
Reference in C++
References Under-the-Hood - As a 'Hidden' pointer
LValue,RValue References Usecases and Performance Benchmarking
Internals of 'inline' function

Abstraction, Object Lifetime and Ownership : Under-the-Hood

Function Pointers -Callback functions and Dispatch Table in Middleware
Abstraction in C using Struct with function pointers Vs C++ Class
Access Specifiers in C++ Class
'static' Data Member and Member Function in the class
'static' objects and Middleware Use-case
Constructor and Destructor in C++ Class
Copy Constructor for Object Owning Resources
Return Value Optimization with Copy Elision
Move Constructor
Move Semantics
Shallow Copy Vs Deep Copy - Uses

From Overloading to Templates: Under-the-Hood

Function Overloading and 'Name Mangling' under-the-hood
Inheritance and its Types
Execution order of constructor and Destructor
Function Overriding and the middleware use-case
Function Overriding -Mental Model and Object Slicing
Virtual functions and Runtime Binding - Under the hood
Significance of 'final' keyword
why virtual constructor don't exist? but virtual destructor does?
Operator Overloading - Basics and Middleware use cases
Operator Overloading - Under the hood
Ownership Transfer with Move assignment operator
Function Object or Functor - Overloading Function call () operator
Lambda Function in C++ and its Internals
Namespaces and its uses in Middleware
Templates in C++

Road Map From Here...

C++ Learning path for Embedded Middleware Engineers

What Makes “OOPS Under the Hood” Special

“OOPS Under the Hood” is not a traditional C++ course that focuses only on syntax, libraries, or design patterns. Instead, it teaches how C++ actually works beneath the surface—inside the compiler, linker, memory system, and runtime environment. This deep technical focus is what makes the course truly unique.

Most developers learn how to write C++ code, but few understand what happens after pressing “compile.” This course bridges that gap by explaining how source code becomes an executable, how objects are laid out in memory, how virtual functions are dispatched, and how optimizations affect performance. Learners gain insight into what the machine really does with their code.

Another key strength of this course is its strong connection to real-world systems such as embedded platforms, middleware, and performance-critical applications. Students learn why design decisions matter when resources are limited, startup time is critical, or latency must be minimized. This makes the learning highly relevant to industry needs.

The course also emphasizes tool-based learning. Participants work with professional utilities such as nm, objdump, size, and profiling tools to analyze binaries and debug system-level issues. This practical exposure prepares learners for real production environments.

Rather than encouraging memorization, the course builds strong mental models. Students learn to reason about memory, registers, object lifetimes, and ownership. This enables them to solve new problems independently and write efficient, reliable code.

By combining theory, tools, and real-world examples, “OOPS Under the Hood” transforms learners from surface-level programmers into confident system-level engineers. Graduates of this course can analyze crashes, optimize performance, understand compiler behavior, and design robust software with clarity and precision.

In short, this course does not just teach C++ — it teaches how C++ works on real machines.

How This Course Is Different from Others

  1. Focus on Internals, Not Just Syntax: Goes beyond language rules to explain how C++ works at compiler, linker, and runtime level.
  2. Complete Build Pipeline Coverage: Teaches preprocessing, compilation, assembly, and linking in one connected workflow.
  3. Binary-Level Learning: Trains learners to analyze real executables using nm, objdump, size, and map files.
  4. Assembly-Oriented Understanding: Connects high-level C++ code with generated assembly for deeper performance insight.
  5. Embedded and Middleware Relevance: Designed specifically for system, firmware, and middleware development use cases.
  6. Tool-Driven Engineering Approach: Emphasizes professional debugging, profiling, and inspection tools used in industry.
  7. Memory-Centric Teaching: Covers stack, heap, segments, object layout, and lifetime management in depth.
  8. Performance-First Mindset: Explains how compiler optimizations, cache behavior, and data layout affect speed.
  9. Mental Model Development: Builds strong internal models so learners can reason about behavior without guesswork.
  10. Production-Oriented Problem Solving: Teaches how to debug linker errors, crashes, and runtime failures in real systems.

Certificate

The journey through the course is a challenging one! Our courses are packed with insights and will take time to sink in. You will be awarded with a Certificate of Mastery when you complete 95% of the course work.

What you see above is a sample certificate. The design of this certificate will be modified from time to time to make it more shiny and reflect the rightly earned pride!

There will always be a dedicated certificate identification number to verify it with us. This should enable anyone to check the authenticity of the certificate.

How this is different from Others

FeatureUs!Others
Focus on Internals, Not Just Syntax
Complete Build Pipeline Coverage
Binary-Level Learning
Assembly-Oriented Understanding
Embedded and Middleware Relevance
Tool-Driven Engineering Approach
Memory-Centric Teaching
Performance-First Mindset
Mental Model Development
Production-Oriented Problem Solving

Instructors

Jegan Amirthalingam
Corporate Trainer, Manager
Jegan is an Automotive Embedded Systems/Software trainer holding a Master's degree in Automotive Electronics, with 14+ years of experience spanning academia and industry. In academia, served as Assistant Professor teaching Automotive Control Systems, Electric Hybrid Vehicles, and Vehicle Dynamics while establishing a research laboratory for Rapid Control Prototyping and Hardware-in-the-Loop simulation. Guided a Formula Student electric race car project competing at international events in Italy and India. In industry, progressed through senior roles designing competency frameworks for automotive business units, leading Model-Based Development tools creation, and managing technical delivery across diverse client segments. Currently leading the Embedded and Automotive track within a global talent development function, shaping the next generation of automotive software professionals. Research interests focus on control strategy development for autonomous vehicles, vehicle dynamics and control, modern automotive software architectures, and vehicle software development. Continues serving on academic boards for automotive electronics programs, bridging industry innovation with academic excellence.

Requirements

Basic understanding of C-Programming (with Understanding of pointers, structures)

Who this course is for

Embedded and Systems Engineers: Developers working on firmware, RTOS, drivers, and low-level software who want to deeply understand how C++ interacts with hardware and memory.
Middleware and Platform Developers: Engineers building communication stacks, frameworks, and infrastructure software who need strong knowledge of object lifetime, performance, and binary behavior.
C++ Developers Aiming for Mastery: Programmers who already use C++ and want to move beyond syntax and libraries to become confident, high-performance system-level engineers.
Students from Electrical, Electronics and Computer science Engineering Discipline

FAQs

Why is this course not included in the Library Access?

This course is created and delivered by a partner who is not a core member of the Pyjama Cafe team. We need to compensate the partner based on the sales of their content.


Is this recommended for beginners?

Yes! The courses are taught as if the learner has no idea about the subject.


Do I need a special machine configuration to take this course?

No!


Can I change my email-id post purchase?

As much as we'd like to support that, your account will be linked to your email-id post purchase.


What name will be printed on the Certificate?

The name you use on the platform will be printed as is on the Certificate when it is generated.