Want to write a single program that uses C++ for high-level logic, C for portability, and assembly for speed? This video shows exactly how to do it.

We build a complete hybrid program from scratch:

• driver.cpp – contains main(), prints intro, calls assembly
• c.c – simple printf() function
• cpp.cpp – C++ function (with extern “C” to disable name mangling)
• hello.asm – assembly module that prints messages, calls C and C++ functions

You’ll see:

• Why hybrid programs matter
• How source files → object files → final executable
• The role of the driver and why main() lives once
• Name mangling in C++ and how extern “C” fixes interop
• Global / extern in assembly to expose and call functions
• A clean Makefile that compiles each module separately
• Live build and execution with output explained line-by-line

By the end you’ll know how to call across languages safely, pass basic args via registers, and structure projects for fast incremental builds.

No prior assembly required – just basic C/C++ familiarity. Code is copy-paste ready.

Timestamps in comments. Source files linked below.

Like & subscribe for more systems programming!

What is a Hybrid Program 00:00:00
Why Use Hybrid Programs 00:00:21
Program Modules Overview 00:01:10
Compilation to Object Files 00:02:23
Makefile Introduction 00:04:26
Driver Module Setup 00:06:43
Name Mangling Explained 00:07:18
C++ Module with extern C 00:07:43
Driver Main Function 00:10:12
C Module Implementation 00:11:52
Assembly Module Setup 00:12:41
Assembly Data Section 00:13:03
Assembly Text Section 00:14:18
Global and External Functions 00:14:35
Assembly System Calls 00:16:20
Calling C from Assembly 00:18:58
Calling C++ from Assembly 00:20:32
Program Execution Flow 00:21:05
Running the Program 00:23:59
Passing Arguments Between Modules 00:26:23
Hybrid Program Summary 00:29:11

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hello there. Let’s talk about hybrid programs.

What’s a hybrid program?

A hybrid program is basically a program where you have multiple modules,

many written in different languages, all compiled into one executable program.

Why would you want to make a hybrid program? Well, you know,

maybe you have C++ as one of the modules that you’re creating and C++ is a high

And C++ is a high level language, so it makes it easier to write big, robust programs with GUIs and like big design, big fancy design patterns and things.

But maybe at some point you want to interface with the C program.

So it might make sense to, you know, kind of jump into some C code.

Maybe also you want to write a little module in assembly because maybe one part of your code needs to be really, really fast and efficient in some way.

the code compiles down to machine code.

Assembly is just, you know, a level up from machine code.

So let’s see, I’m just gonna write a quick program

to demonstrate that you can do this

and you can have these modules call each other.

First off, I should probably draw a little bit

about what I’m even talking about with multiple modules.

So I’m gonna do my little annotator here

and yeah, there we go.

Basically imagine that you have a C++ module

and we’ll call it the driver.

and we’ll call it the driver and I’ll say like driver.cpp. Okay I think I’m

drawing this backwards. I’m gonna draw this down here. Driver.cpp.

Excuse my penmanship I don’t have a smoother setup on this thing. So we have

driver.cpp that’s one source code. Maybe you have like another module, another

just some C code. The driver, usually the way I like to refer to it, and one of my favorite,

you know, assembly books refers to it is the driver is where the main function is so that

it’s sort of like the entry point of your program. But then maybe we’ll have another module that has

some other kind of CPP code in there. I’m just going to call this file cpp.cpp. And maybe we

have another module that’s written in assembly. I’m going to call this hello.asm. Okay, so just

Okay, so just several source code files.

We will compile them each to an object file.

Sometimes, I think, with new programmers,

they think that you just compile a source code directly to the executable.

We’re not going to do that in this case.

We’re going to get a little bit fancier.

Doing it this way, by the way, will increase your compiling efficiency

when you start getting used to make files.

I don’t know if you’re already using those, but it’s a good idea.

So we’ll write a script to compile or make file to compile

or some kind of a build system to compile.

We’ll compile the CPP driver to just a file called

driver.o, O for object file.

So O for object file depends on driver.cpp.

We’ll have another file called c.o,

so the object file c.o depends on c.c and so forth.

So I’m just gonna go cpp.o, circle it,

and then down here we’ll do hello.o.

Notice how all of these modules, regardless of the language they are written in, compile

down to an object file.

That’s really what it is.

The higher level languages are just an illusion for us humans.

So then at the very top, we want our actual executable file.

We’ll call it main because that’s kind of a standard thing sometimes.

So it’s like our main, we’ll have a file named main that we can execute.

is going to be the main function.

Spoiler, it’s going to be inside the driver.

Remember, the main function, if you’re using GCC libraries,

has to appear in exactly one place, one module in your program.

It should appear one time and one time alone, not zero or more than one.

So the main executable depends on the driver object file,

the C object file, and the C++ object file,

and the assembly hello object file.

Looks complicated at first until you stare at it a while,

complicated at first until you stare at it a while and then you just realize,

oh, every source code is going to compile to its own object file.

And then after we have all the object files,

we’re going to have our executable just sort of linked together at the final

linking stage. So with that in mind,

I’m just going to copy paste a make file that I already wrote.

It’s like my pre solution because this is not a make file video.

And I just want you to know just real fast what it looks like.

All I’m doing is I’m going to make some variables, uh,

for my C++ compiler flags and my C compiler flags and my Yasm assembler flags.

I’m really not doing anything fancy.

I’m just sort of setting up some variables so I don’t have to type.

The newer Ubuntu stuffs need a no executable stack flag and a no pi flag.

So here we’re just like making variables for linking.

My executable’s name is going to be main over here.

I personally like to make make files that default to a cute help menu.

help menu. I know most people just default to building, but, uh, you know, for educational

purposes, I think this is a little more fun, a little easier. So this way later I can just type

make menu or make build or make run or make clean or whatever I want to do. And, um,

I’m going to make a target called run, which is what we’re going to be using. And then a target

called build, which just only builds everything. The run target obviously depends on build so that

to run it and and if you don’t know make files at this point it’s okay this is not a make file video

i’m going to make some make file videos in the future

then my binary the main program is just going to depend on all these object files notice how it

depends on the driver the hello the c plus plus and the c object files so really uh at the linking

stage we’re just going to use g plus plus to just sort of link all the object files together

Then we have a little section to compile each source code file.

So in order to make driver.o, I’m going to compile,

I’m going to depend on the driver.cpp.

And then when it comes to actually compiling, compiling it,

I’m just going to type the commands to compile it here.

Don’t worry about these crazy variables.

I’m going to make more videos in the future.

And then each module gets compiled in its own way.

Then I just have a little target at the bottom called clean because I like to be

able to just clean my build area of object files.

I don’t know about you, but I like a clean build area.

I’m a clean build area guy.

I don’t like a dirty build area.

So that was the make file.

Again, this is not a make file video,

so don’t worry too much about it right now.

The next thing we should do is make a driver.

Again, I’m gonna copy paste from my solution here

because the driver should be easy.

This is really, this video is mostly gonna be

for people who have never done assembly before.

So I’m just gonna assume you know a little bit

about C++ and C already.

So I’m going to say touch, let’s see, driver.cpp so that I can get the driver file in there.

And I’m going to go nano driver, probably put it down in the first place.

Then I’m just going to paste my solution.

Oops, you can tell I copy pasted this from my IDE because I have the extra tabs in there, which I love.

One thing to keep in mind is that, I guess like one of the first rules that I want to tell you for hybrid programs

is that assembly doesn’t understand something called name mangling.

mangling. So what is name mangling? Name mangling is basically when you have a,

oh, this is not going to get called. So this is maybe not a great idea to show you name

mangling. Let me, let me start on one of the other ones real fast too. Let’s do

the C++ module. Okay. So I’m going to go nano CPP dot CPP. I know it’s a silly name. I know it.

So CPP dot CPP, this is just a simple C++ program, which is meant to be called by

by the assembly module just to show you that we can.

And so we just have a little function here,

void, you know, the CPP function.

So it’s just a function that doesn’t really return anything.

Inside of it, I’m just going to print,

hello, this is the C++ function, no problem.

Notice at the top,

this is the first important thing that you should understand.

In C++, we have overloads, right?

You can have the same function name,

but with different argument lists.

And so that gets resolved under the hood

by the name actually kind of changing

based on what the argument signature is,

what the prototype signature is.

So that’s great and all,

but in assembly, at least at this level,

there’s no way to really differentiate between overloads.

In assembly, we’ll just call a name of some function.

But if we try to call a name,

let’s say of just the CPP function,

if we say call the CPP function in assembly,

it’s not going to work

because the actual function has not been compiled to have that name.

It’s been compiled to have the CPP function

and a bunch of extra symbols indicating what the argument list is.

This is great for C++ programs, but it’s poor.

It’s bad for other modules to be able to call the C++ function

because they won’t really know what the actual name is

after the mangling has been done.

So what you want to do is make a little block called Xtern C,

just like this.

You say extern and then C in quotes and then do a scope with braces.

And inside of that, just put the prototypes of any function that you want to be available to other modules.

So, for example, we want the CPP function to be available to assembly modules and C modules, not just other C++ modules.

So, I’m just going to put the prototype of it right there.

You can put as many prototypes as you want.

I think they should come from the same source file.

different source file where you want something to be available elsewhere,

you would put an extern C block for its prototype.

This disables name mangling,

which means the compiled name of the CPP function will actually be the CPP

function. So it’s pretty good. This will make it available to assembly.

So now that I’ve kind of explained that I can maybe close this and go back to

what I was doing before. So this is the main driver program.

We don’t need to engage in a dis,

we don’t need to disable name mangling for the main function because no one is going to call main

except the GCC libraries or like the OS. But when the C++ module calls other modules, it needs to

be able to call the right name. And remember in C++, there’s name mangling enabled by default.

So if I tell it, let’s say on this line right here, or you can do alt N to get line numbers on nano.

we want to call on the hello module will C++ by default will assume that hello has name

mangling applied to it, which means it will actually try to call some name that is totally

different based on the prototype signature, the incoming arguments and things like that.

But so we want to disable that because we wanted to just call the actual name because

hello is going to be a function that we make inside of assembly.

So it’s not going to be name mangled.

So that’s why up here on line seven, we enter its signature.

Enter its signature. Oh, actually this is from a different version of something that I was doing. I’m not going to return anything from hello

We’ll do name a demangling with our extern C block just void hello

And now when we call hello, it’s actually going to call a function called hello without any other

mangling same thing for the C S E A

Oh

That was from a different version. I wrote we’re not going to be calling C in this module. Don’t worry

We’re going to keep it simple

So pretty much we’re going to print hello and then we’re going to print,

then we’re going to call the hello and then we’re going to say goodbye.

And then that’s going to be the end of the program.

So let me close out of that and just double check what I have written right now.

So we’ve got CPP and okay, we need to do C, nano C dot C.

Okay, so let me get my solution real fast here.

It’s a simple program.

Literally, it’s just a C program that prints something.

Remember in C++, we’ve got the IO stream, but we don’t have that in C.

that in C. So I’m just going to use printf. Oh, by the way, this is a C function. Hi.

So done with that. Pretty easy. Shoot. You know what? I need to start learning how to do

clear and LSA. So I can just go up, up, up. So C++, C and the driver

and the make file, which is huge. I just realized that. And now I guess we can start

or hello function.

Okay.

So maybe I want to write this in the Genie program.

So I’m going to, well, maybe I’ll first, I’ll say touch,

and I’ll say hello.assembly.

And then now that it’s there, I can try to open it up.

Let’s see.

Hello.assembly.

Okay, so now let’s write an assembly program.

I’m not going to spend too much time talking about this,

but I’ll say like data section here,

and we’ll say section.data.

We’ll say section.data and then we’ll say system calls.

This is not a system calls video.

I’m just gonna do this very quickly without explaining.

System write is gonna be code one, I guess.

And then we’re gonna do file descriptors, one for stdout.

Whoops, stdout, it’s gonna be equal to one.

This is not a file descriptors video.

I’ll put FDs, I guess.

And then we’ll make some C strings.

C strings, you know, just character arrays, basically.

I’ll say, well, you know what?

I don’t want to type this all out

because this is not a lesson on variables.

I’m just going to copy paste my existing solution here.

And, you know, long story short,

I’m going to try to make this a pretty program

that prints hello and goodbye and things.

And so we just have like some variables

that sort of just you know old strings and hold the strings length and we’re

gonna do one that calls a new line and so forth actually that’ll be a different

video but I’ll leave it in there for now so now let’s make the text section

remember the text section in Yasm is just for the actual code of your program

and then we need to set up some external symbols. So right now, at least for the purposes of this

source code, this source code is inside of the hello module. So you can imagine we’re inside of

hello.o. All the o’s get linked together in the executable, but between themselves, there’s kind

of a little bit of like a border situation happening. There’s like some separation. So

are going to be available to the other modules,

even if they’re part of the same executable.

It’s kind of convenient because you would like sometimes

to be able to write tons and tons of functions

that are only available inside of your assembly module,

and they might not be available to other modules,

and therefore you don’t want to pollute the namespace,

I guess, of the global namespace of the executable.

So by default, if I make a function called hello,

how you make a function, just a quick recap here.

This is not a functions video.

make a symbol with the name of the function you want and then you just put a ret after it and then

you hope that whoever got you there is going to use the call instruction but anyway for now

we’re just going to say this is our hello function okay i cannot call the hello function now from

another module i have to make it visible to the other modules with a special keyword called global

our program the hello function will be available to the other modules but not anything else that

I type without marking it as global so let’s go ahead and do let’s do a welcome message and this

is not a system call a video maybe I should just copy paste this so just looking at it this is a

going to quickly you know breeze through what we’re doing in case you’re interested but you

don’t have to care too much about this right now we’re going to tell rax what system call we want

to make the code for that is what i put up in system right which is just code one means let’s

write to a file we’ll give it the file handle uh that’s going to be the variable we made called fd

std out which means we’re going to be giving it the file handle of one which means we’re telling

to print to standard output because file handle one is always standard output.

And then we just give it the a pointer to the first character of the message

string that we made and then tell it how long that message is. Then we do system call this should

actually um this this should actually print a string. Okay so then uh let’s see down here I’m

going to make a function called crlf because I’m lazy and I don’t like constantly adding extra stuff

constantly adding extra stuff to the string so that there will be like a new line line feed

situation so i usually like to make a little function somewhere called crlf carriage return

line feed is what it stands for and it’s the same thing it’s just like load up the system call

registers so that it knows i want to print the string which is just a line feed

carriage return line feed and then actually call system call and then return to the caller so this

back up here let’s see crlf i guess i am going to be doing it it’s just a string with the the

slash r slash n or the carriage return line feed characters in ascii those are 13 comma 10 so i can

put that there instead of a literal quoted string okay so we got that and then that means after the

welcome message i can just like call crlf in order to have uh the cursor jump down to the next uh

after that string is notice how I don’t have any line feeds after my strings that’s kind of why I

like to do crlf and it lets me just call crlf a bunch of times if I want to just like space things

out temporarily okay so we’ve got the hello function and now we’re going to print another

message here I’ll just explain this real fast so I’m going to print a message about calling a c

So same thing, we’re just going to tell the system call service that we want to print a string and it’s going to be our string here that says, you know, we’re about to print this.

We’re about to, what do we say?

We’re about to call the C function and then later we’re going to call the C++ function.

So we’re just going to print a message announcing and do CRLF.

So that’s really nothing new at all.

And then down here we actually call the C function, which is not going to be in this module.

It’s going to be in the C module, the other source code.

Somewhere in this program, we need to let our assembly module know

that the C function is available because it kind of goes both ways.

In assembly, I have to mark a function as global if I want other modules to be able

to call that function, but I also have to mark a function as external

if I want to be able to call some other modules function.

So we have to go back up to the top.

I mean, somewhere in the text section, I think would be fine.

But for me, I just like to put it at the top.

put it at the top at the top so I’ll say externals and then I’ll go extern

keyword and then just name the function that I intend to call this way when the

linker is trying to link all the objects together it doesn’t get upset because

you tried to call a C function which is not in the current module it’ll

understand that it’s gonna happen you know like it’s gonna call other modules

for that it usually gets upset right away and then while we’re at it let’s do

Let’s turn the CPP function because that’s going to come from the C++ module.

So now we have both of our external functions set up.

We’ve marked our global hello function so other modules can call us.

And then let’s see, oh, what did I do wrong?

I put the C message in the wrong spot.

I was inside of the CRLF function.

So I’m just going to copy paste that back up here.

Okay.

Then we’ll do the same thing for the C++ message,

or for the C++ stuff.

I will first print a C++ message

with these lines up here.

That’s just like a regular system call,

and then I’ll do a CRLF, so nothing new,

just printing something.

And then I will actually call the C++ function

called the CPP function.

Then I’ll say goodbye with another block of text.

Again, not super important or complicated,

so I’m just gonna paste it.

Just another string.

string. And then when we’re done, I’ll just say, you know, return, we’re done. So that means if

you notice how we don’t have like any symbols in here called underscore start, that means this is

not a pure assembly program. And we don’t even have a symbol inside of here that is called main.

So that means this hello ASM module is not going to be the entry point of our program. It’s just

going to expose a function called hello, which does some stuff. The entry point of our program

really, let’s see, where is it? Oh, gosh, I think I already closed it for some reason. It’s the

driver program, which we talked about. So remember the driver program, it’s got a main here. So that

means this is going to be what the GCC libraries or the operating system calls, however you want

to think of it. So this is the entry point of our program, it’ll just print something quickly,

then it’ll call the hello function, which means execution will jump in to the hello module. So

module and and also it would be really easy to apply this logic to have a c module call on an

assembly module and in fact you can use this logic to have every type of module call on any other i

mean just if you have a c++ function either being defined in the current module or being referenced

in another module just make sure that you have an extern c block and then if you’re inside of a c

and you’re going to call a non-name mingled module like C or assembly,

then just do this block here.

No problem.

What else can I really tell you?

The C module, we looked at that.

The C++, we looked at that.

Pretty easy.

Hello module.

I mean, I guess we’re kind of done already.

So what we should see now is a little intro here.

Hello, my name is whatever.

And then when we jump into the hello module,

we should see a little welcome message about being in the assembly module.

And then we should see a message about calling the C function.

And then the C function should print.

Let me open that up for you.

Let’s see.

The C function should print.

Just, oh, by the way, this is the C function.

And then when it returns at the very end, remember, even in a void function, there is

a return statement implicit at the end of scope.

So when it returns, it’ll come back down here.

And then the C++ message will get printed.

printed and then the C++ function will get called which is going to end up being

just it just prints you know another message this is the C++ function

then when it returns implicitly at the end of the function

then we get down to here where we just basically say goodbye and then return to the caller

the caller in this case is going to be the driver program because this whole time we were just inside

called. So then the driver will say goodbye and then it will return control to the GCC libraries

or the operating system ending the program. Let’s see if that works. Okay, clear. And so,

you know, the way I wreck my make files, I’d like to do a little menu. I type make and it’s like,

oh, the menu, make menu, make build, just in case, just to see what’s up. Okay, clear.

say, let’s do clear and make run because that’s really what we’re after.

Again, run will implicitly call build.

So do that.

And it seems to have succeeded.

It wasn’t actually very exciting.

Let me do a make clean so you can see it compile real fast.

We run it.

It’s compiling.

That was still kind of fast.

So up here is basically the make file, all these lines.

They’re just calling your normal compiler and assembler tools and linker tools.

linker tools and then here’s the driver like we said it prints the hello message

you know my name is whatever I love that name I have a strange name generator

that I found online that’s not my name you can call me that if you want to and

then we have the message that we’re going to call the hello module so now

we’ve called into the hello function inside of the assembly module assembly

module prints hello you know I’m inside of here now and then the assembly module

Now we’re going to call the C function and then the C function actually

executes and it is now printing with its print F function call that it did,

you know, by the way, this is a C function. Hi.

And then it returns to the caller.

Maybe I could have added another print statement if I felt like I wanted to

spend more time, but it returns to the caller, which is the hello function.

Then we get to the next part of the hello function where it’s like now calling

the C function as a print statement.

Then it actually does call the C function. The C function prints itself out.

prints itself out hello this is the C function and then the assembly module

says goodbye it says it’s finished and then it returns to the caller so finally

at the end of this print statement the there’s like that little return statement

at the bottom of the hello module that returns to the caller which was the

driver dot CPP program so then the driver prints the driver is now back in

the driver is now back in control. You can see that message behind the terminal here.

The driver is now back in control. Then it says goodbye. Then it returns zero to the operating

system and the whole program is done. So it’s important to understand that if you want to

pass arguments, right now I’m just going to say, you know, I’m going to make another video that

is more robust in the future about passing arguments back and forth between these. It’s

important to understand for now that you can pass arguments between all these different

between all these different module functions if you want.

Like if I wanted to give the.

If I wanted to give the hello function.

An incoming argument, let’s say like an integer or a character value or a pointer

or something like that, I could just load up appropriate registers.

Remember, we have argument registers in assembly.

I think I can never remember if RSI or RDI are the first one.

I’m going to say RDI is the first argument just off the top of my head.

I always look that up.

So if I wanted to call, let’s say give an integer argument to hello when I originally

called it, then from the driver, I literally would just have to type an integer argument

in there and then under the hood, the RDI register, assuming that I’m right about RDI

being the first argument, the RDI register would get loaded up with that value.

your assembly program all you’d have to do is do something with the RDI register

you know load it up save it do whatever it is that you think you’re gonna do so

that’s how you pass an integer or like a character or a pointer from C++ to

assembly it works the same exact way if you want to pass arguments when calling

from C to assembly and when if you want to pass integers from assembly to C or

or C++, it’s the same thing just backwards.

First, you load up RDI as the first argument register with whatever value you want to pass

to C or C++.

And then in the signature of the C++ function, you just expect, you know, a long or, you

know, whatever you were going to get and the register will already be loaded up.

Remember, the C++ is not really happening on the machine.

It gets compiled down to assembly.

So this source code that we’re looking at, it’s another illusion for our benefit.

benefit. It’s not happening. It’s getting assembled and then compiled down to machine code. And then

that is what’s actually happening on the machine. So when you write that you have an argument in a

C++ function signature prototype, you’re not really writing that at all. You’re just saying

that the A variable should get loaded from whatever the RDI register had.

Or if you previously loaded the RDI register and you want to call a C++ function, that’s

a C++ function that’s what it would expect the RDI register so it can work pretty seamlessly

just calling things back and forth um so yeah I guess that’s all I really had to say

this is the basics of writing a hybrid program thank you for watching I hope you learned a

little bit of stuff and had a little bit of fun see you in the next video

thanks for watching this video again from the bottom of my heart I really

appreciate it I do hope you did learn something and have some fun if you could

do me a please a small little favor could you please subscribe and follow

this channel or these videos or whatever it is you do on the current social media

website that you’re looking at right now it would really mean the world to me and

it’ll help make more videos and grow this community so we’ll be able to do

more videos longer videos better videos or just I’ll be able to keep making

videos in general. So please do me a kindness and subscribe. You know, sometimes I’m sleeping

in the middle of the night and I just wake up because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy. That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could troll me if you want to just wake me up in

the middle of the night, just subscribe and then I’ll just wake up. I promise that’s what’ll happen.

Also, if you look at the middle of the screen right now, you should see a QR code, which you

QR code which you can scan in order to go to the website which I think is also named somewhere at

the bottom of this video and it’ll take you to my main website where you can just kind of like see

all the videos I published and the services and tutorials and things that I offer and all that

good stuff and if you have a suggestion for clarifications or errata or just future videos

that you want to see please leave a comment or if you just want to say hey what’s up what’s going on

you know just send me a comment whatever i also wake up for those in the middle of the night i get

i wake up in a cold sweat and i’m like it would really it really mean the world to me i would

really appreciate it so again thank you so much for watching this video and um enjoy the cool music

as as i fade into the darkness which is coming for us all

Thank you.

The post Mix C++, C, and Assembly into One Program – Hybrid Program Full Build Tutorial appeared first on NeuralLantern.com.

Hey coders! Ever hit a wall with a program that just won’t work? In this video, I’m spilling the beans on caveman debugging—a super simple, no-fuss way to hunt down bugs in your C++ code (or any language, from assembly to Python)! No need to wrestle with complex debuggers; this method is all about using print statements to trace what your code is doing, step by step.

I’ll show you a real C++ program where things go wrong (think integer overflows and mystery crashes) and walk you through how to sprinkle in cout statements to spot the problem fast. You’ll learn how to label decision points like loops and if-statements, break down complex expressions with temporary variables, and format your debug output so it’s easy to read. Plus, I share a neat trick called short circuiting to toggle your debug prints on or off without deleting them—saving you tons of time!

Whether you’re a beginner just starting out or a pro debugging a massive codebase, caveman debugging is a lifesaver. It’s quick, it’s intuitive, and it fits my “let’s figure this out” vibe perfectly. Stick around to see how I catch a sneaky bug in a for-loop and fix it in minutes.

Why watch?

• Learn a beginner-friendly debugging technique that works in any language.
• See real code examples with clear, relatable explanations.
• Get tips to make your debug output readable and avoid hours of frustration.
• Discover how to short circuit print statements for reusable debugging.

If you’re ready to level up your coding game and squash bugs like a champ, smash that play button! Don’t forget to subscribe and hit the bell for more coding tutorials, from beginner hacks to advanced tricks. Drop a comment if you’ve ever used caveman debugging or have a bug you need help with—I read every one! Check out my next video on using a proper debugger for even more debugging goodness.

Scan the QR code on-screen or visit my website (linked below) for more tutorials, services, and coding resources. Let’s keep the coding community growing—your support means the world! #CavemanDebugging #CodingTips #DebuggingHacks

Hey everybody! In this video I’m gonna try to familiarize you with a concept

called caveman debugging. It’s just as bad as it sounds but it’s really really

really useful. So suppose for the sake of argument you’re writing a program I’m

gonna show a C++ program here but this this concept is not just for C++

debugging it’s also for assembly and any other kind of language that you can come

other kind of language that you can come up with but suppose I have a program and I’m trying to

figure out why it’s not working so if you look at this program right here that I’ve kind of written

up already we have a main function here and we have like a little hello message that’s not my

name I love that name though and we have a variable a and then we just sort of do some nonsense to it

to try and compute a value for a when I say nonsense I mean literally I’m just I just made

I’m just I just made up instructions the point of this video is not to show you some advanced program

It’s just to show you that you know

This is how you can possibly debug a program that has gone awry

So you can imagine at home that this code you’re seeing right here might be your larger project your larger

Code base whatever it is that you’re doing that is not working for some reason and you’re not sure why

So, um, let me run the program real fast

It basically is just like a little for loop and then it just sort of

of you know not randomly but it just kind of increases the value of a for no reason

a bunch of times and then it calls a function that will crash later

so let me show you what happens when we try to run this program okay do do do

okay i want to go clear and make run if you don’t know how to do a make file or compile

or link or anything like that uh then go see my other videos so clear and make run

What did I do wrong?

TempResult was not declared in this scope.

Okay, well, this is now a video on reading compiler errors.

Line 59, I probably left something out.

Oh, because I just changed it.

I forgot to put it back in there.

Return tempResult, we should just return input times two.

And I’m just making this up.

It’s not really like a valid algorithm.

Okay, so we run our program.

We print the final result and we realize for some reason the final result is wrong.

result is wrong. So I don’t, I mean, I just made this up. So I don’t really know what the right

answer is. But just imagine that you are looking at some sort of an output, some sort of a final

state, maybe a crash. And you realize, oh, my program doesn’t work, but it’s too complicated

to figure out. Caveman debugging to the rescue. Caveman debugging kind of is as bad as it sounds.

It’s just really, really simple. But it’s also really useful, especially if you just want to do

on you don’t want to dive deep into a full-on debugger or do something more advanced it literally

is just printing a lot of things while your program is running i do it all the time i usually

don’t even go to a debugger unless i really get in trouble with like some huge mess um okay so

the first thing i’m going to say is in this for loop we uh you know we’re kind of like iterating

And so probably this is a good idea to announce that we’re iterating in the for loop.

So I’m just going to go Cout.

In C++, you know, we have the Cout object that we can use to stream texts to standard output,

which usually goes to the terminal.

So use whatever construct you’re using for your particular language.

So we’re going to do Cout.

And I should say also, if you’re programming in assembly,

if you are programming in assembly,

it’s a little bit more complicated than just writing a Cout.

little bit more complicated than just writing a C out you probably have to have some pre-computed

messages and then you can use a library to print a number to the screen or use printf to print stuff

to the screen but you can do it just takes a little bit longer so anyway conceptually I’m

just going to say this is the first iteration of my loop so I’m going to sort of announce it I’m

going to say main and then I’m going to call it main four or how about primary four or first four

but I want to try to label the for loop.

And maybe instead of leaving those parentheses blank,

I could say iteration number i right there,

or maybe I could do iteration i.

That would be pretty good.

Then I just have to replace the i with the actual variable i

so that the i keeps increasing.

So I’m just going to like do another stream operator here

and I’m going to say i.

Then I’ll print a new line.

we’ve got, you know, one iteration of our loop.

Maybe I should also print what is the current value of A

because the point of this, you know, weird nonsense code

is we’re coming up with a value for A, right?

So I should just print what A is at the top of each iteration of the for loop.

So I’m going to say A is equal to, and then do another A at the end of it.

And then maybe at the bottom of the for loop,

when the for loop is actually ending one of its iterations,

I can just say we’re at the bottom of the iteration so maybe I’ll put to end

iteration and then print the final value of a and then at the top I’ll say begin

iteration at this point you might start to feel like hey aren’t you using too

many words here like why can’t I just print a bunch of numbers I mean you

could but when you’re coding you need all the brainpower you can get to not

just code but to debug coding is already hard enough without making it harder

harder for yourself than you need it to be. So, you know, I see people all the time, they’re

trying to debug their code and they just like start printing numbers. And after not very long

at all, they’re looking at the debug output and they’re just like, what did that number mean?

Where is the number I’m looking for? It’s just a bunch of numbers. It’s harder to debug when you

do it that way. Do it the nice and pretty way. It just costs you a couple of extra keystrokes to do,

you know, nice letters and new lines and things, nice words, labels. Isn’t that still a lot better

Isn’t that still a lot better than debugging for an extra six hours?

Because you can’t really understand what you’re seeing.

Anyway, let me show you what this looks like so far with just those two lines added.

Now we can kind of see, alright, alright, on iteration number 61, where I was 61, then

this was the first value of A and then after that this was the second value of A, you know,

when we were finished with the iteration.

It seems to have gone up by a certain amount.

you know it was like a negative blah blah blah 836 and then negative blah blah blah 708 so it

kind of increased in value all right that’s a little bit helpful now it’s a really good uh

place to uh print our decision points so anytime in your code where you have an if or an else or

a function call or anything where you are kind of like you know making a decision or processing your

data in some way it’s probably a good idea to announce your decisions so i could say up here i

say up here i can go maybe i’ll say uh main first four and then i’ll call it uh maybe i’ll do a

double colon there and i’ll say top if just to make it easy to read that i’m kind of like at

the first if statement um maybe i’ll even put parentheses i’ll say a is more than 20 just to

kind of like name what i’m actually doing and then i could replace the a with the actual value of a

actual value of a so i could say a like that and maybe uh when i’m reading this later i might want

to kind of actually see the variable name so i could say uh you could just like put a as a string

and then maybe its value in parentheses or something like that do a new line um and then

maybe after that top thing i’ll say uh true to indicate that we’re inside of the the if statement

the if statement and then maybe at the bottom of that if statement we’ll just say

a is now true and we’ll say like a is now you know whatever the new value of a was so just

basically we’re announcing that we decided to go into this if block and then we announce what we

ended up changing a to and also you probably anytime you see a compound expression like this

You know B time something or a plus something or just you know a big part of multiple parts of the expression any expression

That’s more than just like one variable or one number. It’s probably a good idea if you break that up into temporary variables, too

and then

Print out each variable and I know that’s a lot of stuff to read but again it beats debugging for an extra six hours

I’m gonna leave that be for now though

leave that be and

I’m just gonna continue adding comments into the rest of the code. So I’m gonna do the second if block here

So I’m going to do the second if block here.

I’m going to say we’re in the first floor.

We’re in the bottom if more than 20 true.

And then we’ll print out what is the value of a after we’re finished.

We’ll say a is now is now whatever value for a.

And then I’ll do the same thing for this function call.

Because, you know, when I call this function, it’s going to change the value somehow.

So we’re going to do cout about to a plus equals f, you know, call to f.

And then inside the arguments, I’m obviously putting i plus 3.

But because i is a variable, we could just print that.

So I’m going to do quote, quote, and then just stick the actual i in there.

And then another new line.

a finished a plus equals f and then I’ll just say you know a is now you know a you know print the

new value of a you could also say a equal equal a and then print the value whatever you want but

the point is I’m just printing everything here so now let’s go down a little bit more because

there is a function call if you look at this function call down here here’s like some nonsense

being used here’s some other like you know disabled code really what i’m doing at the

very end is i’m just taking the input that the function received and i’m just multiplying it by

two and returning it so again imagine that your code is a lot more complicated than this

maybe input times two is actually input times two divided by three and then some other function

call and then some other this and some other that and whatever so a lot of people will just kind of

stuff like a really complicated expression in one line or one assignment or one return statement

And that’s super confusing because you can’t really be sure that every part of the expression is as you thought.

So it’s a really good idea to break it all up into parts and print each part.

So you could imagine that we have like a C out here and we’ll say C out, you know, begin F.

I’ll say like begin for F and then F receives an input of input.

Do an end L.

And then I’ll make a temporary variable here.

variable here I’ll say int temp results equals input times two and then I’ll

print that f and maybe I’ll do the input again

temp result is now and then say temp result so I’m just gonna print what the

temp result actually was and I could print something about I just multiplied

thing about I just multiplied the input by two and then you know the more

complicated your expression is the more temporary variables you want to use and

just kind of print every single one of them and print you know this new

variable is the result of dividing by two this new variable is the result of

calling some other function and so forth

so then we have like a basically you know basically a pretty good idea maybe

at the end though instead of multiplying by two again you want to make it more

want to make it more consistent with your debug output so like here temp result is obviously going

to be the result that i return why would you do the expression all over again for the return part

when you could easily get it wrong why not instead just return the temp result that you made right so

then that way your output completely matches what you’re actually returning and for now i think

that’s all we need to do let me run it one more time and then you’ll see a bunch of stuff now uh

Now, we have a lot of information that we can use to trace how our program was thinking and hopefully find the problem.

But isn’t this like a little bit starting to get a little bit hard to read, right?

You can see that there are kind of blocks happening whenever we iterate.

So, you know, for me, I always try to keep in mind you need all the brainpower you can get.

Why not just format it a little bit better so it’s really easy to just quickly look at one block and see, you know,

the couts kind of like belong together so i’m just going to add one more cout in the main for loop

here just at the very bottom i’m going to go couts and l just so that i get a new line and if i run

the program again notice how it’s easier to see the blocks like oh that’s clearly one iteration

right here you know your mind just grabs onto it faster and that increases your brain power and

makes it easier to debug and read the debug output so i can go all right all right okay so

all right okay so we’re right up here oh around uh iteration um number 83 uh a was this number

and then it got increased by uh this other number and the reason that that happened is because the

function returned 172 so it basically increased it by 172 and then it ended up being that number

oh okay i think i see what went wrong oh no right in this particular program if we scroll up just a

little bit we can probably see that the integer is overflowing right the integer was getting bigger

right the integer was getting bigger and bigger and bigger here and then eventually

it jumped into the negative at some point so right here we can see oh okay when did this

number become negative suppose we didn’t want it to be negative um what was this this is like

a million this is a billion no wait wait wait this is uh no that’s a million right there so it’s like

299 million and then it overflowed oh no no it didn’t it didn’t overflow it started at 299

it started at 299 then at the bottom it was sitting at 899 million that’s kind of close to a billion

and it did jump up from 300 million to 900 million so that’s a jump up of like 600 million

oh you know it’s like kind of jumping up faster with each iteration oh and i’m using a 32-bit

signed integer which has a maximum value of around 2 billion so now i could possibly realize at this

the number is just like it became too big and I need to change my data type or I need to change

my algorithm for some reason right so you can kind of get to the bottom of things pretty quickly

so here’s another problem that people encounter when they’re using caveman debugging

basically you you add all these cout statements or print statements or whatever you’re doing in

whatever language you have and then when you’re finished you’re kind of like well I guess uh

I need to delete all of these Couts because I don’t want all this you know

Junk being printed in my program after I fix the problem or maybe you’re trying to debug a different part of your program

So then you start commenting out all the print statements or you start

You know deleting them or whatever and then whoops later on you realize maybe that part of my program

Was not actually fixed and I have to add all the Couts all over again from scratch that costs time

So that’s not fun. So here’s a trick that I like to use. It’s called a short circuit

it’s called a short circuit it’s a sort of like a beginning C++ thing or just

when you’re first learning how to use logical operators for boolean

expressions so I’m gonna do a boolean and I’m just gonna name it after what

problem I’m trying to solve so we could just call this you know main C outs or

something like that let’s I don’t know primary problem I’ll call it primary

the boolean as true because then what will happen is uh we can then short circuit all of the cout

statements we can say primary problem couts and cout like that and the way the short circuit works

works is if you have a logical and expression you can see right here we have two sides

of that statement now one’s on the left which is just the boolean and one’s on the right which is

have a logical and then you know one and zero is equal to zero true and false is equal to false so

both things have to be true for the expression to evaluate to true which means if the first thing

is false there’s no point in even looking at the second thing at all because if i if i set that to

false then the second part the c out is it doesn’t matter the whole expression is going to evaluate

to false anyway so uh the logical operator itself will just you know block out the rest of the

you know, block out the rest of the statement.

That’s called a short circuit.

So I’m going to copy the short circuiting to all of my C out statements like this.

Okay.

And do that.

And then the C out there.

And I guess I’ll leave the final result there.

And for the moment, you know, this is just a regular function.

apply the short circuiting to this other f unless I do a separate boolean but

keep in mind if this was a class and you had two different methods that you

wanted to short circuit see outs inside of at the same time you could just use a

member variable and name it after the problem you’re currently trying to solve

and then just short circuit each see out in the appropriate method with that

boolean so I guess in this regular program that doesn’t have a class I

could move the boolean into the global if I wanted to but I’m not going to right

if I wanted to, but I’m not going to right now.

And if you’re writing assembly or some simpler language

and you’re thinking, hey, I can’t short circuit an assembly

or some other language, well, you could write a function

that just takes a couple arguments.

You could write a function that takes a string to print

and maybe a number to print or just, you know,

something simple like that.

And then in the function itself that prints,

you could call it debug print if you want.

Have it look at a global variable or define

that you’ve set up at the top of the assembly module.

set up at the top of the assembly module, which you can just turn on and off,

like just do a data byte and set it to a zero or set it to a one.

And then the function debug print will just look at that variable to decide

whether or not it’s going to actually print or not.

So, you know, it’s a little more complicated in assembly,

but you can do it basically the same concept.

Let’s run this again just to make sure it still works.

Okay, so it still works.

So now suppose I want to turn off all the Cout statements.

If I just change the true to false,

the true to false notice how it’s all gone except for the stuff inside of f which i told you i

wasn’t going to touch but notice how easy it was to mute it and then if i want to bring it back

later i just go true to unmute it of course if you want to do a little bit more typing you can

also do if statements like if this condition is true and that condition is true then print the

debug statement so then you can have a more complicated way of muting and not muting but

I’m going to leave it as is right now.

Let’s see, what else do we got here?

I think actually at this point, this is the basic idea of caveman debugging.

Just basically print everything.

Print all of your decision points.

Use pretty labels that are really, really easy for you to understand.

Use formatting so that your brain doesn’t have to struggle to understand what you’re seeing.

If you just print a bunch of numbers, you’re going to be shooting yourself in the foot.

you’re going to be shooting yourself in the foot and use short circuiting or if statements to

selectively mute them so you can do less typing and and debugging the debugging and so forth but

yeah i think i think this is all i really wanted to show you in this particular video

i hope you feel like an expert in caveman debugging i certainly am and it you know it

kind of fits my personality a little bit i’m like what’s going on um and like i said before

debugger it’s probably a better idea but I usually don’t unless I’m in big trouble

and I have a huge mess on my hands I usually just go directly to caveman

debugging we’ll look at the same piece of code in my next video that I’m going

to publish which is going to talk about using a proper debugger so watch the

next one also but for now I hope you’ve enjoyed this video thank you for

watching I hope you learned a little bit and had a little bit of fun see you in

video

whoops what the heck

hey everybody thanks for watching this video again from the bottom of my heart

i really appreciate it i do hope you did learn something and have

some fun uh if you could do me a please a small little favor could you please

subscribe and follow this channel or these videos

or whatever it is you do on the current social media website that you’re looking

at right now it would really mean the world to me and

more videos and grow this community so we’ll be able to do more videos longer

videos better videos or just I’ll be able to keep making videos in general so

please do do me a kindness and and subscribe you know sometimes I’m

sleeping in the middle of the night and I just wake up because I know somebody

subscribed or followed it just wakes me up and I get filled with joy that’s

exactly what happens every single time so you could do it as a nice favor to me

or you could you control me if you want to just wake me up in the middle of the

and then i’ll i’ll just wake up i promise that’s what will happen also uh if you look at the middle

of the screen right now you should see a qr code which you can scan in order to go to the website

which i think is also named somewhere at the bottom of this video and it’ll take you to my

main website where you can just kind of like see all the videos i published and the services and

tutorials and things that i offer and all that good stuff and uh if you have a suggestion for

clarifications or errata or just future videos that you want to see please leave a comment or

if you just want to say hey what’s up what’s going on you know just send me a comment whatever i also

wake up for those in the middle of the night i get i wake up in a cold sweat and i’m like

it would really it really mean the world to me i would really appreciate it so again thank you so

much for watching this video and um enjoy the cool music as as i fade into the darkness which is

us all.

Thank you.

The post Caveman Debugging: Simple Trick to Debug C++ Code Like a Pro! appeared first on NeuralLantern.com.