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.

Hey there, coding enthusiasts! Ready to master compiling, linking, and executing programs on Linux? In this fun and approachable video, we dive into the nuts and bolts of turning your code into runnable programs. We’ll create a simple C++ program, compile it with G++, and explore object files, linking, and execute permissions. Plus, we’ll mix in C and assembly code, tackle name mangling, and build a bash script to automate it all! Perfect for beginners or anyone curious about Linux programming, this guide is packed with practical tips and real-world examples. Don’t miss out—subscribe for more coding adventures, leave a comment with your thoughts, and let’s geek out together! Scan the QR code to visit my site for more tutorials. #LinuxProgramming #CodingForBeginners #CPlusPlus

Introduction to Compiling, Linking, and Executing 00:00:00
Overview of the Process 00:00:05
Writing a Simple C++ Program 00:00:28
Compiling with G++ 00:02:01
Understanding Executable Files 00:03:04
Executing a Program 00:04:21
Handling Execute Permissions 00:05:13
Creating a Compile Script 00:07:00
Using Shebang for Scripts 00:08:43
Specifying Output Files 00:10:53
Breaking Down Compilation Steps 00:12:26
Compiling to Object Files 00:13:17
Linking Object Files 00:15:24
Handling Multiple Source Files 00:18:39
Mixing C and C++ with Name Mangling 00:22:52
Enhancing Script with Error Handling 00:24:29
Adding Assembly Source File 00:31:16
Using Bash Variables for Flags 00:41:53
Organizing Compiler Flags 00:44:41
Final Script Enhancements 00:46:36
Conclusion and Call to Action 00:47:35

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

Hey there! Let’s talk about compiling, linking and executing.

This video is going to focus on Linux, but I think it’ll be useful for all other operating systems that you might be working with at home.

I’m just going to basically explain like what does it mean to compile?

What does it mean to link a program?

What does it mean to execute a program?

If you don’t know that, then I think this video might be for you.

Okay, so for starters, imagine you have written a program.

I’m going to write the program here real fast.

I’m going to say, let’s do an empty file.

We’ll call it, let’s see, I got my answer key up here.

We’ll call it first.cpp.

First.cpp.

So I’m just like making a first piece of source code and I’m editing it in my little editor.

Notice how I’m not calling this the main.cpp program because a lot of beginners, they always

do main.

I want you to know that you don’t actually need a source code file called main.cpp.

Even if you’re writing a C++ program, all you really need is just one instance of the function main.

Beyond that also, you only need an instance of main if you’re writing a hybrid program

or some kind of program that is in pure C++ or that has the GCC libraries.

GCC libraries call on the main function as your entry point.

But if you’re writing pure assembly, the entry point is actually underscore start as a label.

We’re not really going to do this is not an assembly tutorial.

I just wanted you to know real fast.

Okay.

So I’m going to do like IO stream and then I’m going to say

STDC out and I’m just going to print, you know, hello from first.

Cpp.

STD.

And L.

Okay.

So we kind of have like a hello world program that’ll just

that’ll just basically print a message and do nothing else how do we compile

this program and execute it you know what does that actually even mean okay

so for starters the first thing that you probably do when you’re compiling a

program you’ve probably been told to do something like this let me get my little

command line open here you’ve probably been told to do something like this

let’s compile with GCC or G++ and we’ll say the standard for C++ that we’re

There are a bunch of other standards you can use.

We can turn on all warnings.

We can have the compiler be pedantic in terms of the warnings that it gives us.

You know, these two things at the end don’t really matter that much.

It’s really all about G++ and then STD C++ 23 to get it compiled.

And then we’ll give an input file.

We’ll say burst.cpp.

And then I think probably usually this is where most of you stop.

you stop we just kind of like specify a couple flags specify the input file then

hit enter and it compiles if we list the contents of the directory now this might

be familiar you’ll probably see something called a.out a.out notice how

the permissions look a little bit different for that for that file it’s

kind of printed in green in Ubuntu and if you look at the left side right here

you can see that it’s got a bunch of X’s in the permissions area that just means

That just means it has execute permission.

The compiler does that automatically for you,

but essentially this is like just, you know,

an executable binary file.

It’s not a text file.

It’s just something that the computer is meant to run.

We can look inside of it real fast.

There’s a program called XXD on Linux,

and it’ll sort of spill the contents of that file.

So if I say XXD and then I go a.out,

it just spills like a whole lot of like binary nonsense,

right?

you can see at the very beginning elf that’s uh i think that’s executable linking format

for linux and then there’s like a bunch of stuff and it just doesn’t make sense this is not text

that you can read here’s like some sort of a shared argument that it’s using and then some

register information i don’t even know what most of this is somewhere in here if you look

carefully you’ll probably see that message where is that oh yeah hello from c first.cpp so it’s

saying that the message we typed in the program is actually embedded in the executable.

That makes sense.

So hopefully I’ve proved to you that this is just an executable program.

How do you execute the program?

Well, usually you’ll have to type, you know, the full path to the program that you want to execute

because your custom program is not in the system library paths.

So your system’s not going to know where to find it automatically,

even if it’s in the current folder.

So you would usually do something like, you know, the full path to your executable,

path to your executable like a.out. But there’s a shortcut we can use in Linux. The dot directory

usually just means or it always means the current directory. So if we say dot and then a slash,

that’s the same thing as typing out the full path to the current directory. Then it’s really easy to

just type the name of the file that we compiled. Okay, so a.out. We executed it now. So that’s what

it means to execute. We just compiled without a lot of options. We’re going to try to do that better

We’re going to try to do that better in a second.

And we know that you need execute permissions.

Let me show you what happens if we take away execute permissions.

I’m going to use a command called chamad, like change the mode.

I’m going to say take away execute permissions from the a.out program.

Then if I list the directory again, notice how there are a bunch of X’s missing now

on the left side of that a.out permissions area.

Notice how it’s not in green anymore.

Depending on your system, it might not be green or gray or whatever.

be green or gray or whatever but just look at the permissions so now if i do a dot out

it’ll say permission denied maybe you’ve seen this before especially if you’re syncing with

the cloud that doesn’t carry execute permissions from one machine to another which happens to me

all the time we can reverse this with just the chamad you know plus x execute permissions

and then we can just execute it again the funny thing about execute permissions is

you can actually execute a bash program which is basically a text file without

without needing to execute a binary program so this is not a bash video I’ll

make other videos in the future on my channels for for bash but for now just

know that something you compile is not the only type of thing that you can

actually execute in fact in Linux under the hood a lot of system tools are just

written in bash or Python or something else that looks like a human readable

like a human readable language and they are not necessarily all compiled languages, you

know, like C++.

Okay, so now that we kind of know that we’re compiling a program, let’s be a little bit

better about specifying the name of the output file.

So I just want you to see one more flag here and while I’m doing that, I’m going to create

a script that will compile our program for us.

nano and I’ll just name a file I’ll name it compile and it’ll be our compiler program okay

so what we did before is it was I think G++ and then we named the standard is C++ 23 and then we

said wall wall just means give me all warnings which is good to help your you know to help you

write better code same thing for pedantic just helps you write better code it gives you more

but you know it’s pretty good. Okay so this is where we stopped last time so

I’m going to say now let me remove a dot out now instead of typing the command by

ourselves we can run the compile script. The language I’ve just written was was

well I haven’t really written in any particular language but if we use a

shell interpreter called bash which is actually what’s running in the terminal

right now it’ll interpret any command line that we give it as just something

line that we give it as just something that we want it to execute to the system. So if I type

bash to run the bash interpreter and I just specify the name of the script, it should compile the

program automatically by executing that one line that I put inside of it. See now I’ve got the a.out

again. If you rewind the video you’ll see the a.out wasn’t there when I originally ran it.

One more time just to prove it to you. bash compile. Now you can see that it’s back. Okay

Okay, so let’s make this compile program a little bit better instead of typing bash every single time

I think I just want to try to execute the compile program directly. I

Can do that pretty easily. There’s something in

In our script that we can put that will designate what interpreter we should use to run the program

So right now it’s just like some text and it doesn’t really mean anything

there’s something called the shebang which just means hash bang and

just provide the path to some interpreter. I’m going to type shebang and then a path

to the bash interpreter. If you don’t know where bash is on your system, you can go which bash.

And I guess mine is a user bin bash. I think I can get away with bin bash. Let me see.

Let me just type it out to make sure bin bash. Yeah. Okay. So if I type exit, I’m actually in

another version of bash, which is inside of bash. If I do exit, I should just kind of stay where I

Okay, so bin bash will work, user bin bash will also work.

I’m going to go back to editing this compiler program.

And now all I have to do, because the system is going to know what interpreter to use to execute my little script program here,

all I have to do is add execute permissions on it, and it should work.

So let me first remove a dot out.

And then let me try first to execute compile.

It should not work because I don’t have execute permissions.

Remember we talked about that before.

permissions. Remember we talked about that before? So if I do that it says

permission denied. Oh no! So I’m going to give it permission to execute. I’m going

to say change the mode plus X on compile. If I list the directory again notice how

it’s green notice how there’s a bunch of X’s everywhere. So now I should be able

to just say compile and then it seems to have worked and notice how it has an

because it’s a pain in the butt to type out all the compile commands every single time,

especially if you have a complicated compile command or many files that you want to compile

in the same shot. So, you know, of course, in another video, I’m going to talk about make files,

build systems, proper build systems are a lot better than just making a script. But for now,

let’s just make a script because I just want you to understand, you know, compiling, linking,

some of the surrounding ideas. Okay, so I’m going to, let’s see, I’m going to go nano compile.

And the next upgrade that I want to make is I want to specify the output file because it’s

kind of a bad idea to not specify the output file and just hope that the compiler gives you

the file that you wanted. I don’t know. So I’m going to do dash O main, and that’s going to give

So if I remove a.out just to keep my area clean, I can now do compile.

And if I list again, notice how I’ve got main.

So I can execute main and it’s the same program that we already had.

In fact, maybe sometimes just as a shortcut since this is a script,

what if I’m always hitting ls-la, I always want to list the folder after I compile.

I could just put that into the script.

The more commands you put into the script, the more convenient things can get, unless

I guess it gets too messy.

So I’m going to do, I’m going to list first, and I’m going to remove main, just to prove

to you that we’re doing this from scratch, and then I’ll do compile.

Notice how it compiles and then lists everything for me.

Seems like it didn’t actually turn the compile green.

That’s probably another flag that we have to stick in there.

Let me see if I can do that real fast.

If not, I won’t waste time.

This is not an LS video.

probably color or colors is what I got to do. Let me just do that one more time. Yeah, okay. So

that’s just a flag on LS. That’s not what this video is about. So now we’re compiling directly

to main, but here’s the problem though. We’re actually kind of sort of skipping over some

steps that we could be aware of. When we compile our program, we’re actually taking our source code

and we’re assembling it down to assembly code under the hood, and then we’re compiling it to

And then we’re compiling it to an object file, which is sort of just machine code.

It’s like a level lower than assembly.

And then as a last step, it’s getting linked into an executable named main.

So we’re skipping a ton of steps.

Really what’s supposed to be happening is every single source file.

Oh, whoops.

I’m on the wrong machine right now.

Okay.

Where’s that?

Oh, the machine that I’m recording on.

There we go.

CPP and we’re thinking that it just goes directly to main you know that works if you only have one source file or if you don’t want to have

fine-tuned control over your compiling

But I would like to do something a little bit more detailed. Let’s compile our

CPP source file into an object file. I’ll name it first.o and then we’ll link that into main

Why is that useful because later when we have multiple source files?

We might we might want to compile them all to object files first and then link them all together in one step into main

all together in one step into main this will be even more useful when you later realize that you

can use a build system that does kind of the same thing to save compilation time i won’t talk too

much about make files here but let me just tell you when you start using a build system

your compile time can be drastically reduced uh story i used to have a program a long time ago

that i wrote myself took like an hour to compile i would literally every little change i made i’d

have to get up and leave and go make a sandwich or something and then come back by the time it

back by the time it was finished compiling when i started using object files as intermediate steps

and upgraded to a build system i was using gnu make then my compile time went down to like a

minute each time so it was like so much more efficient anyway let’s do that let’s do that now

let’s let’s uh let’s nano our compile script and you just need another flag in here for the gcc

an object file and not actually produce a fully linked executable that you can execute that means

i should probably rename main to something else because main is supposed to be my executable at

least that’s what i’ve chosen i would like to have every object file be named similarly to the source

file it belongs to so i’m going to type the output now is going to be first.o and then the c flag

just says only compile don’t link this means of course that i’m not going to produce a program

a program that I can run. Let’s see, I’m gonna end up accidentally deleting the

compiler. Okay, but we can see what we’re doing. Okay, so compile and CPP for first.

So I’m gonna compile it and now notice how we have an object file and no main

and just the source file and its corresponding object file. So I can’t run

this program. I have to do the additional linking step now. So I’m gonna do

step now so I’m going to do compile and in my editor here let’s see where is my

command that I wanted to do for linking okay so I’m going to link with the the

GCC libraries I’m gonna use the G++ command I’m just gonna put a couple of

flags I’ll explain them real fast I’m gonna say that I want a 64-bit

executable which you probably actually don’t have to specify I’m going to

anyway and then I’m gonna tell it again that I want it to link up against the

23 libraries. This is important if multiple modules reference the C++ libraries. I’m not

even sure. I think I need it in both the compiling command and the linking command. I’m going to

leave it in both because it should work. Usually if you want to embed debugging symbols into your

program, you want to put a dash G there, which is a great idea. But we’re not going to talk about

debugging in this video. You can also specify the type of debugging symbols that you want.

symbols that you want I’m just gonna put that in here right now G dwarf 2 and

then there’s some new flags that you kind of need there’s one here called no

PI which I think is just an Ubuntu thing your program probably won’t execute if

you don’t do that just just put it in there and trust me there’s another one

that we have to put in now called no exec stack which basically prevents your

program from executing code sitting inside of the stack which is just sort

not get hacked hopefully it’s not bulletproof but you know it might help

and then i’m going to give it input files the input files for the linking

stage maybe i should do a comment linking stage

compile the c++ program or source or something

for the linking stage uh you want to you want to provide all of the object files

that you’re going to link together in this case we just have you know

file named first and then we can specify the output file as main if we didn’t

specify it would probably be a dot out like we saw before so if I got this

right let’s see if I did now this should compile the C++ source code file into

its corresponding object file and then scoop up the object file turn it into an

executable okay so my clear and then list and then I’m gonna remove the object

put star dot o which is a shell trick to basically say that that star dot o is

going to expand to really mean every file that ends in dot o so you know in

this case it’s actually just gonna end up being first dot o but it’s a trick you

can use to grab multiple object files or files of a certain type all in one

command so I’m gonna do that and then I’m gonna list again and then I’m gonna

compile and you can see that the compile command it created first dot o the

the object file, and it also created the executable main.

So if I execute main, the same thing should happen.

So great. We’re ready to move on to another step.

Let me remove star dot O.

I got to be so careful because I’m going to totally ruin this video by erasing the wrong thing.

Okay. Because this is, I should be in a Git repository, but I’m trying to be fast here.

Okay. So let’s nano compile.

Let’s create a second source file actually.

Okay. So let me get out of this.

Let me get out of this.

I want to create a second source file.

I’m going to call it second.c.

It’s going to be a pure C program.

And because we don’t have C++ libraries in C source files,

I’m just going to say, you know,

standard input output dot O for the header.

I’m going to make a function called void second probably.

And it doesn’t do anything except just sort of print

a little message.

So I’m going to say hello from second.

And then do a new line.

because we don’t have endels in c all right i think that’s probably going to work so then

let’s uh edit our compiling script and we’ll just add another line here to compile the c source

okay so i’m going to go gcc because it’s not c plus plus anymore and um i’m going to do all

warnings and pedantic again uh you don’t really need even need to worry about that and i’m going

need even need to worry about that and i’m going to give it an input of second.c because that’s the

file we just worked on and i’m going to tell it i only want you to compile with the dash c flag if i

forgot that on this one then i’ll probably end up with an object file a main and then an a.out that’s

only based on the c source code and that probably wouldn’t work because the second source code

doesn’t have a main function inside of it so um let’s see we’ll do output and it’s going to be

and then I think that should be okay you know something that I just realized I

should mention too is when you’re making hybrid programs like this or or

programs where there are just many many source files like I said before you

don’t need to have a source code named main.cpp you can name all your source

codes anything that you want the one thing that you really do need is a piece

of source code oh I’m editing inside the terminal suddenly sorry I got

Sorry, I got sidetracked.

I wanted to edit all this stuff inside of Genie because it’s a little bit better.

Maybe it doesn’t matter.

So notice how we have the main function inside of our first.cpp program,

and then there’s no main function inside of our other source codes.

For your program that uses the GCC libraries, you need exactly one instance of main.

so that means um you know you have to have at least one and if you have more than one it’s

probably not going to link so if i put a main inside of here probably not going to work

this also kind of means you can arrange your source code in a funny way you could

have a bunch of different pieces of source code that you could consider maybe libraries maybe

there are a bunch of classes or something that will help your program and you can release multiple

different executable files by just having different source code files each with their own

mains and linked separately against the object files that contain your library or classes or

whatever that’s just a little side tip but um anyway let’s see if i actually did this right

we’re linking this and i’m going to see if it works i get stuck inside of the terminal i start

thinking i’m going to edit everything inside there okay so it compiled well let me let me

remove the main and then just clear it again in the list okay so now I’m gonna

run the compiler and after the compiler ran everything seemed to be okay it

compiled first into its object file and it also compiled second into its object

file if I run the main executable notice how it only prints hello from first dot

CPP well what about the second one that we just added well what we need to do is

improve our linking stage notice how in the linking stage right here we just

stage right here we just only link first.o so we should also include the other object file that we

want i’m going to glob that in a second but uh let me show you compile now if we run main

what did i do wrong hold on let’s see here second.c oh i forgot to actually call the second

function so that’s cool just uh wrote a bunch of stuff for no reason at all let me uh let me have

have the main function call on the second function we’re going to encounter an issue here too the

second function is written in c and the first function uh its its source code is in c plus plus

and the thing is c plus plus uses something called name mangling i won’t go over it too much in this

video but it uses name mangling so you can overload functions you can have functions with the same

name but like different signatures right so it’ll go in there and it’ll mangle the name of a function

the name of a function according to its overload prototype so that we can actually call overloaded

functions but we don’t really have that in C so that means if we try to call a C function

from C++ we’re probably going to end up calling the wrong name because there’s the expectation

that the other module has name mangling enabled but it’s not because it’s C so I just have

to do this little block extern C and just name all the stuff that is not going to be

name mangled i’ll just provide the prototypes of all the functions that i want to be able to call

so just void second if you look here again we just have void second and now when um when the c plus

plus module calls on second it won’t expect name mangling so it should work so we’re calling it

and then we linked it now everything i think should be okay i’m going to compile one more time

and then i’m going to run the main program and now you see that we have both calls in there

Awesome. Let’s give this script a little bit more output though. This is kind of

precarious. What if something failed inside of there? Maybe you don’t want the script to continue

if something fails and maybe you kind of want to know where the script is at while it’s compiling.

So I’m going to upgrade it just a little bit. So compile the source. I’m just going to say echo

compiling the, you know, compiling burst.cbp. And then here I’ll just do another echo and I’ll say

and then here I’ll say echo linking the executable or the binary aka the binary

I don’t even know if that’s the proper term I just like to call these things binaries because

they’re not in text anyway so if we do another I’m going to do I’m going to do a compound

command line here I’m going to go clear and compile so that I don’t have to continue to

continue to clear every single time. Now notice how it prints what it’s doing. So if it kind of

failed somewhere along the way, or if it took a long time, you’d kind of know what’s going on.

Now let’s use a little bash trick, because remember this is a bash script. It’s not just

going to only execute actual commands. I’m going to say or exit with the return code of the previous

We’re going to try to execute G++.

If G++ fails for some reason, then the whole program or the whole script is going to exit

and it’s going to exit with the return code mentioned here.

I think it’s not going to print it.

I’ll show you how to print it in a second, but we can actually make a function called

die up here in a second, which might be better.

So I’m going to do the same thing over here.

I’m going to say or exit with the return code of the GCC command and then here or exit with

And then here or exit with the return code of the linking command.

We’ll do it one more time here.

Notice how it seems to work.

So now let’s make the first C++ program not actually compile.

I’ll put a bunch of Zs there.

And so if we try to compile it again, it should just quit right after it tries to compile the C++ program.

So that saves you some time and helps draw your attention to what went wrong.

The C++ compiler is saying hey, there’s like a type there. It doesn’t show the exit code though. So let’s make a function in bash

That will die and print an exit code. So I’m going to say do die or maybe just die by itself something like that

Functions whoops. I’m in the wrong language

Let me go back to the compiler

make a function in bash

Called die and it’ll take one argument and the argument will just be the exit code

that we want it to alert us of.

So I’m going to say echo,

I’m going to say we are dying now.

Previous exits code was,

maybe I’ll do a little variable here,

I’ll do a local variable.

Exit code is going to be the first incoming argument.

This is a bash program, not C++.

And then here I can just say exit code.

Okay.

So then after writing all that,

then after writing all that I can say or die and then just you know so I’m calling

a function and the first argument I’m giving it is the actual exit code of the

thing that died so we’re just kind of like using indirection to print a pretty

pretty message to get a little bit more information so we’ll try that one more

time notice how it says we are dying now previous exit code was one so that just

that just tells us that gcc exited with the exit code of one not super useful but it’s nice to see

could be something else entirely like i don’t know maybe uh maybe we misname the first source

code file let’s see if the code changes i think it probably will nope maybe this exit code was one

no such file or directory all right exit code am i doing something wrong i guess i’m all right

Alright, okay, so let’s just move on.

I wanted it to be fancier.

We could also upgrade a little bit if we wanted to.

Instead of echoing, I could make a function called log here,

and I could just say that the log command just echoes,

and maybe we’ll put a cute label, and we’ll say, you know,

my super cool program compiler, or how about super cool compiler?

And then just do the $1, because that’s the first incoming argument that you get.

the first incoming argument that you get now I can type log instead of echo so

that’s nice and why would you want to do this well now it’s gonna go inside of a

function which means later on you can start adding extra commands like logger

a log to the system daemon oh no so this would write to your system log in

addition to printing something you could do anything you want you know it’s just

like a regular program adding more power by sticking everything inside of

functions I’m gonna put log here and let’s see if it works

let’s see if it works pile okay nice notice how we have a little message with a little header which

seems pretty cool maybe instead of echoing here let’s make a complaint function let’s do a

complain and same thing as the echo function but maybe I think there’s a flag where you can tell

echo to print to standard error instead of standard output but I’m just going to do it the easy way

it the easy way I’m going to say one goes to two so that the the first pipe standard output is going

to be redirected into the second pipe standard error so now I can use complain instead of um

echo down here complain before I die oh I forgot to actually

or die I forgot to actually exit so that means it was oh yeah it’s still compiling everything

Let me fix that.

So in the actual die function, hopefully you were at home cringing along with me.

Let’s see, let’s exit with the actual exit code that was specified just to make things

a little bit more automatable.

Yeah, now it stops right away.

And the complainer is like, you know, pretty cool.

Let me fix the first source code real fast.

And we’ll say that the second source code is broken.

We’ll put a bunch of Z’s there.

So now the first one compiles, the second one, it breaks.

And we’re starting to, you know, get a hang for a compiler script that’s a lot more sophisticated

than just typing things on the command line, right?

You can take this as far as you want.

The next step above this is using a proper build engine.

So let’s see.

Well, let’s do another source code.

an assembly source code. So we’ll say third dot ASM and it’s just going to be Yasm. This is not

a Yasm or assembly tutorial. I’m just showing you how to, you know, build a, you know, compile,

link and execute. We’ll make a data section so I can just stick some defines in here real fast.

I’ll say system write is going to be equal to a one and then the file descriptor for std out

Do you ever feel like red jumps out at you on the screen?

Does that mean I have eye problems?

I am kind of old now.

I don’t know.

Hello from third dot ASM and I’ll just put a little new line there.

So I don’t have to do it elsewhere.

And then I’ll have to specify the magic message length because this is not a sophisticated program that can loop through the message looking for a null terminator.

And then I’ll do a text section, which is where your code goes.

which is where your code goes and you know in hybrid programs if I have this

third function which is marked as a which is marked using a label and then

in return statement I still have to mark a third as being accessible outside

this module so I’m going to do the global statement and then I’m just going

to do really quickly I’m going to move something into RAX it’s going to be

system right so basically I would like to write something somewhere to some

some file descriptor its first argument wants where I want to write it so I’m

gonna write it to the standard output instead of an actual file and then I’m

gonna move RSI the next argument is going to be the actual message or a

pointer to the message that I defined above and you know check out my other

videos if you want to learn assembly that’s this is not this is not an

assembly learning video I’m just kind of doing it real fast in case you’re

probably unless I ruined it somehow let’s start compiling or assembling the

assembly program so just one more we’ll say assemble the assembly source or

module or whatever you want to call it we’re going to use the ASM to do that

G dwarf 2 is the debugging symbols not necessary in this video the format is I

want a 64-bit executable that’s how you do it in Yasm and I’m going to give it

and I’m going to give it an input of just the third assembly source file.

And I want it to output the third object file.

I got to remind myself to glob line 36 after this or die with the exit code.

Okay. So now this might work.

Oh, I got to put, I got to put third dot O in the linking stage.

I’m going to do clear and I’m going to go here and compile.

and compile.

Unrecognized debug format, dward.

Why didn’t you stop me?

It’s g dwarf.

Let’s see, what did I do wrong?

g dwarf, oh, dwarf dash two.

Oh, it’s not even g, it’s just dwarf two.

Sorry.

And I got to put a dash, I think, for EASM.

Yeah, okay.

Let’s see if that works.

What did I do wrong?

Oh no no, Yasm doesn’t need the dash, but GCC wants the dash.

Okay, I had it right the first time.

Doop doop doop, okay, so it probably linked.

Let me run it and see what happened.

Hello from the second, oh, we still have to actually call it from the C++ module.

So now we’ll do the same thing.

We’ll say that the assembly module, it’s not going to use name mangling.

use name mangling there’s no overloads so we’re going to put it into the extern C

block and we’ll just say you know void third how do we know that’s that it’s a

void function with no arguments well you know that’s just a convenience that

happens under the hood with C and C++ in assembly it’s just a label that you’re

jumping to and returning from void means return type all that means is I’m

trying my best not to make this a C++ or an assembly tutorial but all that

All that means is there is no return value getting returned.

That would be the RAX register if I wanted to move something in there.

And then similarly, if I wanted to catch arguments, I’d be grabbing from other registers.

So I’m not grabbing any register, any arguments from registers, and I’m not sending a value back with RAX or XMM0 or anything.

So that just means it’s void and no arguments.

So let’s do it again.

Compile it and then run main.

then run main hello from second oh i sure put in the name mingling thing but i forgot to call it

let me do that third so now one more time compile and then run it

what’s happening in here

third i guess i should probably open this up now third asm so global third and then third oh

important part of a system call you got to put the keyword or the instruction system call in there

one more time i hope you’re laughing and cringing at home trying to make this more fun maybe i don’t

know okay so now it’s all it’s all working notice how we have a bunch of different modules in

different languages we’re compiling them all to object files first and we’re uh we’re linking

them all into one executable and we’re doing this in a really really easy way by using a script

script instead of typing all the commands out manually. Pretty convenient, right? Let me give

you another upgrade real fast here. So this is kind of irritating. I have like all of these object

files that I have to specify. What if I forget to specify some? Since this line 36 is just going to

be something that goes directly, you know, to the shell as a command line. This is not like bash

wildcards I can say star dot o meaning I’m going to give every object file to

the linker as an input file and that should just work automatically keep in

mind if you want to use an advanced strategy like I mentioned earlier where

you have multiple different object files and they’ve each got their own main

functions because they’re each going to be their own separate executables then

globbing all object files probably not going to work you might want to organize

files or stick the object files for executables in like their own folders or

something like that we’re not going to go that far but I just want you to know

so let’s do that again real fast here we’ll say clear and compile and I’ll

just try to like run main assuming that the compiler works yes so it worked

everything compiled by the way this and end that means only execute the next

So if I, you know, clear is obviously going to succeed and then compile, it might succeed

or not.

Then I’m going to try to run main.

Let me actually, let me actually do that real fast.

Let me show you what I’m talking about.

I’m going to remove main.

You’re okay.

So then I’m going to do clear and compile and main.

So obviously if everything works, then everything works.

But if I do that again, where something is not actually going to compile, like maybe

the second the c source program is not going to compile by putting some z’s in there then the

dot main or yeah that part shouldn’t get executed so it won’t try to execute our program

notice how it just stops so that’s convenient if i do it again though with a different command

if i chain instead of between the commands instead of putting and end to say one must execute before

semicolon then they will all execute no matter whether whether they succeeded or not maybe in

certain things you’re doing you actually want that behavior but in this case it’s going to be bad

watch what happens it fails to compile and then at the end it also tries to run a program that

doesn’t exist because it never got linked because the script stopped so i’m just letting you know

you have lots of different options when you’re writing these scripts we do it again and then let

And I think, well, maybe there’s one other thing I want you to know.

Sometimes these lines get really, really long, right?

And it’s messy and irritating.

At least for me.

Maybe if it goes off the side of the screen for you, it’s like, oh, that’s awful.

You can actually just separate a command across multiple lines with a backslash.

Or sorry, I think that is called a forward slash.

It’s the drive slash.

I don’t remember forward slash backslash.

I just say web slash and drive slash.

So I’m going to do G++ and do a little slash.

Then I can put the whole rest of the thing on the next line.

If I wanted to, I could start separating these out by category.

So maybe I’m like, oh, I don’t know.

Maybe M64 on its own line.

And then I’ll keep these other two on their own line.

And maybe these two on their own line.

You know, it’s up to you how you organize this.

And then I’ll say, give me all the input files on its own line.

And then the output file on another line.

on another line you could even put the or bars for the die part on its own line I

guess I’ll just try that and now let’s just make sure that this still compiles

let me remove star dot o and remove main it’s not there okay so clear and then

list and then two showed up somewhere oh my mistake I probably should have caught

some file got saved as a two I should have noticed okay so let’s do clear and

compile and I just run main okay so now everything works notice how even though

everything was on a different line it all just seemed to work cool what about

something here on line 38 we’re using the C++23 standard but we’re also doing

that up here and we’re also using the all warnings flag up here and down here

and pedantic also and even the linker like what if I want to put all warnings

into the linker we could make variables in bash and by the way this is totally

starting to become a job for for mark for make files but for now we’re just

stay in bash so I can make a variable in bash I can say maybe GCC flags name it something and I’ll

just put equals whatever and I’ll just type the stuff that I know is going to appear in every

single invocation of G++ or GCC so I’m going to go wall because I want to put that everywhere

and I’m going to say C++23 because I’m going to put that everywhere and probably pedantic I’m

I’m not going to put the dash C flag everywhere because notice how I’m only putting that on the compiler commands when I just want to make an object file.

But when I’m linking, there’s no dash C because that means you got to actually link.

So let’s see.

We got G dwarf two, G dwarf two.

Maybe I could put G dwarf two there and see if it still works.

So I want debugging symbols and I want them to be in dwarf dash two format, which honestly is the default format.

which honestly is the default format if you just put dash G.

Let’s see if I can get away with that for now.

So I’m going to go GCC flags.

And here I can get rid of C++23 and wall and pedantic.

And I’ll just insert instead GCC flags.

And if you want to be extra careful,

you can put these little braces around the variable name of that.

Probably should be fine.

But because I don’t want to type that again,

I’m just going to copy paste it into the other command.

So wall pedantic, just paste that.

Just paste that and then I’m going to leave it alone for Yasm because Yasm is different than GCC.

And then here I’m going to do another line where I just kind of put the flags.

That means I can get rid of those two flags.

And then wall and pedantic are going to show up.

No pi is kind of a linker only thing.

So is the no exec stack.

I think probably that will be okay.

Let’s see if I got that right or wrong.

Oh no.

Unrecognized command line option.

Wall pedantic GCC.

Oh, I guess because I quoted it.

I shouldn’t have done that.

Because I quoted it, the command line thought that that was all one argument.

I should have remembered.

So I’m going to unquote it right now.

This should help the command line understand that all of the things inside of that variable,

the GCC flags, are separate arguments instead of just one argument.

Let me try one more time.

Yay, it seems to work.

Okay, we got a warning here.

Command line option C++23 is valid for object,

but not for C.

Okay, so basically I made the mistake

of trying to send a C++ object,

which is this right here, or sorry,

a C++ argument, which is this right here,

into a C compiling command.

Not great.

So what if I did this?

I’ll do C flags, and it will contain only flags for C,

for C and then I’ll have another one for C++ flags

which will only contain things that are for C++ compiling so the regular C compiling can take

wall and pedantic okay and then it can take the G dwarf 2 okay the C++ flags it can take everything

except for um sorry the C++ flags can actually take all of the C flags and then additionally the

and then additionally the the c++ 23 flag so i could embed a variable inside of itself i could

say c flags or sorry i could embed a variable inside of another variable so that i can just

steal all of the flags from the c flags variable stick them also in the c++ flags variable and

then just add one more at the end of that hopefully that works i think it probably will

here and then use the C flags here just for compiling I could probably name the

variable better put the word compile in there or something but I don’t really

want to I think some people put CC to mean like C compiling but I don’t know I

just want to do it this way so we have that and then we’re gonna do CPP flags

like this we could also organize the variables differently so that the we

We could have some linker flags, which basically would probably have all of this stuff minus dash C.

And then we could have linking flags.

No, we can have linking flags that has all that stuff minus the C.

And then we’ll have like some compiler flags that has the linking flags plus the dash C.

But I don’t really want to spend a bunch of time on this now.

For now, we’ll just say we have C flags and CPP flags.

And we’ll just manually add that dash C.

But of course, keep in mind, you can organize these things any way you want.

and organize these things any way you want.

So I’m gonna do,

well, this might actually work.

I’m getting distracted.

I think it works.

Okay.

Let me just double check by removing all the object files.

There’s a two in there still.

Let’s debug that if it happens again,

then I’m gonna remove main.

Okay, then I’m just gonna list everything real fast.

Okay, let’s see.

Is there gonna be a two in there now?

Is there going to be a two in there now?

No, is that only when it fails?

Only when something fails to compile?

I mean, it’s working, so that’s good news.

You know what?

Leave a comment somewhere letting me know

where you think I went wrong with this two,

and maybe I’ll release another video

or something in the future,

at some distant point in the future.

But yeah, anyway, I hope you learned a lot of stuff

in this video and you had a little bit of fun too.

had a little bit of fun too. This has been, you know, a little intro for compiling, linking

and executing in Linux, but also probably on a bunch of other systems if you have these

same tools, and you’re working inside of bash. Thank you so much for watching this video.

I’ll see you in the next one.

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

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 could troll me if you want to just wake me up in the middle

And I just subscribe and then 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

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 uh uh 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

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 Compile, Link, Execute: A Beginner’s Guide to Linux Programming with C++, C, and Assembly appeared first on NeuralLantern.com.

Tired of typing endless compile commands? Join me in this fun, hands-on guide to mastering GNU Make! We’ll walk through creating a Makefile to simplify your coding builds, covering C++, C, and assembly projects. Learn how to set up variables, define functions, manage dependencies, and organize build directories to cut compile times drastically. From practical tips like using clean targets to advanced tricks like dynamic variable assignments, this video has it all. Whether you’re a beginner or a seasoned coder, you’ll see how Makefiles can transform your workflow. Plus, I share a real story of turning a 1-hour build into 1 minute! Subscribe for more coding tutorials, and let me know how Makefiles change your game. Scan the QR code for more resources!

Introduction to Make Files 00:00:00
What is a Build System 00:00:11
Problems with Manual Compilation 00:00:16
Using Scripts vs Build Systems 00:00:36
Benefits of Make Build System 00:00:56
Personal Experience with Build Times 00:01:15
Creating Sample Source Files 00:02:20
Installing Make Build System 00:04:56
Creating a Makefile 00:06:02
Defining Functions in Makefile 00:06:46
Calling Functions and Variables 00:07:13
Setting Up Compiler Variables 00:10:51
Dynamic vs Static Variable Assignment 00:11:56
Compiler and Linker Flags 00:12:44
Setting Up Build Paths 00:19:16
Printing Variables for Debugging 00:21:24
Understanding Targets in Make 00:25:10
Dependency Graph and Compilation 01:02:04
Managing Build Directory 01:03:11
Creating Binary Target 01:05:44
Handling Object Files 01:11:29
Running the Program 01:13:16
Clean Target for Cleanup 01:17:00
Advanced Build System Features 01:22:46
Git Ignore for Build Files 01:24:34
Conclusion and Call to Action 01:25:08

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

Hey there, let’s talk about using make files and the make build system.

So what’s a build system? It’s basically just a program that helps you compile your program.

In a previous video, I talked about the idea that it’s really cumbersome

to type out build commands, you know, compiling commands, linking commands and so forth for your

cumbersome and you’ll forget everything that you’re supposed to be doing. So the next upgrade

from that was in a previous video I talked about let’s take all the commands and put them into a

script so that we don’t really have to remember all the commands. We can just, you know, create

a build script and then just kind of run it when we want a program to compile and link and execute.

But then the thing is about a script is if you have a very, very large program,

it might take a very long time to compile. So a build system will take care of that for you.

care of that for you the build system that i’m about to show you the make build system

it can carefully calculate which source code files you’ve actually changed since the last

time that you built your program and it will only rebuild the source code files

that actually need to be rebuilt you know into their corresponding object files and such

so for as a personal example long time ago before i learned how to use build systems i had a giant

And every single little change that I made, I would just have to wait for like an hour.

Like I’d have to go get a sandwich or go do something else or work on a different project for an hour.

Then come back and see if my changes actually affected anything.

Somewhat quickly, I got irritated enough that I looked into build systems.

And I realized that make, the one that I’m showing you today, is pretty easy.

It goes really, really far, but it’s pretty easy to get started.

And it drastically reduced my compile times.

set up, you know, the make file and everything so that I let the build system do the building.

My build only took like a minute. So I could do like a quick change and then just wait one minute

to see the results and then another quick change and so forth. Okay. So if you look at the screen

here, I’m sitting here on a blank desktop. Hopefully I’m recording everything. Am I?

I’m sitting on a blank page here. So let me just make a couple of source code files. This is not

This is not a tutorial for C++ or assembly or anything.

I’m just going to copy paste a couple of sample programs in here real fast.

So I’m creating a C++ source code file.

I’m calling it first.cpp and it’s going to call functions from other source code files.

This is going to be a hybrid program.

Again, don’t really worry about this.

My other videos already explained hybrid programs and so forth.

I’m just going to show you how to use the make build system.

the make build system.

So let’s make another source code file called second dot C.

And then another one called third dot ASM.

So I’m linking a I’m linking three source.

Whoops, that’s wrong.

I’m linking three source code files.

And they’re all in different languages just to prove to you that this will work

with a hybrid program.

And so you can kind of see I’ve got first, second and third.

The first one is C++.

The second one is just C.

Third one is assembly.

If I look at it real fast, get ready to pause the video.

real fast get ready to pause the video then you can see that it’s C++ and if we look at the second

one it’s just C and if we look at the third one it’s just a very simple assembly program and they

just sort of say hello and that’s it okay so you know at this point in my other video I would have

made a compile script I’d say nano compile and then I’d stick a bunch of compile commands inside

of it let’s see do I even have that from last time let me see if I got it if I have it I’ll

I got it if I have it I’ll just paste it real fast just to show you compile I don’t think I’ve

got it although I do okay I’m just gonna paste it in here and it’s not the point of this video check

my other video if you want to kind of understand everything that’s going on in here but it’s just

a script so I’m gonna go compile clear and then list and then in the last video I just said let’s

and it compiles everything and it links the binary and then I can run main which is my binary and then

it just runs this program so it’s no problem it seems okay but again imagine that your program is

huge many many lines of source code in every single file and many many many source code files

and perhaps you’re pulling in libraries and shared objects and just like you know a bunch of other

stuff your your your building could slow down drastically so I’m going to remove the compiler

the compiler script and then I’m going to manually remove all the compiled

object files. Got to be careful with this. Remove the binary. Okay. So now I’ve got

that one, two, three. Okay. Now I’m ready to set up a make file. So I guess first

you probably should have the make build system installed. If you’re if you’re

learning about C++ and assembly you probably already do but just just so you

know it’s a it’s gonna show up in Ubuntu as the build essentials package so

So sudo apt install build essentials.

I can’t remember if this is plural or not.

It’s either build essentials or build essential.

You can do an apt search or a DNF search depending on your system.

We can do build essential and see what shows up.

So I’m just going to go to the top build essential.

Okay, so it was singular, not plural.

I have it installed already.

Let’s see.

If you just want to install make by itself, you can probably do apt search.

search, just make and go up to the Ms.

You can see right here.

It’s just pseudo apt install.

Make is all you really have to do to get the whole make build system.

They’ve got a website, you know, search for Gnu make.

I’m going to type it on the screen here.

Gnu make search for that.

You’ll get a nice website with a bunch

of documentation and examples that go way beyond this video.

But I’m just going to show you the basics so you can get started.

So the first thing you should do is create a file called make file.

create a file called make file. I think under lowercase m is supported but I usually do uppercase

m which is obviously supported because I always do it and what you’re really going to do is you’re

just going to create an empty file call it make file and then inside of the make file you’re just

going to give make a bunch of commands and things that you want it to do and then later when you’re

actually ready to compile you’ll just type make as a command and then give make an instruction and

have lots of instructions and targets available inside of the make file for

make to grab onto. Okay, so moving on. The first thing I want to show you is how to

define a function in make. You probably won’t do this a lot, but for me I kind of

like to print, you know, pretty messages and sort of like do repetitive tasks in a

function. So when you want to define a function you just use the keyword define

and then you name the function. So I’m gonna make a function called say which I

see what it’s for I know it’s silly define say and then I’m going to tab here and then I’m going to

tell it to print some information I’ll just put test info for now the thing about calling functions

is you usually put a dollar sign and then an open parenthesis and then the name of the function and

then after that arguments to the function so here you can see actually let me get line numbers up

here on nano you can see online too I am calling a function called info it’s a built-in system

it’s a built-in system function you don’t have to define it yourself and I’m

telling it I want you to print some info to the screen and I want you to print

test info to the screen and that’s it so in my make file I can just call that

right away with call you know dollar sign parentheses and then the keyword

call and then name the function that I want to call closing parentheses and

then if the function takes arguments I put a comma and then just start

providing the argument so I’ll just say hello what’s up actually this shouldn’t

up. Actually, this shouldn’t take my arguments right now. We’ll upgrade it in a second. But

so this is a very simple makefile. It doesn’t actually have any targets. It will just simply

do things. This kind of stuff is useful. At the very top of your makefile later, we’re going to

define like a bunch of variables. And sometimes it’s nice to print them out. So I just want to

show you how to start printing so that maybe if your makefile isn’t working, you’ll realize that,

oh, that variable is wrong because you printed everything when it started up. You don’t have to

You don’t have to do it that way.

I just like to.

So how do you invoke the make file?

We just literally type make.

And because we named the make file, make file,

the make program will automatically figure out

where it is and go find it and load it.

But you can specify the name of a make file

if you really want to.

I think it’s the dash F switch.

Actually, let me look it up just to be sure.

I’m gonna go man make and just go down a second here.

Yeah.

So this switch right here,

here dash f and then specify the file name or file path or dash dash file and then specify the name

or path that’s how you could use a non-standard make file but almost no one does that everyone

just likes to to name it this way and then just type make so if i type make notice how the first

thing it does is it says test info which is what i told it to do in that function which i called

and then it says no targets gotta stop because we didn’t add any targets yet okay by the way if

about what I’m even doing this for like compiling and whatever go see my other

videos where we talk about compiling and linking and all that stuff this is just

to make things a lot more easy and powerful so let’s upgrade this save

function and I’m just gonna put some brackets and I’m gonna say my super cool

make how about like builder I guess and then instead of test info I’m gonna put

dollar sign one which basically is gonna tell this function you know when I call

say, then the dollar sign one variable is going to show up as the first argument that I provided.

So now when I call say, it should have hello, what’s up as the first argument that goes into

the function. So that means it should print my super cool builder and then the message that I

had it print. One more time, notice how it says my super cool builder. Hello, what’s up, I just like

to do it this way, because then it’s easier for me to differentiate messages that the build system

itself from the actual make file and messages that maybe the tools I’m calling on are giving like GCC or whatever

So let’s edit this a little bit more

The second thing I would like to do is well, maybe I’ll change this to just you know now running or something

Now let’s set up some variables. I’m gonna do like a little thing here. I’m gonna say variables

Put a bunch of comments in make files comments are just hashes

So, you know, this, these lines right here don’t really do anything, 9, 10, 11.

And I’m going to start setting up some variables for my compilers.

So again, actually compiling is in a different video.

We assume right now that you already know how to do it.

So I’m going to say, let’s do some variables for compilers.

You don’t have to do it this way, but the standard convention for naming a regular C

compilers or GCC seems to be just CC as the variable name.

So I’m saying a variable named CC is going to be equal to GCC.

to be equal to GCC and then from this point forward every time I use the variable CC in my

script in my makefile it’s actually going to be like typing GCC and you know if you don’t understand

why you would use variables you probably need to learn how to code a little bit more but basically

it makes everything more powerful instead of typing GCC everywhere and then maybe later if I

want to change it I have to go change it in a million places now I can just change it in one

place and so it’s more powerful let’s do the same thing for the C++ compiler I’m going to say G++

compiler I’m gonna say G++ same thing for my Yasm assembler I’m gonna say

we’re using Yasm also notice how when I assign variables I’m not just using an

equality or an assignment operator I’m not just doing equals that is a little

bit different of a way to assign you can do that but if you just put an

assignment operator by itself just like the equal then if you later change

depends on on the right side, like another variable, then it will update on the left

side. So it’s like, it’s not really a permanent assignment. It’s more like a dynamic assignment.

So, you know, if you want to make sure that the variable has a fixed value that doesn’t change,

even if you start changing variables that it depends on, then use colon equal. I’ll just leave it at that for now.

Not super important. You can also tab and, you know, kind of line things up and it’s no problem.

just to make things look nicer.

So now let’s set up some flags for C and C++ and YASM.

So I’m going to create a variable called ccflags,

do the same thing again where I do the colon assignment operator.

I’m just going to give it some flags.

I want it to show me all warnings,

and I want it to be pedantic about its warnings,

and I want it to generate debug symbols.

build system we want to try to compile source code files into object files first

and then at a different stage link the object files together we we don’t want

to just compile everything in one fell swoop directly to a binary in one line

because we wouldn’t really be leveraging the power of the build system in a

moment I’m going to draw a diagram that tries to make this a little more clear

for now I’m just typing up variables so just bear with me when I’m you know

Cpp flags.

So for C++, I’m actually going to reuse a variable here.

I’m going to reuse the CC flags because all the flags

above are fine for C++ as well as C.

So that means like in my C++ compilation,

I want all warnings and I want it to be pedantic and I want to generate debug

symbols, but in C++, we’ll specify the C++ standard.

So C++ 23.

kind of already leveraging variables against other variables to save typing and make things a little

bit more module. If I decided that all my C was not going to show warnings or was going to convert

all warnings into errors or, you know, use a different flag or something, all I’d have to do

is change it in one spot, line 20 and line 21 would automatically get updated. Also keep in mind

because like I said before, we have this colon assignment operator here going on the right side.

value of cc flags then it would be reflected if i didn’t use um the assignment operator you know

what let’s let’s just do it let’s just do it real fast i’m going to say call say i’m going to say

let’s let’s see cpp flags is and then i’m just going to print cpp flags you print variables kind

of the same way that you call functions you just put a dollar sign and then surround the variable

name in a set of parentheses and that’s pretty much it so i’m going to copy this line a couple

And in between CPP flags, actually let’s do CC flags.

We’ll assign CC flags to something.

I’ll say hello test.

And right now the way CPP flags is written, the assignment kind of sticks.

It’s like permanent fixed.

It doesn’t dynamically depend on CC flags.

So we should see two instances of the exact same message.

Let me open up another window here because I want to keep that editor open.

because I don’t I want to keep that editor open so we’ll do a make and notice how when it prints

the CPP flags they’re the same it’s the same both times even though I changed CC flags in between

those two messages on the other hand if I don’t put that to colon if I just put a sign then now

it is dynamic notice how the second message uses the modified version of cc flags so keep that in

So keep that in mind if you want a variable to be able to change anytime you depend on

anytime a dependent variable that it depends on changes you’ll assign one way and if you

don’t want it to change you’ll assign it another way okay so that’s enough of that I’m going to

take away that message and I’m going to change this back to non-dynamic okay then we’ll do the

same thing for assembly assembly flags this is going to be the Yasm compiler I’m going to tell

I’m going to tell it that I want ELF 64.

I want a 64 bit executable.

I want to dwarf to debug symbols.

I think in Yasm you have to specify the type of symbol.

I think I can’t remember if you actually need to.

So you could try just, you know, dash G if you want.

It may or may not work.

But I always just like to specify at least for assembly.

So then let’s do some linker flags.

Okay, so link flags, you know, what is the linking stage?

What’s going to happen in a hybrid program?

You know, for me, it’s just going to be the G plus plus GCC linker.

So that means I’m going to do all the CPP flags because I want wall and pedantic and

debug symbols and I want the C plus plus standard set and all that stuff.

Whatever you want to do is fine.

And then I want to just specify.

I don’t think you have to do this on modern systems, but I’m going to specify I want to link a 64-bit executable

And then I have to specify no pi

Which I think is kind of an Ubuntu thing your program probably won’t run if you don’t do this

So just trust me for now put no pi in the linking stage and then we’ll do another flag called no exec stack

Which is also a somewhat new thing which prevents

stack which means you might be less hackable not sure if it’s how safe it really is but you know

probably improves the safety a little bit uh let’s see at the last minute okay so now uh

now that i’ve set up the link flags uh i need to like add on the dash c flag for the actual

compiler flags because uh you know if if you know this from my previous videos if you’re going to

compile to an object file and not directly link everything right away you need to add the dash c

away you need to add the dash c flag to let the compiler know oh i just want to compile to an

object file and then later i’ll come along and link so i’m going to go cpp flags is equal to

and i’m going to say equal to itself and then just add a dash c at the end of it and then we’ll do

cc flags and then it’s going to equal to itself with just a dash c at the end of it so

I had CPP flags on line 21 equal to just this basic thing.

And then I reused CPP flags for the link flags,

which means if the link flags didn’t use that colon,

I would basically have ruined the link flags variable by the time I went down

here and changed it. So you don’t have to organize your make file this way.

You can actually hard code a lot more stuff into the variables.

I just like to try to be more dynamic. It’s more fun.

up all the basic variables for the compiler let’s set up some variables for paths so i’m

going to set up paths here so what do i mean by paths you know this is a build system it’s got to

know where things are right so for starters you probably want to name your binary you know the

executable file so i’m just going to make mine main you can make anything you want like my program or

whatever but you know for mine it’s going to be main and then i’m going to set up another variable

going to set up another variable that depends on it so I’m going to say the actual binary path is

just going to be you know this main meaning the current directory and main also you know most it

seems like most make files have it set up so that all of the intermediate files like the the object

files and the binary they get built in the current source directory you know like the root of the

Sometimes also I like to just make a build directory.

So it’s really, really easy to just kind of clean everything out.

You just delete the build directory and you don’t have to worry about the repository getting

super cluttered with object files in the meantime.

So I’m going to name a build directory here.

I’m going to say build directory name is build.

And then so you can imagine there’s going to be a folder here now named build that shows

up whenever, well, I’m going to add more targets later when I actually start building.

when I actually start building, we’re still just naming things.

So then I’m going to name the actual build directory as the current directory slash and then build dir name.

Okay.

So that means the bin shouldn’t just be in the current directory.

It should be in the build dir and then a slash.

And then instead of typing main, actually, I should probably reuse that variable.

So let’s do bin name.

And again, reusing variables is really, really good because it just saves you work.

I can change things in less places when I leverage variables more.

If I had the word main written down all over the program, I’d have to change that in every

single spot of the make file if I wanted to change main to something else.

But in this case, I only have to change it in one spot.

Okay, so now maybe it’s probably a good idea at this point to start printing out what we’ve

done.

So I’m going to do a bunch of, you know, calls to print things.

you know calls to print things print everything out just for double checking ourselves

okay how can i do that i’m going to do that with a call uh the uh say you could also just do uh info

and then you know something like that like we did up above in the save function if you want a less

fancier build system but i like doing it this way so i’m going to say what um let’s do cc uh

CC and I’ll just put maybe like a quality operator or something and then

I’ll just print out what I put for CC and I’ll just start duplicating this

line a few times and I’ll say I’ll just print out everything that I added as a

variable CPP and then ASM type ASM and this just kind of you know it just kind

typed something in incorrectly might take me a while to figure that out but if

I print it all out at the beginning of the of the make file running that I can

just visually inspect what the variables actually contain so let’s do CPP flags

and then we’ll do CC flags

SM flags.

And then we’ll do one more.

It’s going to be probably, oh, link flags.

There we go.

So link flags.

Bringing out a lot of stuff here.

Then I can print the directories, I guess.

So maybe I’ll duplicate this a few more times.

I want to do builder.

The build directory, just so I know where it is.

and I can verify that it’s like a real path.

Builder, maybe I’ll duplicate this one more time

so that I can see the absolute path

to the build directory.

Just for my own information,

because sometimes if you get it wrong,

this is another way to kind of see what’s going on.

So there’s a function in make that’s built in.

You pretty much just say dollar

and the name of the function is abspath.

path and whatever you put inside of it it’ll try to give you the absolute path of that thing

so i’m just telling it now that i want to print the absolute path of the build directory

by the way um you probably don’t want to convert all of your variables to absolute paths because

make has a huge problem with spaces in paths and file names so keep it relative unless you’re just

going to print something um you’ll find out the hard way i mean feel free to try it and prove to

yourself it’s not a good idea um but i found it the hard way many times because i kept forgetting

I kept forgetting. So then we’ll just do the binary, I guess. Okay. Yeah. We’ll do one more

for the binary. It’s going to go there and maybe I’ll duplicate this so that I can say

what the absolute path is. Okay. Abs path. And then if I screw this up, I’ll just look up the

I’m going to do clear and make so I can just see what it’s going to print.

And let me just double check here.

Okay.

So everything looks good there.

Looks good there.

Looks pretty good.

Absolute path to the builder is my stuff.

All right.

Okay.

So seems good so far.

I’m just going to leave that in there because it’ll be easy to double check it.

And now we’re going to do targets.

So what is the target in the make build system?

in the make build system a target is just something that you might want to create or or

or build or compile or something targets are not only for uh building uh executables or object

files or you know something that you make targets sometimes can just be called they’re called phony

targets but you can just call a target and it will execute a bunch of commands within that target

even though it’s not building something specific that is needed so you can use make files to do a

really powerful stuff. Let me show you first off, we’ll do a we’ll do a target. I’ve already

prepared something up here. I’m just gonna I’m just gonna copy paste it here because it’s going

to take a long time to type if I don’t. So here’s a target. An example of a target is okay, I’m going

to name the target the target menu and I’m gonna put a colon. So now later I can type make menu

and what will happen is it’ll execute all those commands that are listed below. Each command

is really just going to be a shell command.

You have to use tab to indent for the command itself.

Notice how I have a bunch of echo statements

and then I’m just like printing stuff, right?

So this whole target, it doesn’t actually build anything,

but it will print a menu to the screen for me,

which is pretty convenient.

When you’re not actually building something,

like you’re not building the executable

that the target doesn’t name an executable,

then it’s called a phony target.

And you want to name it as a phony target

phony target with this line 67 down here because if you don’t the build system might actually

eventually end up getting confused between a fake target and something that might be sitting on your

file system like if i accidentally put a file named menu on my file system at the root of my

repository then make might get confused and think well i see the file so therefore i don’t need to

build it and then the menu will never show up again so this way i’m saying this is a phony target

at the file system it’ll just always execute that target for me so this is the basics of a target

you just name a target put a colon and then every line under that is a shell command that you wanted

to execute so let me just show you that real fast we save to be sure so we’re going to do clear and

actually the absolute paths are starting to bother me let me get rid of them right now

head before I made this video. Okay, and we can just sort of trim the fat a little bit. So I’m

going to do clear and make. And notice how the menu target just ran by itself already.

The convenient thing about make files is the first target that shows up is going to be known

as the default target and it will just get executed automatically if you don’t specify

what to execute. So notice how I just typed make by itself and I didn’t actually specify a target.

I could specify make menu and the same exact thing happens.

Notice how I said make menu, the menu shows up again.

But if you don’t specify anything,

then it’ll always execute the first found target.

And just to prove that to you right here,

I’ll do maybe I’ll do like a different target

and I’ll just call it hello.

And I’ll just have it echo hello.

So now if we just execute make with no arguments,

notice how it just prints hello.

if I want the menu again, I got to go make menu.

Right? Okay. So I’m going to, I’m going to set the menu back to the default target.

Another thing that sometimes people do is they’ll just make a target called default.

I guess I’ll do that here, make a target called default. And they’ll say that the

default target depends on whatever they want to actually run. And you don’t even need to

call it default. You can call it hello or anything that you want. So, you know,

put to lead default just so you know that this is not a standard system name that’s expected so

the default target it’s just the name of the target then a colon and instead of putting shell

commands underneath i could put dependencies on the right so now i’m saying that the default target

depends on the menu target which means in the make build system first what it’s going to do is it’s

going to go check to make sure that main or sorry menu is satisfied because menu is actually a fake

Because menu is actually a fake, you know, a phony target, it’s always going to get executed.

And then when it’s finished and laDefault realizes, okay, all of my dependencies are satisfied now,

then laDefault is going to execute and it’s actually going to end up doing nothing.

I mean, we could put some commands under here if we want.

I’ll put the word nothing.

And just to prove to you that menu will get executed first because it’s a dependency of laDefault.

And then finally laDefault will execute its commands and print the word nothing.

execute its commands and print the word nothing.

Let’s do that and then I’ll erase the echo command there.

So we’ll do clear and make.

Notice how the menu got printed first

because it was a dependency of the default

and the default is the default target.

And then after the dependencies were satisfied,

then the default did its thing and printed nothing.

But so let’s get rid of that.

And now it’s just like when you do make with no arguments,

then the menu gets printed.

printed. Okay, so what else can I talk about real fast here? Let’s talk about

silent commands. I’ll put a little comment menu. Let’s talk about silent

commands. You see all these at symbols here? There are a bunch of symbols that

you can use throughout a make file. I’m going to show you just this and a couple

other ones, but basically this means don’t print the command you’re about to

execute, just execute it. So let me show you an example real fast of what I’m

what I’m talking about.

Targets to show silence and non-silent commands,

or a suppressed command, whatever you wanna call it.

Basically not printing the command,

just executing the command.

So I’m gonna name a target silent commands,

and it’s not gonna depend on anything.

So that’s why I’m gonna hit enter here,

just like with menu and unlike the default.

So then I wanna do tab to enter a command

to enter a command and the echo command is going to say hello this is a silent command or a

suppressed command then i’m going to do basically the same thing again but i’m not going to put the

at symbol in front i’m going to say hello this is a non-silent command so what we should see is that

if we exit the silent commands target we should see first this message gets printed on line 75

and then second we see the full command including the echo statement that shows up on line 76 and

on line 76 and then third we should just see the message hello this is a non-silent command

let me oh and then if it’s a phony target meaning it’s not an actual file on the file system

that you expect to be built we have to do phony and phony is actually a target notice how i’m

saying dot phony colon indicating that that it’s a target and we’ll just say that it depends on

and we’ll just name the command that is also a phony or the target that’s also a phony

you can specify all of the phony targets in one line if you really want to but for me that kind

of feels messy and you’re allowed to like add add add dependencies so notice on line 70 i’m adding

menu as a phony target and then on line 77 i’m adding silent commands as a phony target

the way you do it is up to you but i like to do it this way so i’m going to do silent commands

and then I’m going to do make silent commands.

So now we’re actually going to execute the silent commands target

so we wouldn’t see a menu.

And then we’ll see an example of the silent commands.

Notice how the first one that says,

hello, this is a silent command.

The actual echo command is nowhere to be found

because that whole line was muted

and only the output of executing the command gets shown to you.

But for the second one,

remember we did not put the at symbol on the second command.

So the whole entire command gets printed.

the whole entire command gets printed echo and then quote this is a non-silent command and then

that command gets executed and here’s the result it’s the same string except just without the echo

so you know this line right here is this is the command that we’re about to execute whoops

this is the command we’re about to execute and then the last line is this is the result of

executing that command why would you want to print your commands kind of useful sometimes to see the

compiler statements that show up there have been a few times or more than a few times in my life

times in my life where I was running a make file and just kind of watching it and it was printing

out all the commands that it was executing and then I realized oh my god that’s wrong because

it was printing and I was able to fix that so you know you don’t have to print your commands but

you probably want to so let’s see what else can we do okay so here’s another thing that I want to

show you how to ignore failures so sometimes if you’re compiling your source code won’t compile

So then that means the compilation command failed.

Or if you want to do any command in general,

and for some reason it returns false or it fails,

then that’s considered a failed command.

The make build system will stop execution of any target

as soon as it encounters a failure.

It’s kind of a good thing.

What if you had a huge complicated target,

which you can do it this way.

I’ve done it this way before.

What if you had a huge complicated target,

which not only builds everything,

but then also tries to deploy it to your remote server?

deploy it to your remote server.

Well, if your program fails to build, you probably don’t want the deployment part to

execute.

So you would hope that it would stop as soon as something failed to compile.

Right.

So we should try to know the difference between failed commands stopping the make build system

and failed commands being ignored by the build system and just continuing.

So we can do it both ways.

So I’m just going to do a little comment here.

or ignoring failures and then i’m going to do ignore failures so that’s a target no dependencies

and i’m just going to do false false twice in bash if you just you know do a false

then it will be interpreted as a failure um so you know if i put true here it will be interpreted

as true and this is not necessarily a make file thing this is a bash thing just like the command

just like the command line. Let me show you real fast just just to prove it. I’m gonna prove it to

you. Okay, so hopefully you remember if you can do echo dollar sign question, it’ll tell you the

return code of the last command that you executed. So if I type echo hello, and then as another

command, I echo the return code of the previous command. Now it’s going to basically tell me

echo and then it’s going to tell me whether or not echo succeeded. You see a zero indicating

succeeded it would be really weird if it didn’t succeed but you know whatever now i can modify

this command just to type in some random stuff like what if i type in this notice how the second

part the echo return code part echoes a 127 anything but a zero is considered a failure

usually so it’s telling me 127 and that’s sometimes a standard code meaning something

wasn’t found i could also just do true and that should give me a zero because you know in bash it

bash it understands boolean so it’s like true success that’s a return code of zero it’s weird

but that’s what it is if i return if i execute false then the return code should at least not

be zero it’s probably going to be a one yeah there we go so just letting you know if we just

execute the statement false by itself or true by itself then that’s telling us

um that’s sort of like simulating a failed compile command or something i guess we could put

commands in there if we wanted to but i don’t really want to run the compiler just for this

in the compiler just for this so then I’m gonna do echo this echo statement

should be reached as previous errors which I’m using false to represent should

be ignored so now why how do I know that we’re gonna ignore the errors because I

put the little minus in front of the false notice how before it was either an

at symbol or nothing at the beginning of a command remember the at symbol does

Remember the at symbol does suppression.

The minus symbol says try to run this command,

but if it fails, ignore it,

continue with the recipe for that build target.

You know, recipe meaning all of the commands

that you want it to execute.

So that means the ignore failures target

should actually fail twice and then make it to line 84

where it just prints that message.

Then we’ll do, well, we’ll mark this as a phony target.

practice to try to mark your phony targets i’ve i’ve not done that in the past and eventually

regretted it a few times so then i’m going to do stop on failures is another target and we’re going

to do false whoops no minus because we actually want to stop on failure false and then we’ll do

another echo and we’ll say this echo statement should never be reached as previous errors

false should cause build build termination okay I’m kind of verbose but I hope this explains it

we’ll name this as a phony target too phony you’re a phony failures okay so we can run both these

maybe I’ll put a comment here just to show you it’s two separate things I kind of like doing that

we can run ignore failures and then we can run stop on failures separately to see what happens

Let me get rid of this terminal window.

Okay, so I’m going to do clear and, what was it?

Ignore failures and then stop on failures.

So ignore failures, notice how it prints false

because I forgot to put an at symbol in front of it.

And then the make system itself says,

hey, error, that command failed, error one.

Remember before we had the return code one

when we just typed in false.

me that it received return code one from trying to execute false inside of bash so it detected

that a failure occurred so these two lines go together then the same thing again because i have

two false statements in there and then the last statement says this echo statement should be

reached as previous errors should be ignored because we use the minus symbol i’m having a

hard time selecting text here i gotta i gotta go home and practice my text selection actually wait

So notice how, you know, the minus symbol right there says, let’s ignore.

So now let’s do stop on failures.

Stop on failures.

Notice how the first false showed up as an error to the make build system.

And then make just said, we’re done.

We’re not ignoring this error.

We’re just done.

So keep that in mind.

Anytime you have commands that need to stop the build, if they fail,

build if they fail you should not put a minus in front but anytime you have commands where

everything just needs to be executed even if some stuff fails you want to put a minus in front of

there we’ll talk about a clean target a little bit later which usually you know just continues

even if there’s a failure so we got silent commands ignored commands or ignored failures

and failures that we’re actually going to stop so now we’re going to get into the the meat and

make file it doesn’t really do anything it doesn’t build anything for us I’m just kind of showing you

you know how to work with the make file like the very basics now let’s actually start to build

things so the first thing I’d like to do is I’d like to make a target for the build directory

if you you know again if you just kind of like look at my file system here I don’t actually have

a build directory right so I want to make sure that a build directory exists I could of course

dir and then type build but I want the build system to do this automatically for me and also

as a lesson for what we’re doing so you know be sure the build directory exists so I’m going to

name a target and this is not going to be a phony target I think this is our first non-phony target

right yeah oh I forgot to put la default as a phony might regret that one day the defaults

you is phony and everything’s funny. Okay. So now we have our first real build target. I’m just

going to name the thing that I want to build. And I’m going to name it by typing the build directory

variable. I could type, you know, underscore build or whatever it is that I put for that variable.

What did I put there again? Underscore build. Yeah, I could put that if I wanted to. But again,

try not to hard code things. It’s better to stick things in variables if you can.

So since this is a target, I’m going to put a colon. It doesn’t really depend on anything,

because if we’re just talking about building that folder all we really have to do is execute a command

to just make sure that the folder is created right so i’m going to do no dependencies and

then i’m going to like maybe do a little all say function call just to announce that we’re going

to ensure the build directory a lot of people don’t do this but i’m going to do it ensuring

the builder and now i could put you know what the builder is probably a pretty good idea so that i

probably a pretty good idea so that I can see what I’m trying to ensure let’s

just run that real fast if I say oh shoot I guess I would have to do make

and then name build let’s see if that actually works yeah okay so I’m naming

the build directory you wouldn’t normally actually name the build

directory in the command line but I’m doing it so it says we’re ensuring the

build directory and then now it says the build thing is up to date because the

because the target finished executing,

but nothing actually got created, right?

So what I would like to do before we actually create it

is replace this builder variable with a special variable

that GNU make gives you called $at.

The $at variable, and I’m quoting it,

you don’t have to quote it,

it always ends up being the name of the current build target.

So again, it’s a bad idea to hard code

It’s a bad idea to hard code lots of different values

and it’s way better to put things into a variable.

But at the same time, if you can get away with

hard coding a variable name multiple times

and you can use something more generic,

well then that can also increase the power

of what you’re doing, make things easier for you

and easier for you to debug.

Save yourself some time, right?

Because coding is already hard enough.

So if I do dollar sign at,

it should show up as whatever the builder contains

because that’s the current target.

So let’s run that one more time.

that one more time and we’ll say clear and make build notice how it says ensuring the builder and

then it quoted the current target which is underscore built nice so we got that now let’s

actually run a command to create the directory that’s just going to be you know in linux the

command mkdir to make a directory and again i could put a builder here but it’s probably a

special variable that will change because what if later on i want to change the name of that variable

uh if i did then i’d have to change it in three places now but uh you know and possibly way more

places later down the line but if i use that special you know dollar at symbol then i only

have to change it in one spot okay so mkdir so that basically says it’s going to look to see if

that folder is created if it’s not then it’s going to create it with that command so if i do that

So if I do that, notice how it executed that command and also printed the command.

So it’s like mkdir build.

If we list the directory again, notice how there is a build directory.

Okay.

You go inside of there.

Everything’s fine.

I’m going to remove it real fast.

Whoops.

Okay.

All right.

our make file until it’s somewhat decent it’s not going to be amazing but it’s going to be somewhat

decent okay so we have a target that will build the build directory now let’s make our first real

target that is it’s going to be a phony target but it’s going to it’s going to do something for us

so run the program we’re going to make a target called run and so if you type make run then it

which in my opinion would be building the program first.

Your opinion may vary, but you know, so I’m going to do it this way.

I’m going to say run colon because that’s the name of the target.

And I’m going to say that the run target depends on the build target.

So remember this means that before run can actually execute its steps,

it will go quickly to the build target and execute all the steps in its recipe.

So essentially I’m saying before we try to run, let’s build.

So it depends on build.

By the way, build is not created yet.

We’re going to do that in a second.

not created yet we’re going to do that in a second the only line in this recipe that i’m going to put

is just the name of the binary meaning after build is finished running i can assume that

the entire executable is actually built and it’s ready to run so then i’m just going to run it so

it’s just like first go build it somewhere else and then run it and again indirection and modular

thinking is is a lot more powerful than just sticking all the build commands right inside of

run target and duplicate all those commands for the build target so this is way better and then

i’ll name run as a phony because this is not an actual file i’m trying to build the run the there’s

no file named run then we’ll do the build target build and link the object files and executable

okay and this is where it gets a little funny so we’re going to make a target called build

actually build everything we shouldn’t hard code them here we should treat every source code file

as as one separate thing that needs to be built every corresponding object file that comes from

a source file should be one separate thing that that gets built from the source code that needs

to be used to build i guess is what i should say so what should the build target depend on like

before we can say that build is satisfied.

How about just the executable file itself?

So I’m going to say the bin.

So our main program,

it should be totally built and finished

and set up and created and everything

before we can say build is satisfied.

And then hilariously, once that’s satisfied,

then the build target is totally satisfied too

because it doesn’t really do anything.

It just asks, you know, this is more of a shortcut.

Okay, so now let’s,

Let’s maybe first before we link let’s start writing commands to actually build the source code files. So I’m gonna do

build the first object file

So remember we have three source code files here. We’ve got first dot CPP and

Second dot C and third dot ASM. So that’s just three source code files. They should map to three object files

Let me let me draw this for you for a second before we talk about it further because I want to make sure

that what I’m about to do is crystal clear when we’re talking about like the dependency graph.

Okay. So my mouse is all over the place. I gotta execute a command real fast.

I have many monitors going on right now and the pen just keeps forgetting that it’s only

supposed to be on this one monitor. Okay. So I got that. Okay. So the first thing that we

executable called main.

So I’m just going to draw that on the graph here for you Windows people.

You can imagine there’s a dot exe on the end of it, but in, you know, in Linux and

other link and other operating systems, we don’t really need that.

So main, we want to build that.

That’s the, that’s the primary thing we’re trying to build.

What does it depend on though?

What needs to be built before we can, we can create our executable?

Well, we need to compile every piece of source code into a corresponding

all the object files will be linked together into the executable so maybe i’ll i’ll write

down first what the uh what the source code files are going to be so i’m going to do let’s see first

sorry about my writing i don’t have a smoother right now first dot cpp and i got like a really

small draw pad um i’m i’m making lots of excuses but i think probably my penmanship in real life is

maybe even a little worse i don’t know i was at a job a long time ago and i was taking down

names of customers it was like a tech support center and my boss after he saw the paper that

i was writing down he just looked at me and he went chicken scratches and then he walked away

okay so we have first dot cpp and then we have second this is why i like typing second dot c

okay so we got that and then we’ll have third dot asm so third maybe i should go slower a

At least I’m not making misspellings.

I know these are simple file names, but it could happen.

So we have three source code files.

They don’t really depend on anything because they just are themselves.

We don’t need to build these source code files.

So we’re not going to draw any arrows indicating that these files depend on something else.

They’re kind of like the primary source.

Like these are the things that would actually go into your Git repository,

whereas the object files that we’re going to generate and the executable that we generate,

they would definitely not go into your repository.

your git repository. Okay, so what’s going to happen? First.cpp is going to generate first.o.

We’re going to type that out in a second, but basically first.o. That’s awful. That just looks

disgusting. I’m going to keep it though. Okay, so in order to indicate dependency,

we’re going to draw an arrow from first.o to first.cpp indicating, all right,

if we’re trying to build first.o, then it will look at first.cpp and it’ll check.

check does it exist if it doesn’t then there’s an error if it does exist then then the the the

build system is actually going to check the modification dates of first.o and first.cpp

assuming that a first.o already exists it’s just going to check it’s going to say

does is first.cpp newer than first.o if yes then that means i have to recompile first.o if no i’m

not going to recompile it and i’m going to save a bunch of time this is kind of the heart of why

So same thing for 2nd.0.

2nd.0, I’ll just circle it here, and we’ll say that it depends on 2nd.c.

And then, of course, the 3rd.0 object file, it’s going to depend on 3rd.asm.

So again, notice how they don’t really depend on each other.

Maybe if you have a C++ file, maybe if you have a C++ program that’s really complicated,

maybe your first.o, it would depend on the CPP file,

and it might also depend on some other header files that you have set up somewhere.

So then there would be more circles and more arrows that we draw.

But for now, it’s just a simple program, so I’m just going to leave it this way.

But just keep in mind that when we name dependencies in the make file,

you want to name a dependency of everything that a source file depends on.

So like first.o, it’s definitely going to depend on first.cpp,

includes that are custom or from someone’s library and not the C++ standard libraries,

then you would want to say that first.o depends on those as well. Because if you change

a header that you made elsewhere in the program, then you probably want to recompile

that corresponding object file, right? So just keep that in mind.

Anyway, we’ll do first.o. Okay, so now the executable program main, that needs to be

all the object files so I can just say that it depends on all three object files

with just this right here and this is the basic idea of what we’re about to

type up in the make file itself keep in mind that the make system will actually

build this graph in memory under the hood to try and figure out which things

actually need to be built or not you could even launch make with multiple

threads I’ll probably forget to do it but it’s a things like dash J and then

things like dash j and then the number of threads you want to launch in order to totally saturate

your cpu and have as many things compiling as possibly can be compiled make will figure out

which things don’t actually depend on each other and then build them in separate threads at the

same time so your build system is just like so much faster so let’s see we got uh corresponding

object dial for every source file and then we got the binary that depends on the object notice how

source code file what would happen is when we wanted to build the let’s say we wanted to just

you know this is the the target the binary target that is just named main what will happen is it’ll

look at its dependencies and the way we’re going to write it it’ll say okay it depends on the three

object files if they’re already there and they’re already satisfied then it it won’t actually

if they’re already there and they are all newer than their corresponding source files then none

corresponding source files, then none of them will get rebuilt. If main itself sees that it is newer,

like the existing on disk version of main is newer than all the object files, then that tells the

build system, oh, I don’t actually even need to relink the binary at all because the object files

didn’t change, which means the source code didn’t change. And so you could actually like type make

build and nothing happens because nothing needs to happen. It’s going to be pretty cool. I’ll show

I’ll show you in a moment.

Okay.

So for now, I’m going to try not to erase this.

I’m going to do a toggle.

Do I can, I don’t know if I remember, I think it’s like control.

Let me do the menu here.

I don’t want to screw it up.

Okay.

It would have been control.

Okay.

So I’m going to toggle visibility.

Just get that off there.

Just in case I want to show it to you again later.

So now let’s make the first object file.

So remember the first object file is first.o.

to create a target that will build the object file based on the first source code file.

I’m going to put a colon there to indicate that it’s a target.

And then remember on the right side, we can do dependencies.

Well, we have to say that this depends on the first CPP file.

If we didn’t, then every single time we run the make system,

then this object file is just going to get built over and over and over again,

even if it doesn’t need to.

So now with a dependency there, it’s going to look at first.cpp

and then it’s going to look at first.o if one exists if one doesn’t exist it’ll

definitely build it but if one does exist it’ll go is first.o newer than

first.cpp if it is don’t do anything but if it’s not then rebuild it make sure

it’s fresh here’s the other thing though I kind of wanted to build everything

inside of the of the build folder so I’m gonna add the variable build in front of

it let me do it first without doing that so that you can kind of see what will

So it’s going to depend on first dot CPP.

And then there’s another thing you can do in make files where you can,

I forgot the proper name for this,

but you can specify other types of dependencies where they only need to exist

as a dependency.

They don’t necessarily need to be freshly fully updated because,

you know, the way files and folders work,

if you start adding or removing files from a directory,

then the directory thinks that it’s been updated.

And so that can kind of throw off the build system’s thinking

the build system’s thinking because your build directory will always think that it’s been updated

if anything happens. But we don’t really care about the date of when the build directory was

built. We just want to make sure that it exists, right? So we put a little or bar and we put those

types of dependencies on the right side of the or bar. Okay, maybe I’ll leave a comment or something

at a later date specifying the official name for that, but I mean, that’s how it works.

So that’s the recipe.

It’s got dependencies.

You know, in the past, I’ve said when you name a dependency,

it goes off and make sure that that dependency is resolved.

Well, that’s true for phony targets and targets that sort of do other things.

But in this case, if we’re just naming a file, all it’s going to do is just look

at the modification date of the file.

So now let’s do the recipe.

I’m going to do CPP, which means that’s the C++ compiler.

And I could write, you know, G++ and all the commands here directly

directly if I want to, but it’s kind of a waste of time.

And it’s not, it’s not very smart because we said before, what if you want to change

the flags and you have a hundred objects that you’re building, you probably just want to

be able to change one variable instead of a hundred different things.

So we’ll do CPP flags and then we’ll, let’s see, we’ll take first.cpp as a source.

You can imagine again, this is like, you know, G++ happening inside of here and then wall

inside of here.

and then at some point you specify the source.

Okay, so just keep that in mind.

And then after I specify the source,

I want to specify the output

and the output is going to be first.o.

And now let’s use another trick

which allows us to make slightly more powerful make files.

So again, you want to avoid hard coding stuff if you can.

There’s a special variable.

Well, okay, let’s go back first to the other special variable.

Remember $and, or sorry, $at.

that always refers to the current target right so first.o is the is the current

target so I don’t even have to type first.o here I can just do dollar sign

at there’s another special variable which just basically means the first

dependency that’s been named so if I just do quotes and then I say this it’s

weird I know dollar sign and then angle bracket pointing to the left or like a

typing first dot CPP. If you wanted to send a bunch more stuff, like if you wanted to

send all of the names of all dependencies that you named into the command line, then

you can use the carrot like dollar carrot. That’ll do all of the dependencies. But if

we’re just compiling one source code file, you probably want to just do one dependency.

Like for example, if I had other thing dot HPP as a dependency, I probably wouldn’t want

because then that would be telling the compiler,

here, I want you to compile first.cpp and also other thing.hpp,

which probably wouldn’t work.

It’s probably not what you want.

So instead, if I do this like arrow to the left,

then it will only give it first.cpp rather than both dependencies.

But I guess we’re simple.

We don’t really need all that right now.

So we got that finished.

Let’s see.

We now have the binary.

okay this is only going to run if i do make first dot oh maybe i should do that right now so that

we can we can take more baby steps to making this more complicated so i’ll do here and make

and then i’ll do make first dot o so notice how when i typed first dot o it went right to this

target no problem and then it started to you know it looked at first dot cpp just to see you know

built or not and it it also looked at the build directory as a dependency and

then finally it actually compiled so what we should see right now is first

dot o sitting in the directory and then also we should see the build directory

again let’s just double check that so if I list everything notice how the build

directory exists if I go remove and then remove the build directory and then

clear it again notice how we also have first dot o so I can say remove first

So if we go clear and list everything again, now I’m going to do one more time.

Make first.o and then if I do list, then the first.o got built and the build directory got built.

Notice also that as soon as I ran that command, it did make dir on build.

So it built the build directory.

So that was the build dir target.

And then it went over to the first.o target and it executed that command to actually compile it.

All my variables expanded, so it’s like G++, wall, pedantic, whatever.

That special variable with the arrow pointing to the left was the first source code, or source code file.

And then the $at variable expanded to the current target, which is just first.o.

If we run this again, I’m not going to clear it, I’m just going to go make first.o.

Notice how nothing actually happens.

It’s missing two lines.

Up here we had two lines where we made the build directory

and we also compiled the object file.

But notice how here it just says the object file is up to date.

It did not recompile it because it can tell that the source code was not changed.

Let me go into another directory right here and I’ll just modify the source code file.

I’ll just add an extra line to it and then I’ll go back here.

and if I compile it now we should see that it chooses to compile it again

because now the source code is newer than the object file so if I go make

first notice how it did not build the build directory because it already

existed but it did rebuild the object file because the source code was updated

if I immediately try to build it again it does not need to rebuild it because

the source code didn’t get updated since the last time I built and so it says

it’s up to date up to date sometimes you might see a message that says something

just says something like nothing to do, I think.

So just keep that in mind.

We’re getting a little bit better now.

But I’m also making a mistake here

because we have a build directory

but there’s nothing inside of it.

I wanna put everything inside of my build directory

just to show you how annoying this could be.

Notice how we got a first.cpp and a first.o.

Imagine if you had a million source code files,

you’ll have a million object files

sitting in your repository or your directory

kinda cluttering the place up, right?

cluttering the place up, right? I don’t like it. I’m not a fan. You probably want to edit your

git ignore so that you don’t accidentally put object files into your repo. But for me, I think

it’s better to just ignore, git ignore a build directory, and then just stick everything inside

of the build directory. It’s up to you, but this is the way I’m going to do it. So how do we get

it to be inside of the build directory? First, let me remove the object file. Okay, let’s see,

I think I can get rid of that. That’s responsible for the swap file. We probably want to put

star.swap inside of gitignore so that the temporary files from nano don’t go into our

repository. So now I’m going to prefix this object file. And a lot of people don’t do this,

but I think it’s pretty cool. I’m going to do build dir slash the object. And then now

everything’s going to show up inside of the builder or at least that one. So if I remove

directory just kind of list things again then I can do make first oh and then

notice how it mmm what happened oh what did I do wrong well I did something wrong

okay hang on let me see if I can fix that first oh what in the heck did I do

second and third. Okay, so I didn’t break anything.

First.o. Oh, because when I typed this on the command line, I was typing first.o and

well, that’s not the target anymore. The real target now is underscore build first.o.

So maybe this is a good time to stick our binary target inside of there.

So we have the binary target. I kind of ignored it for a second because I wanted to show you an object file first.

We want to make the main file that gets executed.

We have to link everything together.

So, well, maybe this is a better description down here for that.

And then up here, I’ll say alias for just building the binary.

Whoops.

Binary building.

Building.

There we go.

Okay.

So now we’re actually going to do it.

So we’ll put bin.

So now bin is its own target, meaning our main program that we want to create

main program that we want to create is uh it’s going to happen somehow the uh dependencies that

it needs though should be all of our object files that we intend to create so first you know one of

its dependencies should be uh inside of the builder and i know this is annoying to type these variables

all over the place but kind of the price you pay for having everything outside of the working

directory but i guess that’s why a lot of people don’t do this we say builder first dot o so

So basically saying before we can create the executable, we have to first build the first

object file.

And then we’ll just name more dependencies.

I’ll say the builder, we separate dependencies using spaces.

That’s another reason that make has problems with spaces if you’re going to do like an

absolute path or something.

So then we’re going to grab the second object file as a dependency and then the third object

file as a dependency.

means we just need to set up targets for each one of those object files we only have first.o

set up so far we’ll have to set up the second and the third one so aside from those dependencies we

want to make sure that the builder is actually created so we’ll put builder as another uh you

know non-time stamped uh dependency like we did with the object file then the command we’ll actually

and remember CPP is just GCC and then the link flags is the stuff that we set up up above

which is basically going to be you know wall pedantic G and then M64 no pi no you know all

the stuff we don’t want to type manually at the very bottom so we’re going to do that link flags

you know we want to give it every single object file as an input so we’ll name you know first.o

and then we’ll name second.o second.o and you know i’m getting irritated i hope you can tell

already i don’t want to type all these things so we can use a shell trick we can put a wild card

there we can say how about i just give you every file asterisk that ends in.o so star.o basically

on that command line it’s going to go look into the build directory and just

give it every object file that it sees it’s not a great idea if you have

multiple different executables that you want to make and they’ve all got their

own main functions and they’re all in the same builder but in our case we only

have one executable with one main function so we can just throw all of the

object files we want at it if you had other types of object files you wanted

to link into your executable like for example shared object files you could

object files you could basically do the same thing but just go you know builder star star.so

or maybe not even in the builder if i if let’s say if i gave you a shared object file

and i wanted you to link that into your program you would just specify wherever it was

you know maybe it’s in the root something.so maybe it’s in a different folder um and maybe

you want to create a variable up top to just kind of like name where the shared object files are

libraries are it’s up to you but I’m just letting you know this is how you

would do it to get a shared object file in there as well for this program it’s

very simple we just are gonna grab the object files and that’s it so now we’re

just ready to specify the output file with a dash o and we’ll use that same

trick again dollar sign and at so we don’t have to specify the the full

target which is just going to be the bin variable so let’s see what do I got to

If we run it right now, it should fail because it’ll complain that we don’t have second and third built.

But at least I have enough now to use the make run target.

So we can stop specifying the names of files and just say something like make run or make build and it’s just way easier to type.

So I’m going to type make run.

It’s going to depend on build.

Build is going to execute before run even tries to run.

Build is going to say, well, I depend on the binary, the executable.

Then that means the binary’s target is going to run.

run it’s going to depend on all these object files so before it even tries to do anything

it’s going to go down here to the first dot o object file it’s actually going to build it

then it’s going to come back and try to handle the next dependency which is second dot o

but there’s no target for second dot o and it’s not on disk um so it’s just going to fail at that

point so let’s see if let’s see if i’m right we’re going to do make run clear and whoops

Make run

Okay, so ensuring the build directory. Oh, I forgot to mention that yet

It’s gonna ensure the build directory then it actually builds the first object file so far so good

Then it complains no rule to make the target second auto so we can’t continue Oh

drat

By the way just to show you I think it’s like a J

Let’s say we wanted to launch this with eight threads. I think it might be low

Is it lowercase or uppercase J? I can never remember. Let me try lowercase

second how about uppercase nope okay so it’s lowercase well I guess it just fails right there

I was kind of hoping it would try to spawn off two threads to look at second and also third

at the same time and then fail twice maybe that’s why it didn’t do that because it automatically

saw right away oh we can’t do anything so let’s just cut the whole build process so now I’m going

Cut cut cut paste paste and then I’m going to say build the second object file

So we’re going to depend on seconds

There are actually advanced patterns you can use so that you don’t even have to specify the object files you can

There’s there’s these things that people do I did it a couple times

But I don’t really like it where you can have make sort of scan your source code directory for all CPP files and

Automatically compile them in the exact same way and then the output file is like

And then the output file is like the name of the source code file and then.o concatenated at the end of it.

But this video is not like that advanced, so I’m not going to do that.

So we’re going to compile second.c into second.o.

And we need to make sure the build directory is created.

And instead of using the CPP compiler, we’re going to use the regular C compiler.

And then we’re going to do cc flags right there.

and I think that’s all we need so then we’re gonna do the last object file by

the way in nano I’m going control K to cut and control you to paste and it’s

kind of convenient if you want to like duplicate you know a few lines we’re

gonna use the ASM to assemble the assembly code so I’m gonna do third dot

what it was and then we have to use a totally different command now we have to use the assembly

assembler variable so that’s the name of the tool that assembles and then we’ll give it the assembly

flags i mean i guess it’s not that different and then we’ll say give it the first dependency which

is just the source code and then output to the at target so we should have like a lot of stuff

ready to go let’s see if this works now if i say clear and make run then what is it going to do it

then what is it going to do it the first thing it does is it compiles the second object file

notice how it did not compile the first object file because remember we just compiled that

and we didn’t change the source code so it just ignored it and we have a faster compile

then it assembles aka compiles the assembly to its own object file and then

now that all those object files are satisfied notice how like you know for the binary

all of those object files first and make sure the build directory is there. Then finally it can

execute its own recipe, which is just one command saying, you know, let’s link this stuff together

by grabbing all the object files. So that’s this line right here, the linking flags and the linker.

So it’s like GCC and all the linking flags, the no pie and all that stuff. And it’s expanded that

variable. Remember we put builder slash star dot O. So that glob right there basically says grab

glob right there basically says grab all the object files from the build directory and then

output the main program in the build directory no no i think even if you’re using a build directory

sometimes people will still put their executable in the root i don’t know it’s up to you i don’t

really care finally after all that is done you’ll see let’s see what we actually did is we said let’s

its recipe it goes down here for build and then build says first we need to build that binary

and then binaries like first we got to build the object files and then you know all those

get built finally when the object files are built then the binary gets to link itself

when it’s done linking itself then we go back to this point because now finally the dependencies

on line 108 are satisfied then that means the build target its dependencies are satisfied

dependencies are satisfied. It would execute its recipe, but there’s no recipe there. So it just

goes back to run because in the first place, run said, I need you to make sure that build is handled

before I’ll execute my recipe or all of my statements. So finally, after all that stuff

was done, then it’s just a command line that just names the executable, which is going to run it.

And that’s this last part right here. So right there, it just names the executable using a

using a whoops using a relative path to our main executable so now below that

line the program is actually running it’s like hello from first hello from

second hello from third and watch this if I do make run again nothing happens

except executing the program notice how none of the object files are getting

built the binary is not getting linked nothing is happening because it’s

already done all it does for the run target now is just run the executable

run the executable. It’s the same thing as if we did build main, just to run it. That’s it.

You know, of course, it’s a little more proper to go dot slash, right? You don’t have to use the

dot if the thing you’re naming is in a different directory, but you do if it’s in the same directory.

Like if we just went into the build directory, by the way, here’s all our build files. They’re

in one convenient place. You can do a git ignore on that, or you can just delete the folder if

if you want to clean everything.

But we can’t just type main here, it’s not going to work.

We have to do a dot slash main because we’re in the same folder.

But if we’re one level higher, then we can just name build main and it’ll work.

Okay, so let’s do another thing real fast here.

Let’s do another target that is kind of typical.

It is the clean target.

useful when people have object files just scattered around the root of their of their file system

there their repository but i like to add it in anyway for mine even though mine’s a little bit

cleaner right now so we’ll do another target called clean and we’ll just say clean the uh the

build area system thing stuff and i’m just going to put the word clean with a colon no dependencies

meaning it’ll always run right away and not depend on anything it’s obviously a phony target because

It’s obviously a phony target because I’m not going to make a file called clean so I’m

going to stick that as a dependency to phony.

And then what is it going to do?

Usually this is where you put something like let’s remove star dot o, let’s remove all

of the object files and then let’s remove the binary file and let’s remove anything

that we built so that we can just clean it.

Maybe I could put that here, build dir slash o, I’m going to make it a little bit better

in a second.

inside of the builder and then we’ll also remove the binary.

So when we go back into our file system,

if we list the build directory,

we should see that it’s empty after we run this.

So I’m going to do that right now.

I’m going to do make clean.

And then you can see that these two removal commands got executed.

And then if I list the directory again, notice how it’s empty.

But the remove command will fail

if it tries to remove something that doesn’t exist.

to remove something that doesn’t exist so we’ll actually get like a a nasty message from clean

or from make if we try to clean again so we say make clean it says remove tried to remove object

files but there was nothing inside of there no such file or directory so then it just stops the

whole process well that seems okay for now but what if you uh what if you had gone in and removed or

and that stopped other things from being cleaned you’d probably end up being

pretty frustrated right so for the clean target I’m just gonna say remove is a

command that won’t stop the build or the target so I’m gonna put a minus in

front of there meaning don’t stop if something goes wrong just keep

executing all these commands and so now if we do clear and make clean notice how

it actually tries to remove both types of things it doesn’t just stop on the

I guess this is the first problem.

It’s trying to remove the object files.

Then remove says, no, I can’t do that.

There’s nothing there.

And then make says, I’m ignoring you.

Stop whining.

There is no bathroom.

And then the same thing happens for removing the executable main.

But we can make this actually a little bit more efficient.

I mean, this is kind of what you’ll do if everything is sitting at the root of your repo.

But if we simply have a build directory and you’re absolutely sure that you already have

you know set to the correct value then you could just remove i don’t know if i want to do it now

because i’m getting scared you could just remove the entire build directory i’m going to do it but

i’ll explain to you why i kind of don’t want to do it in a second we could remove the entire build

directory so like with the remove command remove recursively the entire build directory

just so you don’t see it if you feel like it’s an eyesore so i’m going to do make clean

do it again do it again do it again and notice well why wasn’t it

i feel like it should have failed but i guess remove felt like it wasn’t a failure if build

didn’t exist but notice how the builder is gone so i didn’t really have to specify

the object files but it’s a little bit safer i don’t know it depends on your philosophy

this is way more compact and nicer that was my first feeling but it’s also a little more

there into the variables area and i like change the builder somehow i change its name or i change

its value and i accidentally now have this variable pointed to like a dangerous path

and then if i type make clean it just erases everything not sure i really like that idea so

i’m going to do i’m going to go back to the original way which takes more typing

remove every object file and maybe before that let’s remove the binary so if we do

if we do make build which by the way will only build things it won’t run anything remember

the dependency graph that we looked at a little while ago or not the dependency graph that we

explained the dependencies so it does everything required to build but it doesn’t actually run the

program and that’s fine i just wanted to go look inside of the build directory

and you can see it’s got all the stuff there so then if i just run make clean one more time

by the way, if I try to run make clean from here,

there’s no make file in this directory.

So nothing’s going to happen.

So I’m going to go up one level, make clean.

And then if I list the build directory,

there’s just nothing inside of it.

Okay.

All right.

Let me just look at my notes right here.

I just finished building this whole giant make file.

It’s not even like that complicated,

but I hope that you’ve learned a lot

about making make files at this point.

this point i hope you kind of like the idea let me just double check there’s nothing else i wanted

to say for this video oh i should point out that gnu make is not the only build system available

it’s just the one that i like the most um remember you can also put shortcuts in there like any

command line that you could actually type could be part of the recipe of a target it doesn’t have

to only build it doesn’t have to only be build targets so again you could make commands in there

like deploy your executable somewhere or check something or like a long time ago I used to have

a recipe actually it was that program I was talking about at the beginning where I converted

an hour-long compilation to just like a minute I had another target in there called deploy so I’d

say make deploy and what it would do is it would build and if it built then it would run unit tests

on my code and if those succeeded then it would copy my source code to one of my other servers

my other servers then remotely it would tell that other server to build and run tests and if all

that succeeded you know if it didn’t succeed then it would just quit if all that succeeded then it

would shut down the the server that I had written as a running service and then it would copy the

freshly built executable to the right location and then it would restart the service so basically I

just like do a bunch of coding and then I you know run my test if everything seems cool then I go make

five minutes or whatever it took to run all the tests and do another compile and deploy everything

and my server was just totally updated just by that so there’s a lot of stuff you can do but

there are other great build systems out there there’s one called gradle there’s one called

maven there’s other like node.js systems there’s a ton of build systems out there

probably a slightly more popular popular c++ build system is called cmake it’s more tailored to c++

um but you know you obviously don’t need to do it it’s just i think like a little bit easier

depending on what you want to do so keep that in mind this is not the only system there’s a lot

out there to explore but this is this is definitely a great first step um let’s see what else can i do

oh we showed you the diagram showed you the info function and the targets and the dependencies

and the run build well i guess i’m out of stuff to show you that’s that’s all i had written down

that I wanted to show you maybe I could this is not a git video I’ll make you

know I have other videos forget but you know if this is a git repository you

would nano git ignore just because I kept mentioning this we’ll do nano git

ignore and then I’ll just say ignore the build directory and ignore swap files so

I’ll say like ignore the build directory and ignore anything that’s edited and

your git status and git add and git commit and stuff then the build directory wouldn’t even show

up so yeah kind of i guess it’s kind of unnecessary for this project okay i think that concludes this

video assuming i was actually recording this entire time thank you so much for watching i

hope you learned a little bit of stuff and had a little bit of fun i’ll see you in the next video

practice practice practice and start making your own make file videos and let me know

files in your own programs and let me know if you liked the content of this video and like if it

helped you i love receiving emails way after the fact when people say hey i love make files now

and it’s all because of you and i do it all the time because then i get to sit alone in my dark

room and giggle to myself it’s all because of me um okay i think that’s probably a good note to

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 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

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 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 will happen.

Also, 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

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 Master GNU Makefiles: Streamline Coding Builds with C++, C & Assembly appeared first on NeuralLantern.com.

Confused by hexadecimal numbers? Don’t worry! This fun, step-by-step guide makes converting hex to decimal super easy, even for beginners. With clear examples and a chill vibe, you’ll master this computer science skill in no time. Perfect for students, coders, or anyone curious about number systems. Hit subscribe for more coding tutorials, and check out our site for extra resources! #HexToDecimal #CodingForBeginners #ComputerScience #LearnToCode

Introduction to Hexadecimal Conversion 00:00:00
Purpose of Conversion 00:00:11
Number System Basics 00:00:39
Hexadecimal Explanation 00:01:12
Converting Hex to Decimal 00:01:59
First Example Setup 00:02:35
Decimal Place Value Recap 00:03:02
Hexadecimal Place Value 00:05:14
Formula for Conversion 00:05:43
Translating Hex Letters 00:08:17
First Example Calculation 00:09:51
Second Example Introduction 00:11:14
Second Example Conversion 00:11:58
Second Example Result 00:13:11
Conclusion and Call to Action 00:14:00

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 converting hexadecimal to decimal.

So why would you do this? Of course, sometimes in computer science and other realms, you may be

faced with a number that looks like this, and it’s got some letters in there, and it’s weird,

and you’re thinking, oops, not a V. That wouldn’t work. Not a G. And you’re thinking like, what does

what does this number mean in decimal well this is a number that is real and we can just change

the way it’s represented uh to decimal so that we can understand what it is so just like a quick

recap if you haven’t watched my other videos yet uh in decimal we have a base 10 system which just

basically means we have these characters zero one two three four five six seven eight nine there

base is 10. In binary, of course, we have base two, which is just, you know, we have a zero and a one

because in the computer, which is why we learn binary, we just have on and off basically for

every single, you know, part of the computer. There’s just like a certain voltage or there’s

not a certain voltage and that’s it. And then for hexadecimal, which is a way to represent the same

numbers, but just in a more compact way. It’s a little bit more compact than decimal. It’s a lot

than binary we can say that this is base 16 which means we have 16 total characters that we can work

with zero one two three four five six seven eight nine and once we run out of numbers we just start

using letters so a b c d e f so there are 16 total characters if we include the zero which means we

So that’s the basics of you know the number basis let’s uh let’s work out how to convert a hex

number to decimal. So I’m going to say ox because in hex when you write down a hex number you should

usually put ox in front of it unless the program you’re working with doesn’t understand that but

usually especially for a human reader you should do it this way. So I’m going to just type like a

few random maybe I have to I have to keep the number small because hex will explode it’ll be

not careful. So I’m going to put like a I don’t know, maybe a few decimal numbers there or a few

like digits that are zero to nine, then I’ll just to make it more interesting, I’ll put some letters

in there. How about like an E there? And then I don’t know, like, we’ll do a B there. Okay, so

how many do I have? 12341234? How about we get rid of? Now, let’s go for it. This is going to be an

So this is our starting number hexadecimal. What we need to do is understand that, well,

a recap if you haven’t watched my other videos yet. In decimal we have, let’s say, 0, 1, 2, 3,

4, 5, 6. You know that the first digit has a strength of 1. You multiply 6 by 1 to understand

the real power of that 6. For the 5, you know that it has a power of 10 or a strength of 10

10 because it’s the next digit over you know to the left same thing for the four it’s like got a

strength of 100 and so every time you move to the left the strength of the digit increases by a

factor of 10. why does it increase by a factor of 10 because decimal is base 10 because we have 10

possible digits we can represent for each character okay so by the time we get to that

left, we have a strength of 100,000. So, you know, if you wanted to really understand 100,000,

if you really wanted to understand, you know, how powerful, let me, let me give some spacing here.

So this feels better. Okay. If you really wanted to understand like, you know, what is the strength?

What is like the actual value of this digit right here? You’re imagining this is like 100,000.

this digit here you’re imagining that this is two of ten thousand you know two times ten thousand

and so forth so uh uh just like another recap the first digit is really 10 to the zero power

like in terms of the strength because if you multiply um let me pin this to the top

if you multiply you know 10 to the something power and you start at zero with the most

the weakest digit 10 to the zero power gives a strength of one and then every time you move over

to the left you just increase the exponent there by one so 10 to the first power is going to be 10

that’s what that five has got so it’ll be five times 10 to give us an understanding of how you

know powerful that digit is move one over to the left it’s 10 to the second power so that’s 100

move one over to the left it’s 10 to the third power and so forth until we get to 10 to the fifth

1 times 10 to the fifth power to understand how powerful that is so we can do the same exact thing

with hexadecimal except instead of raising 10 to a power we raise 16 to a power because hexadecimal

is base 16 whereas decimal is base 10. so that means this e is is uh you know 10 to the or sorry

16 to the zero power and then that 3 is 16 to the 1 power and that f is 16 to the 2 power and so

16 to the 2 power and so forth so first what we should do is let’s write out a

formula which won’t work in a calculator because we’re going to put some letters

in there and then later we’ll translate the letters to actual values so we’ll

start off with the e we’ll say e times 16 to the something power it’s going to be

16 to the zero power okay so then the next digit is 3 so 3 times 16 to the

And then the next thing is going to be F times 16 to the second power.

And just as a reminder here, I’m starting with zero with the smallest digit.

And I’m just working my way up in steps of one.

So it’s zero power or raised to zero and raised to one and raised to two and just so forth all the way to the left.

That number will just keep increasing by one.

The exponent will increase by one.

times 16 to the third power do it again um one times 16 to the fourth power do it again

um d times 16 to the fourth power oh what did i do did i erase something

0, 1, 2, 3, 4, 5.

Oh, that was supposed to be a 5.

Okay, maybe it’s good that I thought I made a mistake

because that drew my attention to the bad exponent.

Okay, so after the D is a B.

B times 16 to the 6th power.

And then one more.

We’ll say 6 times 16 to the 7th power.

And then another one.

A times 16 to the, whoops, to the eighth power.

And another one.

One times 16 to the ninth power.

Ninth power.

Okay.

So just double check your work real fast.

You know, because I make typos all the time and I get things wrong all the time.

So just double check.

Zero, one, two, three, four, five, six, seven, eight, nine.

It’s sequential.

Double check the digits.

6 b d 1 3 f 3 e okay so i got that right i’m not going to erase my work because if i end up screwing

up the next part oh man is it going to be a hassle to correct so i’m just going to copy paste it here

and then i’m going to start translating the letters to numbers anytime you see a number here like one

time something it’s just one but every time you see a letter you have to translate that into

in decimal. Remember in hex, we’ll say, what can I do?

I can say A, B, C, D, E, F.

And I can say that the A is worth 10.

The B is worth 11.

The C is worth 12.

And the D is worth 13.

The E is worth 14 and the F is worth 15.

Well, maybe I should do the other numbers too.

five, six, seven, eight, nine,

just so we have a visual reminder

of like what we’re even looking at.

And I won’t write down what the digits are worth

because they’re worth themselves, right?

So like zero through nine, it’s just worth zero through nine.

So now that we have this little translation table up here,

anytime we see a letter,

we can just translate it very quickly to the decimal value.

So A is worth 10, we’ll put a 10 there.

Maybe I’ll add some spacing so that this continues to line up.

I see a B here, so the B is gonna be worth 11,

11 add another space so it lines up i’m running out of room but i’ll try the d is worth 13 add

another space so it lines up and then the f is worth 15 add another space so it lines up the e

is worth 14 so i’ll add another space so it lines up okay let me just double check my work here a b d

So now I’ve got like a big formula that I wrote out.

I can literally now, I mean, you can do this in your head if you’re like a crazy genius,

but I’m just going to paste this into a calculator and hit enter.

And this is the number that we had originally in hex.

Maybe I’ll put commas here to make things more fun.

I don’t know.

You don’t really need to do that, but I’m going to.

So for me, it’s easier to read.

this is uh like 113 trillion 478 no wait that’s a million and that’s a bill okay so 113 mil a

billion 478 million 25 022. let me punch up my personal calculator here to make sure that i’m

getting this right i’m not going to show this on the screen because i’ve just got this up

on my host machine bet you didn’t know i’m inside of vm right now surprised you didn’t know that

decimal and the number is supposed to be 113478025022 okay so we did this right we now know how

to convert from hexadecimal to decimal and it’s pretty awesome right okay let’s do another number

one that is not quite as hard let’s see how many digits do we have here one two three i think we

5, 6, 7, 8, 9, 10.

Yeah, okay, we had 10.

Let’s do a five-digit hex number.

Okay, maybe I’ll copy…

I’ll copy just this table at the top

since you don’t need it anymore,

but I’m going to need it to do my calculations.

So we’ll do 1, 2, 3, 4, 5,

and I’ll just start randomly changing

some of these numbers.

Like an 8 over here, and how about like a 2?

So I’ve got five numbers.

This is OX.

I’m going to say this is a hexadecimal number.

Kind of ambiguous if we tell the reader this is a hex number,

but then we put OX.

Kind of don’t really need to tell them that it’s hex

because OX tells you it’s hex.

It’s not even part of the value.

So let’s get on with it.

I’ll start by just doing 8 times 16 to the something power,

which is going to be 0 for that first position.

the power as we go to the left so it’s going to be 1 times 16 to the first power and then it’s

going to be f times 16 to the second power and then it’s going to be 2 times 16 to the third

power oh no my thoughts are wandering i think i’m getting bored of recording this video i’m starting

to the fourth power but honestly why couldn’t they end up together so and

then I think one two three four five okay so that’s five digits a to f one

eight a to f one eight all right zero one two three four just to make sure

that I got my exponents right copy paste it so I don’t have to repeat my work if

I get something wrong I’m gonna translate the letters into numbers so a

becomes 10 f becomes 15 and the other numbers are fine as is I can just copy

fine as is I can just copy paste this whole thing stick it into a calculator and now I know that

this number is actually 667 416 with a little comma in there don’t put commas if you are taking an

exam somewhere if you’re watching my video to help with your exam because most most likely the exam

that you’re taking will not accept a comma it’s not been pre-programmed for a comma I don’t know

If you start typing numbers and a comma just shows up, then it probably was programmed for a comma.

But don’t assume it might be a string match and not a numeric match.

So be careful out there.

Be careful.

So 667-416.

Let me punch this into my personal calculator just to make sure I got this right and I don’t have to issue an errata.

667-416.

All right.

We’ve done it.

We know how to convert hexadecimal numbers into decimal numbers.

Thank you so much for watching this video. I hope you enjoyed it and had a little bit of fun and

learned a little bit of stuff. I’ll see you in the next video. 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. 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

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.

just wake me up in the middle of the night just subscribe and then I’ll just

wake up I promise that’s what will happen also 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

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 enjoy the cool music as as I fade into the darkness which is

the darkness which is coming for us all.

Thank you.

The post Hex to Decimal Made Easy: Fun & Simple Conversion Guide! appeared first on NeuralLantern.com.

Binary got you baffled? Let’s break it down! In this fun crash course, I’ll show you how to convert binary to decimal step-by-step—super easy, no stress. We’ll go from 765,432 in decimal to 10101111 in binary (that’s 335, btw), with tricks to eyeball it fast. Perfect for beginners or anyone who loves a good tech challenge. Hit subscribe—I wake up in a cold sweat when you do, and it means the world! More vids coming your way!

Introduction to Binary and Decimal 00:00:00
Understanding Decimal System 00:00:44
Decimal Position Strengths 00:01:39
Decimal Formula Explanation 00:03:48
Transition to Binary System 00:06:31
Binary Position Strengths 00:07:19
Binary Formula Breakdown 00:10:46
Calculating Binary Example (335) 00:12:55
Quick Binary Conversion Trick 00:15:24
Memorizing Binary Positions 00:13:52
Small Binary Example (19) 00:15:43
Closing and Subscription Request 00:16:48

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 converting binary to decimal.

Just a quick recap for those of you who don’t know. Watch my other videos if you’re not sure

about number bases, but basically, you know, decimal is a number system that has 10 characters

to represent a number. So 0, 1, 2, 4, 5, 6, 7, 8, 9. That’s 10 characters in decimal.

In binary, we just have two characters.

So it’s base two, whereas decimal is base 10.

How can we convert between the two?

Well, first, before we can try to convert between the two,

we should try to understand what’s really going on with normal decimal representations.

So if I have a decimal number here, and I say, I don’t know,

let’s just type a couple of random numbers.

How do we really know what this value is?

How do we kind of understand what is the meaning?

Okay, so you know that, you know,

if you just kind of look at this for a second,

you’ll realize this is 765,000, right?

765,432.

How do we know that this is 700,000?

Because it’s in a certain position.

It’s like, you know, several digits to the left.

How do we know that the next one represents 65,000?

Well, it’s one less to the left.

uh it’s a tenth of the like power of the seven digit same thing for the five how do we know

that’s a thousand same thing for the four and the three and the two what we really do is we end up

deciding okay you know what the uh the first digit here on the right side that two uh the strength of

of one. So like, you know, two times one is just two. So whatever, whatever that digit is, if it

was a five, it would just be a five, five times one is five, right? So the strength of the very

first digit on the right side is just one. Every time we move one digit to the left, we multiply

the strength by 10. The reason we multiply the strength by 10 is because there are 10 possible

digits, or 10 possible characters that we can use in decimal. Makes sense, right? So that means the

Makes sense, right?

So that means the three, we know that represents, you know, an addition of 30 because that’s

the 10th strength place.

Same thing for the four.

We multiply 10 by 10 again to get 100 in that position.

So this one has a strength of 100.

I’m writing this vertically.

Hopefully this is not too messy, but I’m hoping you’ll understand.

Well, I don’t know.

Maybe if I space this out, does that make it better or worse?

maybe it makes it slightly better i don’t know i’m going to roll with it

what can i say i’m a rebel okay so i live dangerously the five we know that’s worth

five thousand because again the four position over here you know that third digit it had a

strength of 100 so we multiply that strength by 10 going to the left to to end up with a thousand

to end up with a thousand.

So same thing with the six.

I’m not going to explain that any further.

You know, it’s got a strength of, you know, 10,000.

Okay.

And then the seven, it’s got a strength of 100,000.

And it just keeps going and going and going to millions and billions and trillions

and however far you actually want to go.

That’s how we understand the decimal numbers

that we’re looking at.

How could you imagine this in terms of a formula?

Well, we’re really raising something to the 10th power.

If you think about this, the one,

we could imagine that the value one

is actually 10 to the zero power

because anything raised to the zero power is just a one.

Let me pull up this calculator real fast.

I got to stick that on my desktop in the future.

If we say 10 to the zero power, it’s just one.

Any number to the zero power is just one.

Okay, so then we would multiply that strength

by the actual digit that we see,

the character that we see.

It’s a two.

Okay, so that’s going to be two times 10 to the zero power.

I’m going to put that in parentheses

to keep it a little bit clean or somewhat cleaner.

So now when we go one to the left

to look at that three digit,

to look at that three digit, we end up with three times something.

Let me get a space here for my brain.

Times 10 to the something power.

Well, every time we go to the left, we just really have to increase the power by one.

It’s 10 to the first power because we’re looking for actually just the number 10.

So if we say 10 to the first power on that calculator, it’s 10.

So then, you know, just keep repeating the process.

10 to the second power. And that should be 100. So if I say 10 to the second power, it’s 100.

All right. And, you know, we’re adding all the positions together, even though we’re multiplying

the digit by its strength. So I’m going to say five times 10 to the third power. And then again,

just to double check here, 10 to the third power is 1000. So you can see the five was supposed to

and then again we’ll say six times ten to the fourth power and then just double check here

the fourth power should be a thousand sorry ten thousand and then we’ll do it one last time we’ll

say seven times ten to the fifth power which should be a hundred thousand all right so now

that we’ve written this all out you know this is kind of madness right what you can do now

do now is you can put this into the calculator and it should give you the exact same number that

we started with. We should see 765432, unless there’s a typo. 765432. Nice. Okay, that might

have seemed like it was a little bit of a waste of time, but it’s not because now we kind of

understand the breakdown of the different positions of the digits in decimal, which means

now we can do the same thing in binary, basically the exact same thing, except just use a power of,

use a two to some power rather than a 10 to some power because the only reason we use 10 down here

it says we were in decimal that has a base of 10 now let’s go into binary

which is um a base of two so i’m going to just i guess maybe what did i do wrong

i hit something and it like did a space i don’t even want to know i don’t even want to know

okay so let’s do a binary number i’m just going to type a few random digits

a few random digits. I don’t know what number this is yet, but let’s work it out slowly

in the same way. You know what, maybe instead of doing the formula first and only, let’s do

both parts like we did with decimal. So what’s the position, what’s the strength of the position

for that first character? Well, I said before the first character is always just going to be,

sorry, the first digit is always just going to be a one, right? That’s going to be true

So I’m going to say this has a strength of 1.

How do we know it’s a strength of 1?

Because we’ll take 2 to the something power.

We start at 0 for that first position, and it’s going to give us a 1.

Okay.

So the strength of this one, I already know binary.

So I just know off the top of my head that to go to the left,

the strength just multiplies by 2.

And that’s pretty easy after you start memorizing it.

I haven’t quite memorized hexadecimal yet, but maybe you will in another video.

So I’m going to multiply one by two and I’m going to end up with two.

Double check over here in the calculator.

Two to the first power is two.

So then the strength of this next digit should be four.

Two times two is four, right?

So let’s do two to the second power.

That’s four.

Multiply by two again.

It’s going to be eight.

Double check over here.

Two to the third power is eight.

The next digit is going to be 16 of its strength.

So I’m going to write this vertically again.

So it’s going to be 16.

Double check over here with the calculator.

Double check over here with the calculator, 2 to the 4th power is 16.

Next digit is going to be 32.

Double check with the calculator, 2 to the 5th power.

And things are starting to get messy, so I think I’m going to like space everything out probably.

Just to make it easier to read.

Tell me if you think this makes it actually easier to read or if I’m making it way harder.

I think I’m making it easier.

Okay, so we got 32.

two. Next one up is going to be 64. Just multiply it by two. Double check two to the sixth power.

That’s going to be 64. And then the biggest one that we’ve written down is going to be 128.

Double check it. Six to the seventh power is 128. We could go on and on and on, but I’m just going

to leave it here because we, I hope we have a pretty good idea of, you know, what this means.

delineation or like a delimiter showing us that these are just representing the strengths and

this is the actual number. Okay, so how can we write this out in a formula?

Whoa, what did I do wrong? Did you see that? Oh no. Hang on a second.

I think I missed it. How many digits are there? If there are eight digits, then I definitely forgot

something. No, no. Okay. There are nine digits, so the last one should be 256. Okay.

256. Okay. So I got it all lined up. At some point I must have not lined it up. My apologies,

but hey, maybe I’m making these mistakes on purpose to make sure that you’re paying attention.

You never know. I want you to think. So 256 is going to be the next number. Double check it with

the calculator. Two to the eighth power, 256. Cool. By the way, a quick trick in binary that

the actual highest number that you can represent in an unsigned binary integer is basically the

strength of the highest digit, you know, this 256 here, multiplied by two and then subtract one

from it. So 256 multiplied by two is going to be 512. So it’s going to be 511. So I could

represent a number between zero and 511 or 512 possible combinations. Okay, so now let’s work

let’s work out the formula.

See 16, 30, 16, 40, okay, I did it okay.

I probably should have rehearsed this.

So let’s do each position.

So it’s either always gonna be one times something

or zero times something, right?

Because binary, these characters can only be one or a zero.

So let’s do on the, starting from the right,

we’ll say one times two to the something power.

It’s gonna be two to the zero power

You know, just going to be a one.

Working our way over to the left, it’s going to be one times two to the something power

to the first power because it just increases every time the power increases.

We have four ones in a row here.

I got to try to remember that.

This is where I’m going to start making lots and lots of typos.

Two to the second power.

And then we have another one.

One, two, three, four, one times two to the third power.

And then again, we are going to hit a zero.

So it’s going to be zero times two to the something power.

You might be tempted to omit the zeros.

You can if you want to.

But for me personally, it helps me quickly visually see that I’m getting the powers in

the right order.

I can see two to the zero power, first power, second power, third power, fourth power.

Sometimes when I omit the zeros, I end up kind of like messing up the order of the powers

and or the order of the exponents.

of the exponents and I have to redo everything all over again.

So I just keep it this way.

Okay, so it’s one, one, one, one, one, one, one, one, zero.

So there’s another zero that we need

times two to the fifth power.

So we got both of those zeros now.

And then we need another one times two to the sixth power.

And then we need

0 times 2 to the 7th power.

Okay.

And then we have another 1 times 2 to the 8th power.

And I know we’re supposed to be done on 8

because that’s what we were doing before.

The 256 strength.

So unless I made some mistakes here,

this is probably the number that we can punch up into the calculator

to see what this binary number is.

So I’m going to punch it up.

Huge.

It says that it’s the number 335.

Let’s see if that’s actually right.

I’m going to punch this up in my personal calculator real fast.

I’m going to say 10101111.

And the expression is decimal 335.

Yep.

So that’s it.

We know how to convert from binary to decimal.

And just again, like as a quick shorthand,

it’s probably a good idea if you’re involved in computer science,

to memorize these positions up to maybe

6, 5, 5, 3, 6.

That might sound a little extreme sometimes,

but I don’t know.

Personally, I’m not like the most advanced

binary reader at all times,

but I can remember up to that much.

And what do I mean when I’m saying that?

I’m saying, you know, start with a 1, 2, 4, 8,

8, 2, 56, 5, 12, 1, 2, 4, 2, 0, 4, 8, 4, 0, 9, 6, 8, 1, 9, 2, 1, 6, 3, 8, 4.

Took me a while to remember that one.

3, 2, 7, 6, 8, 6, 5, 5, 3, 6.

So if you think about it, how many bits is this?

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16.

Right here, 16.

That’ll give you two bytes worth of memorization or a word on many systems.

on many systems. For me personally, I just, I like to go up to 6, 5, 5, 3, 5 because

remember I was saying, you know, what is the highest number that you can go up to

with a certain number of bits? It’s always the power or the strength of the highest bit

multiplied by two and then subtract one. So when I remember 6, 5, 5, 3, 6, that tells me that if I

65535. This is very, very useful if you’re going to be working with binary numbers a lot,

or if you’re taking exams or whatever it is that you’re doing, I would recommend everyone do this.

Okay. What do you say? What do you say we do another binary number, but we’ll just do something

a little bit smaller to make it easy. Okay. So by the way, when you start to memorize these positions,

start to eyeball it, which is really, really fast and a good idea. Like I can see those two

numbers right there. I know the first one is a one and the second one is a two. So that means the

one and the one are just going to be a value of three. Then I just quickly go, all right, one,

two, four, eight, one, two, four, eight, 16. So it’s going to be 16 plus three. So it’s going to

be 19. I guarantee it. Let’s, let’s double check this real fast. We’ll say one times two to the

and then we’ll say 1 times 2 to the first power

and then we’ll say 0 times 2 to the second power

and then we’ll say 0 times 2 to the third power

and then we’ll say 1 times 2 to the fourth power

and if I didn’t go too fast and make a bunch of typos

it should be the number 19

So there is a lot of benefit in memorizing the strength of these different positions.

I personally never remember very much beyond 256 when I’m actually trying to work out a number

conversion, but when I’m just thinking of how to compute things, it’s faster if I can go up to

65536. Okay, I hope you enjoyed this video. I hope you learned a little bit of stuff. I hope

you had a little bit of fun. I’ll see you in the next one.

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.

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

just I’ll be able to keep making videos in general so please do do me a kindness and uh 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 could troll me

if you want to just wake me up in the middle of the night just subscribe 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

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 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

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 enjoy the cool music as, as I fade into the darkness, which is coming for us all.

Thank you.

The post Binary to Decimal Made Easy: Fun Crash Course for Beginners appeared first on NeuralLantern.com.