Firmware and Systems Software Engineering

A structured path to mastering the essentials!

IF YOU INVESTED IN US IN THE PAST, PLEASE EMAIL US AT SUPPORT@PYJAMABRAH.COM AND WE WILL WORK ON AN OFFER FOR YOU. SEND THE DETAILS OF THE INVESTMENTS.

Embedded Systems Software Engineering includes writing firmware for microcontrollers and system software for application grade CPUs involving bootloaders, device trees and higher level operating systems.

While there are several resources available online. Each offers a narrow view of one entity of the several. We have created and organised courses, that will take you from Zero to Hero in Firmware and Systems Software Engineering.

Bestseller Beginner Intermediate | Delivered by Piyush Itankar Mahmad Bharmal

(4.9) (24 ratings) 109 students

Last updated: 2 May 2025 | English | Quarterly and Yearly Access.

Course Includes

~ >50 hr  on-demand Video.
100+  Recorded lessons.
10+  downloadable resources.
Certificate  on completion of course.
Cheat sheets and/or quick reference guides.
Case studies based on open-source code.
Coding exercises and challenges.
5+ End-to-end project implementations.
New content regularly added!

A Message from the instructor

What you Learn

Master C programming, converting to Assembly and machine code.
Grasp ARM-M, ARM-A, and RISC-V memory maps and programmer's models.
Write and debug C programs for practical use.
Command C constructs - functions, pointers, structs, unions, enums.
Analyze data types - integers, floats, doubles, signed/unsigned, const, volatile.
Understand data type memory representation - 2's complement, floating-point encoding.
Implement control structures (if, else, switch, loops, goto) and track assembly effects.
Manipulate arrays, strings, pointers, and perform pointer arithmetic.
Leverage debug tools - GDB, make, addr2line etc.
Build mental models for pointers in firmware, Linux, FreeRTOS, Zephyr.
Master pointer operations - pointer-to-pointer, arrays, function pointers.
Handle pointer arithmetic, void pointers, NULL pointers in kernels.
Manage dynamic memory with malloc(), free(); avoid leaks, dangling pointers.
Learn low-level programming with RISC-V and Assembly.
Write and debug RISC-V (rv32i) assembly programs; convert C to assembly.
Use QEMU, GDB, Makefiles for low-level debugging.
Develop baremetal firmware, drivers; print “Hello, World!” on UART.
Understand ARM Cortex-M, Cortex-A architecture, registers, boot processes.
Write Cortex-M assembly, including schedulers with context switching, SysTick.
Master exception handling, vector tables, system registers via QEMU.
Create, debug Makefiles for build automation; write GNU linker scripts.
Use Git, Gerrit for version control, code reviews.
Dissect FreeRTOS kernel; port to new targets with task scheduling.
Develop Linux kernel modules; manage with insmod, rmmod, lsmod.
Implement /proc entries, system calls, device drivers in sandbox.
Explore embedded systems roles, job skills, and career paths.
Generate digital audio in C using sampling, file operations.
Simulate real-world coding with QEMU, Codespace, Multipass.
Build mental models of CPU, memory, state machines, scheduling.
Tackle interview questions on C, memory, interrupts, bit manipulation.
Complete projects - schedulers, digital audio, Linux drivers.

Content List

The list below is a complete list of courses, lectures, quizzes, code reviews, projects, notes etc available on the learning portal at the moment. This list is constantly update with new content every few days...

Low Level with Pyjama Brah! (Public Draft)

I am writing a book to teach C by understanding the CPU/Memory programmers model, exploring the ISA for RISC-V, the assembly, writing baremetal firmware/driver, and ends with printing “Hello, World!” on the UART. The book covers lot more than just C. Things like Assembly, Makefile, GDB based Debugging, Linker Scripts, C, Driver Writing etc… The public draft is available for FREE for online reading.

Low Level with Pyjama Brah!

Roadmap and Career Options

This short course focuses on orienting the college graduates and those new to the industry on what the usual roles, responsibilities are and what opportunities they can expect.

Understanding Embedded Systems
what is embedded systems and how it relates to EE, ECE and CS
What is firmware and Systems Engineering
Understanding What Firmware engineering is
Memory Map and the Programmer's model
State Machines and OS Primitives
Roles and Exploring job listing
HLOS, Application Grade CPU and Virtual Memory
Roles and Skills
Exploring Opportunities and Skillset

The C Language

This course dives into the practical applications of the C language, emphasizing hands-on learning to solidify key concepts. Delivered in an engaging and unconventional style, the lessons go beyond theory, equipping you with the skills to apply C programming in real-world scenarios. By the end of the course, you’ll feel confident in your mastery of the C language, adept at using it alongside the tools and utilities professional C programmers rely on daily.

Roadmap and Mindset
Sandbox Environment and Basic C Program
Keep an Eye on Functions, Pointers and Structs
Example of the RAW power - Functions, Struct and Pointers
Mental Model of the System
The mental model of the CPU
The mental model of the Memory
Instruction Encoding and the rv32i ISA
A tour of Toolchain, QEMU, GDB
Demo - assembly to binary, QEMU and GDB
Instruction Encoder Decoder, Makefile and GDB Dashboard
Anatomy of Assembly Program, writing code, debugging in GDB
Decomposing C to Assembly and the relation
Getting CPU from assembly to jump to C program
Introducing the C Keywords
Data types, Variables and Integers
Datatypes - float and double
Exploring sizes of data types and location in memory
How integers are stored - 2s complement
floating point number encoding and few examples
more floating point - float and double
signed and unsigned
const and volatile
demo - const and volatile
void, c standard and gnu C manual
typedef and sizeof
structs and unions
enums as named numbers
if, else, switch, case, default, do, while, for, continue and break
goto and return
Demo - if, else if and else effects at assembly level
Demo - switch case and effects at assembly level
Demo - loops - for, do, while, continue and effects at assembly level
Demo - goto and jumps across functions
auto, register, extern and static
Demo - auto keyword7
Demo - register keyword
Demo - extern keyword
Demo - static keyword
Introduction to Variables and Functions
definition vs declaration
Demo - variable and function names
Arithmetic operations and pitfalls
Problem statement
Problem statement walkthrough
Setup, variables and I/O
Using conditions, switch and loops
debugging scanf issue and cleaning up the code
guarding against bad inputs and concluding the project
Strings and concept of array and pointers
Defining and Assigning Arrays
Arrays and out of bound access
Strings and Character arrays
Introduction to the concept of pointers
Syntax related to Pointers
Demo - introduction to working with data pointers
Detour - Endianness
Demo - Difference between array and pointers
Generating Digital Audio - walkthrough
Math concepts and sampling
Generating samples and file operations
Demo - Playing the Digital Audio
Revisiting types of data types
Structures - Sneak peak
Anatomy of Struct and examples
Demo - structs
more being uploaded...

C Pointers

C pointers are crucial in Firmware and System Software (based on the C language) design. Linux, Unix, FreeRTOs, Zephyr, ThreadX etc kernels use C pointers heavily. This Course dives into the mental models and inner workings of pointers!

What to Imagine?
What is a pointer?
Why pointers?
Environment Setup
Declaring|Defining a Pointer
Pointer Variable and Address
* and & in relation to pointer variable
Use of * and &
Array and Pointers - Similarity and differences
Many *s and Many &s
Pointer to pointer
Array of pointers
Different types of Pointers
Pointing to data with a Datatype
Pointer to a struct, *, . and ->
Pointer Arithmetic
Memory model and pointer to data
What is a function pointer?
Function pointers syntax
typedef and function pointers
Example - function pointer array
What is a void pointer?
What is NULL and NULL pointer?
void pointers in - Linux source code
heap/ malloc() and free()
Allocation failure
Memory Leak
Dangling Pointer
Double free()
pointer manipulation and unowned memory
Baremetal Code
FreeRTOS
Linux

C - Mastering Bit Manipulation

A short course on how to think about and do bit manipulation in the C Language

The idea behind bit manipulation
Operators and practical aspects of Bit Manipulation
Bit Masking, Setting and Clearing Bits

ARM Cortex-M 101 - Introduction

An introductory course on the ARM Cortex-M CPUs. How to go about learning them.

ARM CPU Architectures
Micro Architecture Vs Architecture
Mental model of CPU Memory interactions
How to master CPU - Different models to learn
Programmers model - Register Set
Modes and Privileges
CPU boot up and Vector Table
Exploring Cortex-M3 registers using QEMU
where to next.... Invitation

ARM Cortex-M 102 - Scheduler Design using Assembly

Learn the assembly programming for ARM Cortex-M CPUs by writing a scheduler from scratch, without using any IDE, SDK or boiler plate code. Course is under development. Content will be added when it's ready.

End Goal
Environment Setup
Mental Model of the CPU, Systems and the Cortex M Controller
From bit to the Programmers model and NVIC
Various ARM Architecture and CPUs - M0, M3, M23 etc.
Programmers model for the M Class CPUs
Privilege and Modes of operation
Boot up process
Exception Handling and Register Save/Restore
Booting the Processor and First Assembly Program
Instructions, Encoding and binary dump
Anatomy of assembly file
Cortex m3 instructions and experiments
Stack manipulation instructions
How can Single CPU run multiple processes?
Anatomy of a Task
Trick to Context Switching and Scheduling
Exception Entry, Exit and SysTick timer
Programming SysTick and confirming the exception
saving and restoring CPU context
Setting up the tasks and the stack and trying to round robin
Round robin and switching between processes
Things to be mindful of
FreeRTOS - the struggle to get to context switching

GNU Make and Automation

Make is a build automation tool that automatically updates files in your project based on their dependencies. It's primarily used for compiling source code, but can also be used to run other commands or perform tasks.

Setup and Quick Introduction
First makefile and basic rules
Dependencies and when make misbehaves
Resolving dependencies - target as a dependency
A better example and variables
Pattern Rules and some internal variables
Variable for target, pattern substitution, functions and debugging makefile
Executing shell commands and assigning value to variable
Organising the source code and use of shell function
Discovering the header paths
Generating the path to headers and targets without recipe
Different names for Makefile and including other makefiles
Passing values form commandline, ?= and +=
macros

GNU Linker Script

This hands-on course dives into the details of writing linker scripts (based on GNU LD). Linker scripts are a must-have skill for firmware and systems engineers who have to deal with scenarios where the placement of various sections (code, data, etc) in the memory needs granular control. Engineers who work on Bootrom, Firmwares, Bootloaders, or otherwise are involved in lower-level systems code.

Environment Setup
Opening and Closing the Codespace Environment
Compilation Process, Linker and the linkerscript
Demo - Resolving addresses and Merging sections
C Code and Allocation in Memory
Diagnostic Tools
Our own linker script: Goal
Anatomy, Memory details, Sections
Sneaky linker and linking multiple objects
Including and discarding sections from same file
Discarding and wildcard
.rodata, problems with Single memory bank
Defining two memories and the problem with .data section
Introducing VMA and LMA
Current location counter, variables and destination info
Address of .data section in the ROM
Code to copy .data section from ROM to RAM
Zero Initialising the .bss section
Creating custom sections and placing it
What is the linker command language
Linker Script and Statement
Expressions
Values
Symbol Names and naming rules
Location Counter
Expression Evaluation
Assignment operation
Assignment statement placement - relative and absolute addresses
Symbol types - Absolute and Relocatable

FreeRTOS - Teardown and Porting

Learn FreeRTOS kernel by tearing it down to it's bare minimum and doing a port for a new target from scratch. This includes booting the CPU from scratch and placing the code in memory manually.

What and Why FreeRTOS
Demo walkthrough - End goal and Tools
Codespace Setup
Programmers model and Essentials of ARM M CPU
Demo - Booting the CPU
Jumping from Assembly code to function in C files
Fixing the problem of function calls in C
Getting the FreeRTOS source code and documentation
Starting to Integrate the FreeRTOS-Kernel
more lectures being recorded...

Git and Gerrit - the collaboration kit

Git and Gerrit are pivotal tools in the software development industry, each serving distinct yet complementary roles that enhance collaboration, code quality, and workflow efficiency.

Introduction and Team Setup
Simulating the real world on local machine
Quick Tour of GIT - why and how
Where to install git from
the init command
status and adding files to staging area
commits and git data management
discarding experimental changes with checkout
resetting and discarding commits
more lectures are being recorded...

The ART of Interviewing

Organised collection of topics, projects and questions from the web that a Embedded Engineer should know and be able to reasons about.

Introduction and Format of the Course
Key concepts in C
C Program and Memory Layout
.text section and behaviour in freestanding and hosted environment
Stack, the location and what all goes there
Understanding Heap and the need
demo - code analysis
structs and union
volatile and const
bit-manipulation and pointers
General Embedded Concepts
Some History of computing system
CPU, Memory, ISA and IO
The concept of Interrupts
More lectures being recorded...

ARM Cortex-A 101 - Introduction to the 64bit ARM CPUs

Introduction to ARM-A Class CPUs implementing the AARCH64 architecture.

Who is ARM as the Company?
A Class CPUs, Architecture and Micro Architecture
How to learn CPU - different models
CPU as seen by Software Programmer - Programmers model
Programmers guide and revisiting uArch
Long discussion on Els and Secure/non-secure
Exception Levels
Secure and Non-Secure world
Use cases and Software Execution in different ELs
Use case for Secure World Software Execution
Revisiting the Document
GPRs, QEMU and Demo
Exploring the idea of System Registers, SCTLR as example
Processor State Register - CPSR or PSTATE
Idea of Exceptions and saving CPU state
Special Registers
Boot process - Single core and Multi Core
Setup and Demo - Glitch at the end
Revisiting the Demo
Next

Linux Device Drivers 101 - Writing and understanding a dummy driver

A hands on Introduction to Linux Device Driver development. Recommended for those getting started with driver development.

A sandbox to run our experiments
mac-setup
Linux Setup
Windows-setup
Multipass relaunch and installing utilities
Linux Kernel, System and Bootup
User Space, Kernel Space, system calls and device drivers
Files and File operations, System Calls and Drivers
Our first Loadable module - Minimum Code based
Deep Dive - make and Makefile
Using lsmod utility to list loaded Kernel Modules
insmod, module and the kernel
rmmod, kernel and module unloading
modinfo and the mod.c file
proc file system, system calls and user interaction
Exploring entries in /proc
creating the /proc file entry and screwing up the kernel
Implementing the read operation
Passing data to user from kernel
User space app example and challenge for you
Quick Revision, What we did not cover and where to next..

Tech Syncs - Workshops on ad-hoc topics

Live Tech Syncs with learners every once in a while where we discuss ad-hoc topics relating to Firmare and System Software Engneering.

Deep Dive - ARM Cortex-M CPUs (part - 1) | 30 April 2025

(planned) ARM aarch64 - Bare-metal Programming

This course is being recorded at the moment and will be added soon.

(planned) Linux Device Drivers 102 - Writing Driver for the GPIO block from scratch

This course is being recorded at the moment and will be added soon.

(planned) SoC and Components - An Introduction

This course is being recorded at the moment and will be added soon.

(planned) Data-structures and Algorithms for Embedded Engineers

This course is being recorded at the moment and will be added soon.

(planned) Python and Automation

This course is being recorded at the moment and will be added soon.

Important: Planned courses are not yet ready for learners and will be added as the current recording concludes.

The Philosophy behind the courses?

We have been creating content for the Embedded Software Engineering community for over a year now. If you have been following us, you would know that we have launched courses in the past, with Firmware Engineering Arsenal (later renamed to Firmware Engineering) being the most popular one. The Courses on C lnaguage and C Pointer have been an all time hit and got us to where we are.

We noticed that we (a small) team were having a hard time supporting different courses individually. And learners were feeling left out when we included one course in one bundle but not another. To make life easy for all, we have decided to offer all the courses to everyone under quarterly and yearly subscription plans. This we believe will free us from the complications that come with attended to everyone on different chat windows.

To help reinforce all the learnings and ensure the learner has a deep sense of practical usage of the lessons, we have introduced Tech Sync (Workshops) where we present live on topics and take questions.

View of the Learning Portal

Learning Paths - For anxiety free life!

Embedded Engineering has not had a linear path. We are attempting to being order to the chaos. The courses are deliberately designed and ordered in the way they are. You can take each course individually or just follow the learning paths shown in the image below. The ones of the left are for firmware engineers (or aspiring candidates) and the ones on right are for those interested in systems software engineering.

Learning Paths

Firmware Engineering

Firmware Engineering involves working with microntrollers. These are typically 32-Bit CPUs (like ARM Cortex-M, RISC-V RV32 etc) with focus on power saving. Engineers tend to either write bare metal code or use an RTOS (like FreeRTOS, Zephys, ThreadX etc) if there is a need to handle complicated state machines.

Having a good understanding of what the CPU does as the result of the C code is a skill that will put you in the top 1% of the entry level Firmware engineers. Being able to understand a senior and co-operate to write the code is more than enough. Notice that the C language and C Pointers course will exactly help you become this. The C Language course is all about insights and based on the RISC-V CPU. So not only do you learn C the way it should be (by being able to reason down to the CPU) but also you learn programmers model and assembly for the RISC-V CPU. Double win!

The ARM Cortex-M 101/102 Introduces the ARM-M Architecture and focuses on booting and programming the CPU in Assembly. You will write a secheduler in assembly as part of these courses, this is deliberate and makes way for understanding FreeRTOS which follows. Going through these courses, you will notice how similar the RISC-V and ARM-M architectures are. By the end of the ARM courses, you will be having the skills of a senior firmware engineer.

The FreeRTOS course is laser focused on tearing down and reasoning about the scheduler and the OS primitives (mutex, semaphores etc). There are many engineers who work with FreeRTOS on a daily basis but don’t understand the internals and thus, hit a glass-roof in their career. Being able to reason about OS constructs like mutex, semaphore, spinlocks etc is important. You will also learn the rare skill of porting FreeRTOS from scratch on a new ARM-M target!!

To grow up the ladder you will need to master the CPU’s programmer model, architecture and be able to use the toolchain (gcc, ld, as, ar, gdb etc) to place the code/data in the memory, debug the solution and write build automation help.

Senior or Staff level engineers worry about details like power, performance, stability and fault tolerance of the firmware. Being an absolute master of C, CPU Architecture, Operating Systems and Debug tools is a must! If you notice, the courses are lined up to get you to becoming a master…

Systems Engineering

Stellar Systems Software Engineers are firmware engineers who are working with Application Grade CPU (ARM Cortex-A, RISC-V RV64, AMD, Intel etc), Complex and interconnected system capable of running Higher Level Operating System (Linux, Mac-OS, Windows etc), Hypervisors and Virtualizer and Systems capable of running general applications like the chrome browsers.

The Application processors are complicated in their architecture and have layers privileges and modes. Systems Engineer need to have a good understanding of the CPUs to be able to reason about the systems level on-goings. They are involved in working with Bootloaders, hypervisors, OS Kernel (Linux, Windows etc) and need to be very thorough with the understanding of the Operating Systems.

The courses included focus on the ARM Cortex-A (aarch64) and RISC-V RV64 architectures. The introductory courses give a over all view of the given architecture. Once the architecture is understood, the next in line is the Linux Device Drivers. The 101 course, provides a deep insight into how the Linux Kernel Drivers work and the anatomy of a general character driver.

We focus on the ARM-A class CPUs just because they are very popular and used in Mobiles, Watches, Tablets, Desktops/Laptops and Servers! Investment into learning this architecture is to prepare for the future and bullet proof your career!

General Skills

Honing technical skills is not enough. For these reasons we have included courses on general skills that a Firmware/Systems Software Engineer should have. When working in teams, collaboration is a big one and most semiconductor companies use tools like Git and Gerrit for source code management. Master these will enable you to be a reliable teammate!

The ART of Interviewing is a collection of special topics and interview experiences that will arm you with the knowledge and mindset to have a productive technical discussion with an interviewer (not to mention, become a better interviewer too)!

More!

We will be adding more courses in the paths so eventually this becomes a robust and reliable path to take as to become a firmware or systems software engineer. The subscribers of course will get the updates for free :)

Our Recommendation

Unless you are a student or an early professional who cannot afford the Yearly plan, our recommendation is to go for the Yearly Subscription to get the most bang for the buck.

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 (`Piyush Itankar` is a sample student name). 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
C language and pointers with focus on machine behavior
Detailed analysis of data types and significance.
Assembly and C Coding without IDE
Detailed explanation and view of Programmer's model of CPU.
Mental models of various components in the System to reason based off.
A Bottom-Up Approach with the tinge of answering the `Whys`.
Thorough explanation of toolchain utilities (gcc, as, ld, ar, gdb etc)
Connecting the concepts with practical use cases and use in industry.
Hands-on experiments to prove every concept.
Focused on practical professional insights
Teach multiple CPU architectures (ARM-M, ARM-A, RISC-V).
Cover the toolchain utilities like compiler, assembler, linker and debug tools like GDB?
Learn at your own pace.
Superficial and confusing explanation
Burn a hole in the pocket with Fee
On campus presence required.

Instructors

Piyush Itankar
Embedded Engineer (L5), Google
Electrical Engineer holding a Master’s degree in Embedded Systems, with a proven track record at industry giants. At Intel, contributed expertise to Navigation Firmware, Bluetooth Driver development, and RF validation software. Currently thriving as an Embedded Software Engineer at Google, drove innovation in Firmware development for the Power Management Sub-system on Tensor SoCs (Pixel Phones) and presently advancing system software for the Pixel Watch.
Mahmad Bharmal
Embedded Engineer (L4), Google
Computer Science Engineer with a Masters in Embedded Systems Design. Worked on Firmware for Intel's Bluetooth solutions, followed by Silicon Validation Software for the Tensor SoCs, and presently working on the Pixel Watch Software. He is system software expert with a decade of experience.

Praise from our learners

(4.9) course rating. 24 ratings

Here’s what those who are learning from the courses have to say about the content and delivery.

Shweta S
(5)
A well structured course for beginners to expirenced professionals, one who is keen in learning what the C program does to the underlying system, this course is for them. I personally enjoyed the debugging using the gdb dashboard. I am looking forward to dive deeper as the course unfolds, I highly recommend this course for all the embedded engineers.
Rohit Alate
(5)
Hello Team, if possible , please create the playlist in some sequence in which we should go through , so it will be really helpful.thanks in advance, and content wise you guys are amazing..... and i would say thanks to team to creating such platform for us...
PADMALAYA RAWAL
(5)
This bundle is crazily interactive. Be aware that it will make you addicted to learning more about embedded systems beyond just looking for jobs. Thanks to the team, who are adding more courses to the bundle, it's never going to be outdated! Loving it❤️‍🔥
Inturi Sri Sasi Kiran
(5)
I am taking a moment to give shout out the the authors of this course, sorry actually it's not just a course it is standard text book for an Embedded Engineer or who wants learn Embedded Engineering. I will strongly recommend this course to the college students especially those who are looking for a career in the Embedded sector.
Gnanesh Sureshchandra
(5)
This course gives you exactly what you need to know about pointers! And more importantly how to think about pointers this is really important, and every embedded engineer must know. Once again thanks a lot for this content creators. Expecting more courses from you in future. (for: C Pointers)
Arjun
(5)
Awesome, within an hour, if an engineer learns the boot up process of arm - cortex-m, that is unbelievable, instructor is really apt at the matter. Thanks (for: ARM Cortex-M 101)
Selva Gandhi P
(5)
I want to say that this course has truly been eye-opening for building my career. Thank you so much, brother, for all the support and guidance. 🙏🏻
Imene Benamor
(5)
I'm currently taking this course, and it's been great so far! The content is clear, practical, and easy to follow. I'm already learning a lot and looking forward to diving deeper. Would definitely recommend it to anyone looking to build or strengthen their skills in embedded systems.
Earnest Kihara
(5)
I wish I had came across this course when I was getting started into embedded C, thankyou Piyush for coming up with this course ,its worth it . I recommend it to all beginner and intermiadiate students and anyone else who feels there is some dots they can't connect in C
Pavankalyan G
(5)
Really enjoyed reading this book! It provides great insights and is well-written.
@n.5s4584
(5)
I just wanted to take a moment to appreciate the amazing content you create! Your videos are not only engaging but also incredibly valuable. I’ve learned so much from your channel, and I always look forward to your uploads. Thank you for sharing your knowledge and insights—keep up the great work! Wishing you all the success you deserve.
@its_me_to-i4e
(5)
Your content is amazing! Last time, I bought the advanced C pointer course, and it was so helpful for embedded systems. Please consider making the course fees more affordable so that students like me can easily access them. Keep up the great work
@sharifyy
(5)
your content is amazing, I give it 5 stars
@techpartel9858
(5)
The flow of this course is Amazing. It covers a whole system overview of how your C code runs and how it's dumped in your hardware. Everything is excellent. Thank you, @piyush.
@Simi-bc8sb
(4.9)
Great content. I really appreciate. Thank you
@ElizabethGreene
(5)
31/Jan/2025
Was there any reason why you preferred the RISCV32i chip over an x86 chip in QEMU? I appreciate the lesson in cross compiling too, but was curious why. Thanks for making these. 10/10
@soumyadipkar9451
(5)
31/Jan/2025
Enjoyed the session a lot sir! GDB Dashboard is truly amazing! 🔥
@vimalathithand917
31/Jan/2025
Just what I was looking for ! I'm sure that this series is going to be a blast ! Please don't stop the series in the middle and thanks a lot !
@aadishm4793
30/Jan/2025
Great content!!
@Ujjaval___
30/Jan/2025
AMAZING VIDEOS
@aadishm4793
30/Jan/2025
Awesome as all the videos 👍👍🔥
@Padmalayarawal
(5)
30/Jan/2025
Really loved your new content, can't ask for more crazy stuff.
@shabeehabbas4737
29/Jan/2025
Hello bro just saw the this video and I cant wait to start the course, the roadmap is unconventional which is why I think its the most awesome one, please dont stop uploading such great content ❤❤❤
@ankitrajbhar6045
(5)
31/Jan/2025
This is what I actually needed in life today.. thanks a tons..
Bhanu Sri Dasari
(5)
Great content
Ashith Polepalli
(5)
Excellent content to learn firmware
Rahul Kumar
(5)
no second thought.. go for it
Vikas Naga
(5)
The best course in Embedded System so far.
Mariyam Shahid
(5)
the best content on c!
@EEShyama
Loving these lectures!! Please keep them coming.
@RavindraBhandari-nf8vs
(4)
31/Jan/2025
I like your teaching method 🫡

Requirements

GitHub account to do the hands-on coding in Codespaces.
Interest in the lower level working of the system.
Some exposure to Digital systems is good (but not strictly required).
Basic understanding of number systems, logic gates, bits and bytes is good to have (but not strictly required).

Who this course is for

Students in Academia with C as a subject in the course.
Early Career Professionals using C as development language.
Embedded Systems Engineers.
System Software Engineers.
Electrical/Electronics Engineers working on hardware programming.
Systems Engineer seeking gain system level insights.
Those curious to learn the underlying details of Systems and how to program it using C.
Those seeking a job change and preparing for interviews.

FAQs

What is the difference between these courses (paid) and the content on YouTube?

Some lectures from different courses have been put on YouTube as Preview. The are not structured and jump to a topic. The Courses in the Subscription are well structured and focused on developing a skill.

Is this recommended for beginners?

Yes! The courses are taught as if the learner has no idea about the subject. Each course starts of by ensuring that the basics needed to understand the followup lectures is understood.

Why a subscription model?

We are billed for the hosting and bandwidth by the platform provider. While we would very much like to offer lifetime validity, given the recurring bills, we have to ensure we continue to earn enough to be able to fund the effort and bring more value to our learners. The quarterly plan is for those who cannot afford the yearly subscription but can benefit from burst learning. To get the most out of our content, we recommend subscribing to the yearly plan.

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

No! All you will need is an internet connection and the Chrome browser. The hands-on examples and lab work is based on GitHub codespaces platform. We use GitHub Codespace to ensure that you don't struggle with the setup and focus on the learnings. You are always free to setup the environment locally. Although, we won't support that, but you are free to do so. The courses, as much possible use a Emulator target of a real board, so if you wanted to run the code on real board. You can do so.

Why is a GitHub account needed?

The Experiments and Labs are based on the GitHub provided Codespaces virtual machine. Codespaces will enable a common work environment for all the learners and avoid the hassle of special setup.

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.

Can I follow the steps on my own PC?

Yes for the most part. Better yet would be if you have a linux machine.

I previously purchased a course from inpyjama/pyjamabrah, any discount for me?

Yes. We can offer a discount on the yearly subscription. Please reach us at support@pyjamabrah.com and be sure to include the details of your past investment. We will work on a custom discount for you.