Join me as I break down a simple yet powerful x86-64 YASM assembly program to copy files using system calls! Learn how to open input files, create output files, and use a looping buffer for efficient data transfer. I’ll demo the code, explain file handles, permissions, and error handling, and even verify the copy with MD5 checksums. Perfect for intermediate assembly programmers or anyone curious about low-level file operations. Check out my other videos for more assembly tips, and don’t forget to subscribe!

Introduction to File Copy Program 00:00:00
System Calls in YASM Assembly 00:00:06
Opening Input File 00:00:17
Creating Output File 00:00:22
Using Looping Buffer 00:00:28
Assembly Program Prerequisites 00:00:37
Overview of Source File 00:00:53
Data Section and Strings 00:01:06
Copy Buffer Length 00:01:21
File Permissions Explanation 00:02:05
System Call Codes 00:02:57
File Descriptors and Exit Codes 00:03:24
Text Section and Entry Point 00:03:45
Welcome Message Function 00:04:01
Print Null Terminated String 00:04:16
Running Initial Program 00:06:26
MD5 Checksum Explanation 00:07:00
File Tests Function Introduction 00:07:28
Open File Read Function 00:09:52
Checking File Handle 00:14:00
File Handle Concept 00:14:25
Error Handling Importance 00:15:24
Testing File Open 00:23:00
Create File Function 00:31:16
Testing File Creation 00:32:36
Copy File Function 00:36:14
Stack Buffer Creation 00:38:16
While Loop for Copying 00:40:14
Read System Call 00:40:47
Write System Call 00:45:03
Checking Read/Write Operations 00:46:51
Final Program Run 00:49:00
Verifying File Copy with MD5 00:49:22
Testing with Larger Input 00:51:20
Optimizing Buffer Size 00:53:41
Conclusion and Call to Subscribe 00:54:41

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 everybody in this video i’m going to show and explain a simple program that copies a file

using system calls in an x8664 yasm assembly program

we’re going to use the system calls to open an input file and read characters from it we’re

going to use another system call to create a destination file and write characters to it

we’re going to use a looping buffer,

which should be kind of fun in the middle.

And I’m just going to do my best to explain as much as I can.

I should say though that before you can watch this video,

you probably already need to know how to program an assembly,

at least in a basic level, Yasm assembly.

And so if you don’t know how to do that yet,

this video is probably going to be confusing for you.

You probably need to look at my other videos dealing with Yasm assembly and

system calls and so forth.

So I’m just going to show you real fast what’s actually going on in this source

actually going on in this source file so far.

So this is my assembly program.

It’s not finished.

I’m going to write it on screen for you.

For the most part, you can see I’ve got a data section here and then I just have a

bunch of null terminated strings.

So I’ve got a string saying, hey, the module started.

We’re about to open the file.

We’re about to create the file.

We failed to do something.

We’re done copying.

You know, we terminated the program, you know, whatever.

Right. So I just have some strings.

No big deal.

Down here, I have something called the copy buffer length, which is which is just

length with just which is just the size of the buffer that I’m going to use

between the input file and the output file so a two byte buffer is really

inefficient it’s too small but I made it two bytes just to show to you that are

looping you know a read area is going to actually work because if I make a buffer

that’s too big if it’s bigger than the file then we won’t actually know if the

if the buffer loop works or not so I’m just gonna put two here could change

that later if we wanted to we’re gonna be reading from a file called input and

called input and writing to a file called output so that’s no big deal in order to open a file with

a system call for read mode we’re just going to use a zero as the flags that just means read mode

and then for the creation of the file we’re going to use some standard permissions this is not a

permissions video I’m going to probably release a permissions video at some later point in time

not too important right now but basically this 640 is the heart of what permissions we’re actually

what permissions we’re actually looking at.

Q is quad word.

And six just means that the owner can read

and write to the file.

Four means that anyone who is in the same group

as the file has been assigned to,

which is usually the owner,

can just read it but not write to it.

And then everybody else,

people who are not the owner

and who are not in the right group,

they have no access to it.

Just a simple security feature of Linux

for file permissions.

You can go a lot further than this in the terminal,

in the terminal, but for this assembly program,

we’re just gonna use basics.

We’re not gonna use ACLs.

I don’t even know how to do that in assembly.

System call codes.

So again, if you don’t understand system calls,

you gotta watch my other videos first,

but we have a code of zero to read from a file,

one to write to a file, two to open a file,

three to close and open file.

Probably should have put that one before create,

but I don’t really care.

85 is the code to create a file for writing,

to create a file for writing and then 60 is the code to exit from the program.

So then we have file descriptors.

Descriptor number one is a standard output.

Descriptor number two is standard error.

And it’s always one and two, no matter what program you’re dealing with.

Unless you have some kind of really crazy non-standard thing going on.

And then for the exit codes, we’re just going to say exit zero for success and exit one

for failure.

Now to the actual tech section where our instructions are in the assembly program.

in the assembly program.

So you can see section text here.

We’ve got a global entry point called underscore start.

So this is not a GCC program that requires a main entry point.

This is a pure assembly program that requires

an underscore start entry point.

Again, see my other videos for more assembly explanation.

I’m gonna call on a method,

well, not a method of regular function called welcome.

Just to print a little welcome message,

you can see right here, that’s all that’s doing.

It’s just loading, you know, a string,

sending it to standard output, and calling on a helper function that I made called print null

terminated string. When it’s done with that, it just uses the call code to exit the program.

No big deal. Nothing too advanced so far. I have the tests function commented out because I want

to write that in front of you. And if you look at what I have inside of print null terminated string,

this is not the point of the video, so I’m just going to skim it. It’s not super important.

called print null terminated string that takes in a pointer to a character array

and a file handle for where you want to print it and what it’ll do is it’ll come

in grab the incoming arguments it’s only got two arguments so it uses r12 and r13

to store those arguments and then r14 is the result of calling another helper

called string length you can imagine my string length function just kind of

scans the string until it finds a null terminator aka the number zero not the

zero but actually a zero in order to figure out how long the string is and then it can use a

regular system call to print the string to the right file descriptor so we’re going to be doing

most mostly this kind of this exact same thing when we copy the file so I’m just definitely not

going to explain it if you don’t know pushes and pops and epilogues and prologues see my other

videos crlf is just going to print a carriage return new line so it or sorry carriage return

sorry, carriage return line feed.

So that’s just like making the cursor go to the next line.

Not a big deal.

We just print a string basically.

And then I have a custom die function

that allows us to die with a failure code of one.

Oh, I forgot to mark that.

Let’s see, 206 exit fail.

I’m just gonna put that down here.

Yeah, instead of hard coding values,

it’s a lot better to use variables if you can or defines.

So all that’s gonna do is just kind of print

an error message and then exit

then exit with the you know the appropriate

Exit code which is just going to be one because this is a simple program

So CRLF print an alternated string dying string length a welcome message all this fun pretty stuff

That doesn’t really do anything except make the program more fun to look at so I’m going to run it here and make sure that actually works

Okay

Nice, okay, so if I run it you can see that the the make file system again

file system again this is not a make file video so I’m not going to show you

my make file see my other videos if you want to learn more about make files but

you can see that the assembly program says that it started and then it just

exited then the make file continues to run these extra commands that I have

set up so this is not part of the assembly program this is just taking a

checksum an MD5 checksum of the input file and then an MD5 checksum of the

what empty five checksums are i’ll probably release a video sometime in the future if you’re

interested on all my platforms just talking about why we why you would use a checksum but for now

just imagine this is a fingerprint so if the fingerprints don’t match that means the files

don’t match right now the output file doesn’t even exist so it just is an error and that’s why the

make file thinks there’s an error because the output file didn’t exist so that’s the basics

of kind of getting started with this you know bare bones program now let’s start looking at running

program. Now let’s start looking at running the file tests. So file tests, we got to make a new

method. I’m going to stick it down here. Let’s see. I got a solution up so that I don’t have to

spend too much time typing. I’m going to try my best to balance between copy pasting and just

typing very quickly. But let’s see, where’s the file test? So we got this. I’m going to put the

I’m feeling pretty lazy.

I’m just going to copy paste the whole thing.

Copy paste the whole thing.

So now this method right here is going to get called the file tests.

I keep saying method because I teach C++ a lot too.

File tests.

If we go down further, this function is called file tests.

Here’s the signature.

It doesn’t take any arguments.

It just kind of does stuff.

It doesn’t return anything.

And here are the registers that I’m going to use.

the input file handle, the output file handle, and then the count of bytes read from the input

file at any given time inside of our looping buffer reader section. So the first thing I’ve

got to do is I’ve got to open a file to read. The second thing I’ve got to do is create a file to

write. And then I’m going to copy the input file to the output file. And then I’m going to print

a message saying, hey, everything was successful. And then I’m going to close both files. Notice how

anything i’m just sort of calling other functions do the work for me again if you don’t know the

prologue and epilogue stuff or calling functions and returning you should see my other videos

but i just like to use helper functions assembly is like so unwieldy right it’s it just gets out

of control so quick and so confusing so fast so anytime you can just you know take a chunk out

of your assembly code and move it somewhere to another module or to another function

going to make your life a lot easier and make debugging a lot easier people who try to write

the entire portion of their program in just one gigantic function those are the people who usually

end up spending 10 times longer debugging for no reason at all so i believe in the power of modular

thinking so anyway what are we going to do inside of the open file read function it’s not too bad

to be honest let’s see if i can find it real quick open file read i’m going to copy paste it because

Again, I’m pretty lazy.

I’ll just explain what it is though.

So down here we need a function called open file read.

So I’m just going to do that.

And you can see the signature that I’ve chosen for this is, you know, I like to

write all my functions in C++, uh, kind of lingo or prototypes so that I can have a

better understanding of what the assembly is actually supposed to do.

So you can see the function called open file read.

I want it to take two arguments.

two arguments the first argument should be a pointer to a string that represents the file

name that i want to open and it should be null terminated again if you look back at my uh at

my strings up here they all have little zeros at the end so they are all null terminated anyway uh

so that’s the first argument that’s going to show up as rdi in assembly and then the second argument

is the flags for opening the file so i think probably that was redundant if i if i name this

that was redundant if i if i name this open file read then i think it should be obvious that the

flags are just going to be the read flags only so i probably didn’t even need to provide this

that was bad design on my part you could write a better one on your own where it’s just one argument

and if the name is read then just use the read flags but if the maybe if you want to leave the

flags in there you could just say open file only it’s up to you anyway so it attempts to open a

successful it’ll return the file handle that’s the long return type right here

long file handle if it fails then it will just basically complain and exit

the program you probably want a more sophisticated way of handling errors in

your program I just decided to complain and exit the entire program because this

is you know not supposed to be super complicated I just want to show you how

to copy files and then for me I like to leave comments that just sort of explain

And once my functions get so complicated that I actually run out of registers,

then that tells me I probably need to just make another function,

you know, split the work up in some way.

So far, so good.

I only end up reusing the same registers for multiple purposes occasionally.

I’m not a hardcore assembly programmer.

I’m just, you know, I’m like medium.

So I’m going to use R12 and 13 and 14.

That’s why we have the prolog pushing all those registers to preserve them

pushing all those registers to preserve them because they’re callee saved and then the epilogue

epilogue that just kind of pops them i’ve got a label here for the function remember a function

is just a label and then a return statement as long as you obey and respect the abi like preserving

certain registers then you should be okay first thing i’m going to do is grab the incoming

arguments so i’m going to grab the file name which is a pointer which means it’s just a 64-bit

integer i can stick that into a register and then the flags same thing so i’m going to grab

rdi and rsi the incoming arguments i’m going to stick them into r12 and r13 so the character

pointer in the flags and then i’m going to attempt to open the file with a system call so

system call is right there line 168 if you look up the table for system calls in my favorite book

that i usually recommend or any table that knows the system call codes for x86-64 assembly

call code to open a file is some number i’ve assigned that to sys open if we look up here

open is code 2 so that’s why i you know i don’t want to remember the numbers it’s bad to hard

code number so i just i just put it as a define and then the first argument that it wants in rdi

is the name of the file so i just gave it r12 i guess i probably could have just used rdi

directly in the system call but that tends to make me nervous reusing the argument registers

registers, I like to have them somewhere where they’re not going to be destroyed.

If I like, let’s say I accidentally added some code here on line 163.

If I wanted to reuse RDI and I accidentally added some code there,

then RDI would have been destroyed.

Would have cost me a bunch of time debugging my program.

Although I admit it’s not super efficient to do it that way.

Then we’re going to do the file status

flags as the second argument, and then we just do a system call right away.

register gives you the result of your system call.

Notice how we use RAX to send in the call code.

And then the system call sends us back its return result also in the RAX

register. So I’m just going to save that right away to R14.

You can see up here, it’s just the file handle.

So we can assume maybe at this point that we have a file handle sitting in R14.

You know, what is a file handle when you ask the system to open a file for you?

The operating system under the hood is just going to do a bunch of stuff to

bunch of stuff to actually open a file it’s going to go it’s going to take the string

that you sent it and it’s going to parse it and figure out you know how do i how do i interpret

where that actually is on disk i’m going to look at like the file system in the past that you

provided i’m going to look at the mount points and i’m going to figure out like where exactly on disk

does that file start and then the operating system stores that the operating system stores the file

name it stores where you’re looking at the file currently stores a bunch of stuff that you don’t

a bunch of stuff that you don’t want to have to remember you know it creates data structures under

the hood and all it’ll give you back in return is a file handle for simplicity because then later

you can use that file handle to just sort of say I would like to write some bytes to a file or I

would like to read some bytes from an open file here’s the handle you gave me previously and then

it’ll just work assuming you have a valid handle so the handle is kind of the most important part

failed because it’s a mistake i’ve said this in other videos it’s a mistake that new programmers

make or lazy programmers make uh let’s suppose for the sake of argument uh uh file open sys call

pretend we’re in c plus plus and there is some sort of an api function that we can call either

directly to the system or some person’s library and it’ll open a file for us so maybe like a

just say we call this right so i’m going to do like a little comment if inside of your program you just

call it with the you know some some path and then you assume that what you have is a valid you know

handle if you assume that what you got back is a valid handle or maybe this is not a function

just assume that the call succeeded, your program is probably going to have errors when you least

expect it. And it’s not going to look good. Especially if you release a function like this

to the public, or if you have like a professor who’s like grading your code and they are testing

to see if you’re checking for return codes and stuff like that. That’s not a smart idea, right?

Like you shouldn’t, should not, shouldn’t proceed as if everything went according to plan. What,

just proceeding as if everything went according to plan.

You want to use an if statement, right?

You want to say if the handle has some value that seems to be valid,

like for example, more than zero in the case of opening a file,

I would say probably more than two because all of our programs

always have automatically assigned file handles of zero and one and two

to represent standard input, standard output, and standard error.

But I think usually people just say like,

if it’s greater than zero, then it’s fine.

zero then it’s fine uh you know for me i might put greater than two but more than zero is fine

the point is check to make sure that it actually succeeded

do i have spell check on this thing oh god you’re all going to see my true spelling let me see if i

can get it on real fast plug-ins what how come this oh okay now it’s highlighted

If we’ve succeeded based on some kind of a comparison of the return result,

then we’ll proceed in one way.

Otherwise we’ll respond to the error by, you know, doing something else.

Somehow, like writing a log file, sending an email, complaining to the user,

doing any number of things where you can actually respond to the error.

Maybe you probably want to change your execution path.

Like if the file successfully opened, then go ahead and start writing to it

or reading from it or whatever.

But if the file did not successfully open,

want to do something else in the program and not just start trying to read from the file so anyway

super super good idea and so that’s why i’m going to implement that inside of assembly 2. so instead

of just immediately using the file handle i’m going to check it i’m going to say let’s compare

it to the number zero if we succeeded then let’s go to another label called uh read success i

personally when i’m doing branching logic i like to say open file read is the name of the function

read is the name of the function and I’ll just I’ll just uh uh append some kind of a suffix

to the original function name that way it’s it’s easier to avoid collisions when you have lots of

functions and lots of labels and things like that so I’m basically saying if we succeeded I’m going

to jump to this label which is down here and so uh this video also is not about branching logic

and and how to implement those instructions you can probably infer it by looking at my code but

it by looking at my code but you know see another video in the future for that topic anyway if we

succeeded in opening the file handle then we’re just going to say oh we were successful and then

we’re going to uh um let’s see we’re going to print the name of the file that we just successfully

opened and then we’re going to send the file handle into rax so that this function has a return

So when you open a file to read successfully, the caller will receive the file handle.

You might be wondering yourself, wait a minute, wait a minute, wait a minute.

It just gave us the file handle in RAX.

Remember, we got to respect the ABI.

Anytime we jump anywhere or call another function or call another syscall,

which a lot of these things do,

we will probably lose the value of registers that are not callee preserved.

And that’s definitely RAX.

I mean, just doing any system call like this print null terminated string function does.

print null terminated string function does that’s going to destroy rex so that’s why i saved it away

first in r14 then at the very end of the function right before i return i’m just going to grab r14

and send it into rex again respect the abi do not return data as a return value in r14 or any other

register you have to use the designated registers and in this case an integer that you’re returning

x anyway so that’s the gist of that let me go back up for a second uh so notice how

we’re we’re sort of comparing oh gosh i just i just reconfigured my annotator and i bought a

new drawpad i wonder if this is going to work ah it works there’s a bunch of stuff i added too

so notice how uh we try to open the file and then we sort of compare the file handle to see if we

off to the success area down here oh my green’s not working oh it’s tricky it’s tricky i gotta

hit it in a certain way there we go if it succeeds we go down here to the success label so we

basically at that point um totally ignore all of the fail code right we’re just like branching

around on the other hand if it fails then execution falls through because it’s not going to jump

if uh if if r14 is not greater than or equal to zero so if we fail maybe i should put this in a

red if we fail then it’s going to fall through to the next label and then the next instructions

some people like to say let’s uh let’s jump to the success label and then if not let’s jump to

the fail label that can buy you a little bit more uh i don’t know jump length if you have a giant

program but in this case i’m just going to let it fall through it saves us one jump instruction

and so if it fails then it’s going to say first off let’s print a message that we failed

to standard error if you want a refresher on standard input standard output and standard error

see my other videos and then it’s going to print the name of the file that failed so that’s this

part right here it’s going to say hey we we failed to print or sorry we failed to open this file name

for reading and it’s going to print a new line there with the crlf thing

and then it’s actually going to exit the program at that point it’s going to say all right we

failed and so the whole program just just quits and that’s my die function that i showed you

earlier it’s just going to call the system call code for quitting and it’s going to give a return

code of one to indicate to anyone automating our program including new make that well our program

failed at least it failed okay so we got all that and then we got the success and so now you kind

of know the idea behind opening a file let’s do that real fast just for fun so file tests

um oh i know what to do i’ll just comment out these uh instructions just so that we’re only

doing the file open yeah that’s pretty good and then we won’t close anything just yet

so now let me run this in the terminal real fast make run it says it successfully opened

it says it successfully opened the file input.txt

and then the program exited.

No problem, that error code one,

that’s because the output file doesn’t actually exist.

So don’t worry about that.

And let’s change the name of the input file

just to show you that it can fail and we can detect it.

I’m gonna put a two there

so that the program will try to open an input file

that doesn’t actually exist.

And then I’ll run it again.

Notice how it says fail to open file input2.txt.

And then it says terminating program after failure to open file.

And then this time, notice how the make file never got far enough

so that it tried to print the MD5 sums of the input and output files.

The assembly program just failed.

And so GNU make said, I’m not going to proceed any further.

Kind of useful when your program gives good exit codes, right?

Because then other programs know when to stop

or maybe what to do depending on what’s happening.

So I’m just going to fix this real fast.

down here and maybe the next thing I want to add is closing the files so we’ve got a function to

open a file for reading and then we have a function down here that is not implemented yet

for closing the files so I’m going to do let’s see what is r12 r12 is the input file so I’m

going to close r12 so basically this function it’s going to it’s going to take one argument

handle. So that’s why I’m giving the file handle of the input file as the first argument. And then

I’m just going to call it. So let’s copy paste close file underneath this. So I’m going to do

like some more space. And let me let me go get this from my solution close file.

And it’s going to be a pretty simple one. Really nothing much to it. I’m just going to write my

C++ prototype saying, well, it takes in one argument and it’s a handle. It doesn’t return

argument and it’s a handle it doesn’t return anything it attempts to close a

file and I’m just gonna use R12 to hold the incoming argument your programs at

home should probably be a little bit better than mine you should check to see

if the file successfully closed or not and respond in some kind of a way but

for me I’m just saying I don’t really care I already showed you that we can

check for a return value so I’m allowed to be lazy now and just sort of try to

close it and then just assume it all went according to plan so grabbing the

So grabbing the incoming arguments here.

That’s why I’m using R12.

That’s why I’m doing a push-pop pair.

And then the system call code to close is pretty easy.

You just say, here’s the code to close.

Stick that in RAX.

Let me go up real fast.

Notice how sysclose is the call code number three

on line 43 there.

So I send it the call code three to say, let’s close a file.

It only wants one argument, which is just,

what is the file handle that you want me to close?

what is the file handle that you want me to close remember before the operating system created a

bunch of stuff under the hood and gave you a file handle you can then use the file handle

to close a file read a file write to the file whatever to the file so it’s pretty easy once

i’ve set up the incoming arguments to the system then i actually use the system call instruction

syscall and then i can assume it’s probably closed at that point then a return statement at the end

like any additional thing happening.

It should just be, it said it successfully opened the file

and then it just exited.

Okay, now we’re ready to add a little bit more.

Let’s create a file to write.

So this is going to be the same thing basically

as opening a file to read,

except it’s going to be a different call code

and we’ll give it initial file permissions

rather than a read mode flag.

But then we’ll just get a file handle in return.

get a file handle in return.

And I’ve also stuck this into another function, of course.

So the file name to write line 109.

If you just scroll up real fast here, or if I scroll up real fast,

it’s a line 27 here, just output.txt.

And then the file permissions that we want to use.

I’m going to scroll up here.

That’s the second argument to the system call code.

That’s just the stuff that I talked about a little while ago where it’s like,

we want the user to be able to read and write to the file.

to be able to read and write to the file we want people in the same group to be able to read only

and we want everyone else to not be able to do anything basic linux permissions not a big deal

at the end you should probably maybe note that uh you know this q i think i might have said this

before this q just means quad word and these zeros are always going to be the same so really it’s just

like three numbers representing file permissions i’ll go over that in more detail in some other

So for now, we know that we’re going to open a file name to we’re going to open a file

for writing doesn’t have to exist yet.

We’ll give it some default permissions.

And those are the incoming arguments to the function that we’re going to call now called

create file.

When that file when that function comes back, assuming it didn’t decide to exit the program

because we failed to open the file, we will receive the file handle in our ex per usual.

And so I’m just going to stash that away real fast into our 13.

Remember R12 has the handle to the input file.

R13 has the handle to the output file.

And then, you know, for me personally,

I put that in comments to help myself remember

what I’m even doing,

because things can get confusing really, really fast.

And while we’re at it,

before we even write the create file function,

I might as well just uncomment these things at the bottom,

just to say, let’s close both files properly.

You always want to do that.

let’s copy paste the create file function let’s see I didn’t do that already right yeah okay

so let’s do that maybe like right here I’m going to go grab it from my solution real fast create

file okay about as complicated as opening a file just because I put in some some checking logic to

see if it successfully opened the file which is a good idea so here’s my function create file

arguments. Oh shoot, file creation hand. Let’s see, am I using R13? Yeah, oh, I mislabeled that.

Instead of saying flags, it should be permissions. So let me just do perms here. Long perms,

file creation perms, perm. I wish I could get a perm, if you know what I mean. Anyway, so,

you know, we just have like the file name that comes in and the permissions that come in,

And it’s going to return a handle just like we did with the read file for opening function.

But this time we’re going to do something slightly different.

So the system call is going to be the code for creating a file.

SYS create, which is not real unless you define it.

So if we just look up, I define that as.

Where is it?

Create 85.

So like right here, code 85 for system create.

Again, not a smart idea to hard code numbers.

Defines are way better.

numbers defines are way better. So then the first argument that it wants is the name of the file.

That’s the incoming argument that I took into R12. It has to be a null terminated string. It’s going

to be output.txt. Then the second argument is the file’s permissions. So that’s R13 that I took here

from the second argument, long perms. Once I’ve set up those things, I can do the system call

right away. The system, again, will try to open the file. It’ll try to create the file,

set up some data structures under the hood. If it succeeds, it’ll give me a valid file handle

in RAX, the return register. If not, then things have failed and I need to respond to that. So

I’m just going to stash the file handle in R14 right away. That’s why I’m also preserving R14

in the push pop pair that I have, R14 up at the top and the bottom.

So now we got to check whether or not we successfully created the file. Again,

logic is just opening up off a reading I’m going to compare our 14 to zero if

it’s greater than zero I’m going to assume it’s a valid file handle so jump

if it’s greater than or equal to to that label create file success I’m still

using my appending can naming convention so the name of the function is create

file so that means the success area is create file and then append underscore

success and so then I’m just gonna you know print a cute message saying hey we

successfully created the file. Yay.

Same thing that we looked at before basically.

And then I’m going to return the file handle in RAX.

If we fail, same thing that we did before when we were opening a read file,

I’m just going to complain basically to the user and then call on my little

die function to properly exit the assembly program with a

exit code of one, you know,

and I could enhance that to exit with different codes. Like maybe exit code.

Maybe exit code one means the read file didn’t work and exit code two means the

write file didn’t work and exit code three means we failed for some reason

while we were copying the data, you know, whatever you want.

I’m keeping it kind of simple.

So we got all that.

Again, this is not different than reading just, you know, the call codes pretty

much and, you know, the arguments, but the idea is the same.

So now we’re ready to uncomment.

I think we actually already did that.

We’re ready to let the program try to create the file.

to create the file and the only thing we need to add after that is the copying portion and the

successful message so let’s see if this works do clear and make run so you can see that the program

starts running here and then it says okay the module started and then it says we successfully

opened the read file and then we successfully created the output file notice how the make file

doesn’t fail when it tries to call the md5 checksum of the output file because now it actually exists

because now it actually exists if we list the program uh list the directory here you’ll see

that the out file has actually been created it just has a length of zero because there’s nothing

inside of it notice also that the permissions match what we intended the initial user can read

and write or the owning user can read and write the group can only read and everybody else can do

nothing to heck with you we could change that real fast just to show you i can get this r to

show you i can get this r to turn into an rw just by modifying permissions up here

you know giving permissions to a group uh just is a nice way of allowing multiple users

to have a shared file location you know add them all to the same group and then set that group

onto the file and then set the group permissions to allow people to do whatever you want them to

do read or read and write or whatever so let’s see where the perms i’m going to change this

So now the group people should be able to read and write.

I can’t remember if this will work because the file already exists.

Let me give it a try.

Okay.

I ran it one more time and it looks like it did not create the file because it already

existed.

So let me just remove output.txt.

There should be another system call code you could use to just check to see if a file

exists or if you wanted to be kind of hacky, you could just try to open the file and see

open the file and see if it succeeded and then close it right away.

I wonder if there is a call code for just exists only.

I don’t remember off the top of my head.

So I’m going to remove it and then run the program again.

And then we should see now.

Yeah, now that the file didn’t exist and was newly created.

Now those new permissions that we added are reflected.

So the group, anybody who’s on the group can read and write.

And obviously the group is just the same as my new user by default.

But again, you could be more complicated than that.

you were running a multi-user system

and you wanted to share folders or whatever.

Okay, so I’m gonna remove output real fast

and I’m just gonna revert the permissions to 640

so that the group really can’t do very much

except just read it.

And then if I, oh shoot.

LS, okay, yeah.

So now you can see it reverted.

Okay, so we got the out file.

I’m starting to get lost here.

I’m starting to get lost here. What am I doing? I’m supposed to copy the data, I think. So file

tests and we are copying the file. I think I just uncommented that. Really? Oh, no, no, no. I’m

looking at my solution repo. Okay. That’s what I’m doing wrong. So we’ll look into your repo or your

the copy file I was like what how did I how did that program run if I already uncommented that

and we’ll we’ll uncomment this message for now no let’s leave it until we actually finish everything

so now we got to do the copy file function so where’s that okay I’m going to copy paste this

whole thing you know what this would have been like a five hour video if I actually had to type

this by hand I can’t even remember how long it took me to write this program I think it was like

off the top of my head. So this would be a nightmare to type, I think, on video, even if I

kind of already know how to do it now. So let’s see, string length, print an alternated string.

This is close file. This is create file. Okay, so I’m just going to do copy.

File is going to be right before close file and right after create file. Okay, so copy file.

Notice the signature that I’ve chosen for this one. It doesn’t return anything. So

So that’s like not great design.

You know, I need to check to see if the copying operations inside of my loop actually succeeded

and maybe return something to indicate success or failure or at least exit the program.

But I’m not doing that right now.

I’m just keeping it a little bit more simple.

It takes two arguments.

The first thing is the input handle and the second thing is the output handle.

Conveniently, we have both of those now at this point.

And then here’s my register usage.

through r15 to just sort of grab the incoming arguments here for r12 and 13 and then

r14 grabs the beginning of the temporary buffer which i’m going to make on the stack because i

think i’m so cool instead of making it as a global in the bss section and then uh

r15 is going to hold the result from the copy operation or i guess the the write operation so

Sorry, the read operation only.

Oh, I think I’m only checking the read bytes instead of the read and the write bytes.

I’ll talk about that in a second.

So I could upgrade my program a little bit more if I wanted to.

But basically R15 is going to be my temporary variable that looks at the return value to

say, hey, did we do we read anything?

Like how much did we read?

So copy file.

This is not a video about making local variables.

So just trust me on this.

so that I can use it to save the location of the stack pointer.

Then I’m going to make a copy buffer on the stack

just by subtracting the stack pointer

because the stack grows downward in memory location numbers.

And then the base pointer is going to help me remember

where the stack was when I started.

I’m just going to say that that’s going to be the first byte in my buffer.

And I’m going to move that into R14.

And let’s see, what did I do?

Let’s see, what did I do?

Think about from the stack.

Oh, did I write like a good program or a bad program?

I feel like I should have actually saved the base pointer and not the stack pointer there.

Let me see if this runs.

If it does run, I probably have a naughty program that might self-corrupt sometimes.

And it might be a good idea to move the base pointer as the first.

Because this is not a stack video, but basically the stack grows downward.

that means you’re sort of like extending its reach you’re allocating like a free space

if i take where the stack

nope nope nope i got it right i’m sorry if i take where the stack ends up after i extend it then i

have a lower address right because it grows downward to memory if i then say that the new

tip where it grew not where it grew from but where it grew to if i say that’s the first bite in a

in a buffer then when you’re actually using the buffer you increase memory locations as you’re

filling up a buffer so then that’s going to grow back towards where the stack started so it should

be fine i think if i if i did go ahead and reverse this if i used rbp instead of rsp there then i

think i would be going in the wrong direction and just corrupting memory so just so you know

this is not a stack video but just so you know so here’s a little label again i’m just kind of

iteration label and at the bottom I’m just kind of jumping back up to that label so this is a loop

you can imagine this is a while loop maybe I should draw that for fun I gotta find more excuses

to use my drophead so this is kind of like a while loop I’ll say while true maybe and here’s like the

body and then here’s like maybe the end of the body and so this jump statement just kind of goes back

this thing’s going to frustrate me so the first thing that happens is we read a portion

of the input file into the buffer so what are we doing we’re just using another system call

we’re saying let’s use the call code for read I can’t remember what that was it might have been

uh whoops oh I cleared the dang drawing oh hang on I have undo I think wait I have that I’m gonna

Okay, I’m not going to mess with it because this will actually terminate my whole program.

One of these keys, I forgot which one, will just kill the whole annotator.

So if we go up to SYS read in the defines, you can see that it is just call code zero.

So that means I’m telling the system I would like to read something.

First argument it wants is a file descriptor for the input file.

In a different video, I showed you how to use exactly this sort of thing to read standard

of thing to read standard input from the user or from another program that launched your program

but in this case r12 it’s not going to be the file handle zero for standard input it’s going

to be the actual file handle of the file that you’re trying to read from whatever that may have

been whatever the os gave you and then here here’s the address of where to store our characters and

if you look up again we decided to remember where the first byte in our buffer on the stack was or

like a local array like oh shoot let’s do it again let’s do more drawings you have like a function

right in c and then here it’s like we declared a local variable maybe not int maybe a character

array we’ll call it a or how about b for buffer and then we just gave it you know let’s say eight

bytes or something for the buffer i think i still have it set to two bytes obviously you want to use

more bytes for efficiency but just to prove that the loop actually works i’m keeping it small like

keeping it small like I said before whoa what’s all that you see that it’s like smearing okay

that’s not good so uh anyway we remembered where the uh buffer starts and it’s going to be r14

and then the copy buffer length is being you know used here uh and I think I have that set up to uh

from the input file and we want to read into our temporary buffer and we want to read at most

this many characters and then we say system call and it does all the work for us to read that many

characters and then we want to remember how many bytes were actually read because that could be

different from the number of bytes we requested maybe we’re at the end of the file maybe the

system is having like some kind of a buffer issue or something so we just want to remember how many

this little token up there to remind myself the temporary bytes read should

go there. Notice also that when we created the stack,

this is not a stack video again,

but like I made the stack buffer equal to the length of the buffer that I

actually wanted to use. So I use the same symbol,

copy buffer length and copy buffer length.

So then it’s going to try to figure out, okay,

how many bytes did we actually read? Let me,

let me do that while loop thing again. Cause I’m, I’m feeling it.

I’m feeling it.

feeling it did i really have to write the word true especially my bad penmanship so we’re doing

while true and then i’ll just say like read you know do some kind of a call to read maybe we’ll

say n equals read like a long you know the the r15 uh register is like the number of bytes that we

actually read and then we do a comparison here so we’re saying you know if you know n is um

if it’s equal to zero then we’re going to jump to the position in the while loop where we’re

um done which is actually past the while loop if you scroll down you’ll kind of see it so i’m just

going to say break so basically if we read zero bytes then we’re done reading bytes we’re just

finished so we just break the while loop and that’s what’s going to happen here when we say

the end of the body and you’ll see that in a second so then otherwise if we’re not done that

means execution is not going to jump it’s going to just fall through to the next statement here

and that’s going to be another system call code to write to the output file and it’s going to be

very similar we just load it up with the system call code for write let me just double check

is code one and then we’re going to give it the target for output which is going to be

a file handle so you know r13 r13 right here that’s a file handle that’s where we want to

write and then the next argument that it wants is the buffer and that’s going to be r14 which

is where we just what’s going on green grain there we go i’m having issues that’s uh the

that’s uh the buffer that we just read into right so if you look here r14 green oh my gosh okay so

green we uh read from uh the buffer pointed to by r14 and then we uh we read into the buffer

pointed to by r14 and then we are using that same buffer pointed to by r14 in order to grab

R15 says how many files or sorry, how many bytes?

Green, I’m having such problems.

R15 says how many bytes do you want to write to the file?

That should be our return value from before, right?

Because we want to read a certain number of bytes from the file

and then write exactly that many bytes.

If we did more, we would be writing some junk data probably.

And if we wrote less, then we would be missing data in the output file

that was originally in the input file.

So you want to do it exactly.

in the input file so you want to do it exactly and of course i’m just doing a system call here

but like i said before your program should probably be a little bit smarter and check

rax after you write to the file just to make sure that you know how many bytes were actually written

like what if you what if you read a hundred bytes but then you wrote 90 bytes only right that would

be like a bad situation so you’d want to do some branching logic there so that if you read 100 and

100 and you wrote 90 you probably want to backtrack the position of the file by like 10.

You know just to make sure that you can actually get all of the bytes into the output file

and seeking backwards 10 that’s just another system call. It’s not in this program but it’s

not too bad. You just make another system call give it the right call code tell it how far back

you want to go no problem. So then when by the time we make it here we’re going to jump back

We’re going to jump back up to the iterate label.

Let’s see, where’s that?

Yeah, right there.

We’re going to jump back up to the iterate label.

So basically this is how the while loop continues looping.

So let me clear that real fast.

Eventually when we’re out of data to read, you know, that’s because if we try to read

and we end up with zero bytes, that means we’re done.

We’ll break the while loop.

Then we’re going to go down here.

Notice how it says copy file done.

What I was talking about before, just sort of jumping past the end of the body.

so if we are done we jump to copy file done and all it does is just restore a

bunch of registers for us and then return to the caller so copy file we have that

handled now and if I go back up here file tests I guess I can I feel bad about

this I can uncomment the success message but we probably should have done more

checking on the reads and the rights just to make sure that we actually wrote

to make sure that we actually wrote the correct amount of characters and everything succeeded

every time and if not we exit the program and only if everything went well then we print a

successful message at this point in this program the way it’s written it could totally fail and

it’ll still say that it was successful so just keep that in mind that’s bad bad for your users

okay i think we have everything that we need now i can probably just run the program and

run. Notice now, oh shoot, I didn’t even show this to you before. Let me just emphasize this

one more time real fast. So I’m going to comment out the part where we actually copy the file

and I’m going to remove the output file. Then I’m going to run the whole program again. Notice how

the two MD5 sums are different. So remember before I said that MD5 sums, they’re basically

fingerprints. They’re not actually considered secure in the modern era. I just use them because

and fun if you are interested in security you probably want to use a

modern hashing algorithm so don’t use md5 but I am but don’t but I am and it’s

basically saying the fingerprint here of input is different than the fingerprint

here of the output quickly indicating to me that the files are different so if I

list the contents of the directory obviously that’s true because the output

file is empty still but if I uncomment this part here where I’m actually

here where I’m actually copying the file then I should see that the fingerprints

match and then if I look at what’s inside of the output file it should match

what’s inside of the input file really fast let me open up a terminal and I’ll

just cat the input file so this is all I added you know why hello there add some

stuff this is definitely more than two characters so we can be sure that our

buffer loop is actually working and so I’m gonna do clear and make run and now

And now the output file, notice how it has a matching file size.

It’s got 38 bytes in there.

Same thing for the input.

And then the thumbprints or, you know, the signatures, whatever you want to call it,

the hashes, they match exactly, indicating that we probably have two identical files.

Even with MD5, even though it’s old and not considered secure,

the chances of two files kind of having random differences,

not hacked differences, but just like random differences,

and having the same fingerprint is like astronomically almost impossible so if i do

cat input oops input.txt that’s what’s in there like we showed before and if i cat the output

now it is uh the same thing why hello there added some stuff for both i could make this as big as i

wanted to just for fun maybe let’s do uh let’s do a nano on the input file

I’ll just add like I don’t even know what I’m doing I’m just going to type a bunch of stuff

oh wait what is this remember that thing that people got taught a long time ago it was like

the quick brown fox jumped over the lazy dog and this was supposed to be all the letters of the

alphabet there was an there’s another one that I just heard about and I don’t remember exactly

look it up on the internet it’s it’s pretty cool i think i need to memorize this and stop using the

lazy dog it was um something like those sphinx of quartz hear my vow or something like that

you know what i’m gonna look it up for you right now i don’t want to do the wrong thing

it’s really cool uh i’ll type brown fox and then uh

Hear my vow.

Oh, Sphinx of black quartz.

Judge my vow.

That’s what it is.

Okay, so I’m going to go back to my little VM here.

Sphinx of black quartz.

Judge my…

I didn’t even write vow correctly.

Judge my vow.

And I think that has all the letters in the alphabet too.

probably less spaces. I wonder if that’s, I mean, that’s what the internet says. If this is true,

and it has all the letters of the alphabet, that’s going to be awesome. I’m going to memorize that

for sure. Sphinx of black quartz, judge my vow. Anyway, so I’m just kind of adding stuff into

this file. And if I run, let me save that here. I’ll do a clear. And then I’ll do, um,

I’ll cat the input file here, and then cat the output file. So you can see they’re different.

again let me remove the output file just in case I can’t remember if I’m supposed

to remove it manually or if I put that into the program we’ll just try it like

this so now they match and then if I cat again the output file notice how it’s a

perfect copy of the input file nice so I think that’s pretty much everything

that I wanted to show you maybe um well maybe we can use a more efficient buffer

we can use a more efficient buffer now that it’s done the copy buffer we could change this to like

eight kilobytes or something we should end up with the same result let me run this just as is

and see if it ends up being the same thing without erasing the file first yeah it looks good let me

remove the output file and then run it one more time so make run and then uh cat the output file

yeah okay so it still works but um you know whereas before we were just using a two byte buffer

two byte buffer there’s like very little chance except maybe at the end of the file that we would

request more data than the file had but using the return value of the read operation always told us

exactly how much was read by the operating system on the other hand if we have a giant buffer we

could request way more bytes than the file could ever have because that file is way less than eight

kilobytes so again we still want to look at the return value to make sure we know how many bytes

how many bytes should be sent into the right file.

So I guess that’s everything that I wanted to tell you

about reading and writing files using system calls.

I hope you’ve learned a lot of stuff

and you enjoyed this video and had a little bit of fun.

Thank you so much for watching.

I’m going to cut the video.

I’ll see you, whoops.

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

I do hope you did learn something and have some fun

If you could do me a please a small little favor. Could you please subscribe and follow this channel or these videos or

Whatever it is you do on the current social media website that you’re looking at right now

It would really mean the world to me and it’ll help make more videos and grow this community

So we’ll be able to do more videos longer videos better videos or just I’ll be able to keep making videos in general

So please do do me a kindness and and subscribe

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

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 send me a comment whatever I also wake up for

I wake up in a cold sweat and I’m like,

it would 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 I fade into the darkness,

which is coming for us all.

Thank you.

The post Master File Copying with System Calls in x86-64 YASM Assembly appeared first on NeuralLantern.com.

Want to master command line arguments in Yasm assembly? This video breaks down how to access and process args in x86-64 hybrid programs linked with GCC. From understanding argv and argc to looping through arguments, we cover it all with practical examples. Perfect for programmers diving into assembly or looking to level up their low-level coding skills. Check out my other videos for more on Yasm and pure assembly! Subscribe for more coding tutorials. #AssemblyProgramming #YasmAssembly #GCC #x86_64

Introduction 00:00:00
Command Line Arguments Overview 00:00:03
Yasm Assembly and GCC Linking 00:00:07
Hybrid Program Explanation 00:01:27
Makefile Overview 00:02:16
Assembly Program Structure 00:03:16
Main Entry Point and Registers 00:03:51
Accessing Command Line Arguments 00:04:26
Argument Count and Pointers 00:05:03
Loop Initialization for Arguments 00:08:57
Loop Logic and Dereferencing 00:10:52
Printing Arguments 00:13:02
Incrementing Pointers in Loop 00:14:08
Running the Program 00:15:35
Practical Application of Arguments 00:17:24
Conclusion and Next Steps 00:17:51
Call to Subscribe and Outro 00:18:22

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. In this video,

I’m going to talk to you about how to accept incoming command line arguments to

an x86-64 Yasm assembly program that is probably linking to

GCC and is thus probably a hybrid program under the hood.

If you don’t know how to program in Yasm assembly yet,

check out my other videos. If you don’t understand command line arguments yet,

yet check my other videos I’m going to assume a lot of knowledge here I’m

really just going to show you how to pull the arguments inside of assembly

using using the GCC setup that they’ve given you so just a quick just a very

quick recap this is not a command line arguments video if we have the program

echo and we give it like one argument of just the word hello then it’s it’s

going to receive one command line argument in addition to its program

echo as argument zero and hello as argument index one.

And it’s just going to be able to look at them and say,

oh, the user wants me to print this hello string.

So it just prints it.

And so that’s kind of how you can tell a program what to do,

either when you’re running them directly

or having one program automate another program.

Anyway, so in our Yasm assembly programs,

how do we actually get that out?

Well, for starters, we are dynamically linking.

Sorry, not dynamically linking.

We are linking a hybrid program.

So I just want to make sure that you understand this is the right video for you.

If you’re trying to do this in pure assembly, or if you need to know that for some reason,

then you’ll probably want to watch the next video that I publish.

But for now, this is a hybrid program.

Hybrid programs, for those of you who don’t know, it just means you have modules that

are written in different source code and they’re compiled differently, different source code

languages.

So you might have a source code file that’s written in C++ another one that’s written in C another one that’s written in assembly

And you compile them all down to their own object files and then you link them together into an executable

If GCC is part of the linking process

Then it’s going to end up giving you a main function as your entry point and it’s going to make things a little bit easier

Here’s my make file. I’m just going to skim through it real fast. This is not a make file video

So if you don’t understand it go look at my other videos

But basically I’m just going to assemble with Yasm and I’m going to use G++ as the linker

and I’m going to gobble up all of the object files. Here’s like a little menu.

I have a target for running and building only. And here’s the main thing that I’m doing. This

is not really a hybrid program. This is just kind of a pure assembly program that is linked with GCC,

but you can imagine you could add other source files in C and C++ and still totally get away

GCC. But anyway, I’m just compiling one source code of assembly and,

and compiling it down to an object file right here.

And then when it comes time to linking, uh, you can kind of tell here, uh,

especially if you’re familiar with make files that I’m just gobbling up all the

object files and linking them together into the executable.

So that’s as far as I’ll go there again,

I’ve got another video that totally explains a lot more in my assembly program.

video just for pure assembly so if you don’t understand assembly see my other videos but for

now we’re just going to say i’ve got a data section it’s got a couple of null terminated strings we’ve

got a hello message a begin message a goodbye message carriage return line feed string i’ve

got the system call codes for you know printing to standard output and to exit the program and then

i’ve got the standard output file handle and then my exit code zero for success again this is all

other videos. So because I’m linking with GCC, my text section here, the actual place where the

instructions are, not the data, is going to have a main entry point. So of course, if you had a

hybrid program, you could have main somewhere else in a different module and then just call on a

function that was inside of assembly. You could totally do that. But for now, I’m just going to

say this is the only source code file. So I mark main as global and I put main right here. And then

I preserve all of the Kali saved registers that I’m supposed to by pushing them at the beginning and popping them in reverse order at the end.

And then I return a return value.

Standard assembly stuff covered in other videos.

But here’s the key for getting command line arguments in assembly.

If you recall, the ABI specifies that in x86-64 programs, the first argument is always supposed to come into a function as RDI in the RDI register.

register or rather I should say the first integer argument I haven’t talked

about to float arguments in any of my videos yet in the future you should

probably search for other videos that that explain how to do float arguments

but for now all of the arguments I’m talking about in this video are just

integer arguments and pointer arguments which is kind of the same thing a

pointer is an integer it’s a 64-bit integer but we’ll just use it as a

using it as an integer so anyway first argument comes in on RDI second argument

comes in on RSI and you can imagine that basically this is the thing you’re

probably used to seeing in your C++ programs if we do this int main and then

integer arg C and then a character pointer arg V and then an array those are

those two registers right there I probably want to change this into long

because you know rdi is in 64-bit form but an integer is an unsigned 32-bit int.

I don’t like that so I’m just going to put long. I probably should put unsigned but I don’t really

care. Anyway so we’re just going to grab those two things so obviously rdi is probably pretty

easy for you to guess how to use it’s just the number of arguments. In this program we’re going

to use it to control a loop counter that’s going to loop through all incoming arguments.

which is going to be the name of the program in this case it’ll be I think

just main is what I called it which is confusing against the entry point I

admit it but imagine that my main program that sits in the file system is

actually called program or hello or whatever so that’s the number of

arguments in RDI and then RSI notice how it’s a character pointer to an array of

characters that means it’s actually a pointer to a pointer and the reason for

every argument on the command line like for instance if i went back here and i said echo

hello let’s just do without quotes hello you i’ve given it two arguments and so when the program

launches it’s going to receive three total it’s going to receive its own program name at index zero

echo it’s going to receive at index one the first argument hello and it’s going to receive at index

two the second argument as you it prints them both so how does echo know how many arguments i have

strings. Remember argc is the number of arguments so that’s kind of easy but how does it dereference

all of the strings if there could be any number of strings? Well that’s this right here.

This whole symbol argv is a pointer and it points to an array of pointers, of character

pointers. That’s why it’s written like this like an array. So it’s a pointer that points

points to an array.

So like if you go to that location in memory,

then what you will see there for the first eight bytes

is just the address of some other memory location where a string has been stored.

Then if you advance that pointer another eight bytes for it,

you know, in memory, because all pointers are eight bytes or 64 bits,

then again, you’ll see that that value of that next eight bytes

is actually a memory location that points to another string somewhere else.

So these strings could be all over the place,

But the pointers to those strings are contiguous in memory starting with what you were given in RSI.

So it’s a character pointer pointer or an array of character pointers, however you want to imagine that.

Anyway, so we’ll grab those and then I’ll just show you how to use them down further in the code.

For starters, I’m calling on an intro function which just basically prints some stuff.

I have a custom function that I wrote called print null terminated string.

That’s not the point of this video.

I have that explained in other videos a little bit.

So it’s up to you if you want to even care.

Right now I just want to be able to print something.

And then let’s see.

So after we print our welcome message in the intro, then we print another message basically

saying okay now we’re about to start printing all the arguments.

Okay cool.

Nothing complicated at this point.

Then I have another label here with my preferred style of adding a suffix after the function

after the function that I’m currently inside of.

And I’m going to say, all right, this is where I initialize my loop.

This is not a looping video, so I’m going to skim through it kind of.

But I’m basically going to say, let’s start the loop as basically saying

the index of the argument that we’re currently looking at is zero

because we’ll start with zero.

So that means we’ll print like if we were going to, if our program was named Echo,

we would also print Echo itself and not just all the incoming arguments

that the user might have typed.

index zero and then we’re going to use r15 as the current character pointer so r15 its current

character pointer is going to be coming from r13 which was the argv argument so that means

r15 is now going to hold a pointer uh let’s see it’s going to hold

when you have an array and the array is contiguous in memory then the pointer itself that points to

the array is also a pointer to the first item that’s just kind of the way it works like if we

have 10 items and it’s an array then your pointer to that array is also a pointer to the first item

in the array if that makes sense so if r13 was a pointer to an array it’s also a pointer to the

go off to a null terminated string i know that sounds weird you got to get used to double dereferencing

here so all we really need to do to access uh the first pointer to the actual string is take the

array pointer that we have and dereference it one time so remember we’re receiving an argv

a pointer to a pointer or like a you know a double pointer if we dereference it once then we should

terminated string. Anyway, so that’s the initialization part. I’m going to start looking

at the first string here and I’m going to say we’re at index zero. And then here’s the top of

my loop. You can imagine this is a while loop. This is not a while video, but you know, there it is.

And we’re just going to ask first, are we actually done? Do we need to break the loop? I like to do

that at the top of my while loop. And how we’ll do that is we’ll say, all right, R14 is the index

the number of arguments so notice how like right here we grabbed RDI right

into R12 right away so basically I’m saying if the index we’re currently

looking at is greater than or equal to the number of arguments then we’re

actually already done remember if we’re using zero based indexing and you

suppose that you have three items in your array their indexes would be zero

So that means if the size of your array is three, like the count, like the RFC, that

means the last valid index is two.

It’s one less than the size.

You know, it’s one less than the count.

So I’m saying at this point that if we ever reach an index number that is equal to the

size, then we’ve already finished.

We do not need to look at the current item.

So I’m comparing those two registers.

You know, where are we looking at versus what is the count?

You know, what is the index we’re looking at versus the count?

If the index we’re looking at is greater than or equal to the count, then that means we’re done.

I’m going to jump out of the loop to a label called main loop done.

So then, you know, that’s down here.

Basically, we just say goodbye and then we jump to our exit function.

And all that does is it just returns from main with some kind of a success code.

You know, so just you can imagine in C++, it’s just return zero.

So, you know, breaking the loop doesn’t really do anything except end the program and say goodbye.

However, if we did not jump, then the, let’s see if we did not jump, let’s, let’s see if

we did jump, we compared it, we realized that we’re done.

Then it’s going to jump down to the, to the done.

But if we’re not done, execution is going to fall through to the next statement.

So that means we’re going to end up doing something with the current item inside of

our loop.

So what are we going to do?

We’re going to dereference R15.

was your pointer to a pointer it was your double pointer there if we dereference it once then

instead of being a pointer to an array of pointers it’s going to be a pointer to one string one one

character that starts one string so dereferencing it once means you know i put brackets around the

double pointer it’s now dereferenced once that means rdi is going to receive a pointer to one

into my function my function takes two arguments it wants a pointer to a string and it wants

the file descriptor to print to again other videos explain you know printing to standard

output but i’m just going to print the string so this part right here should actually print

the argument and then after we’re done with that uh well maybe i should change this

so that it’s a little bit more clear i’m going to maybe push this down and say

these lines up here actually do something they do the printing by

dereferencing and then here we just sort of increment along the array of pointers

and jump back to the top of the loop so what are we doing here with r14

remember r14 was the index that we’re currently looking at so we we start

looking at index 0 line 83 is going to say let’s next look at index 1 and then

this part right here add 8 to r15 that just basically means remember r15 was

remember r15 was the double pointer the double pointer like i said before it’s looking at an

array of pointers so it’s actually a pointer to a pointer if i increase the memory location that

r15 holds then it’s now looking at the next pointer it’s moving through the array r15 at

that point would no longer be a valid pointer to the original array it’s sort of like a running

pointer it’s kind of like scanning all of the pointers but a pointer is eight bytes so if we’re

a pointer is eight bytes so if we’re just looking at the first pointer and we increase the memory

location that we’re looking at by eight bytes now we’re looking at the second pointer so then on the

next iteration of the loop if we dereference then we’re going to end up dereferencing to the second

string then i just print a little new line here honestly probably should have put that up top

sloppy code i was doing this quickly and then we jump to the top of the loop so then we just

going up to the top of the loop and printing arguments and advancing to the

next pointer. And we just keep going at it.

Let me see if this works. Hopefully I didn’t mess this up while I was screwing

around. All right. So I’m going to do this make run. Okay.

So under the hood inside of my make file,

maybe let’s open the make file real fast just so you can see.

I’m just going to nano it real fast here under the hood.

So when I call the program to run, notice how I’m giving it arguments.

You can see right here on this line, or actually let me get the line numbers up.

You can see on line 48, I am calling my executable, which is named main.

In the make file, I’m using a variable, so don’t worry about that.

But I’m giving it four arguments.

And I’m just saying first arg, second arg, third arg, fourth arg.

So that’s why you see that printed in the previous screen.

screen it’s just going through all the arguments that I gave it it’s saying

first arg second arg third arg fourth arg notice how it knows when to stop

because of the argc that came in on RDI now that the program is built you know

I’ve got my main executable which I named main which I said before was kind

of confusing now that I’ve got it I can just execute it again and give it like

one argument of like hello notice how it prints hello on a line by itself you do

do it again dudes and notice how every argument I give it it just prints it no

matter how many I do I can go a b c d e f g I could probably do this so many

times that I exhaust you know a long integer which is would be a horrible

endeavor but yeah everything that I put on there it just loops through it and

prints it so when you are linking with GCC because you’re probably using a

if you’re just linking with GCC.

GCC makes it really, really easy

to access the command line arguments.

Imagine now instead of just printing these things,

you used them to somehow decide

what your program was gonna do.

Maybe the user will give you a sub command.

Like if you’re a Git user, we say Git status, right?

So the Git says like, oh, you Git launches

and it goes, you want the status of something?

Yeah, sure.

So in your program now,

you could read what the user typed,

figure out a way to parse it and interpret it

have your program’s behavior adjust to whatever the user typed in okay that’s it for this video

the next video I’m going to post is how to do basically exactly the same thing but using pure

assembly without linking against GCC so like LD is going to be the linker just like pure assembly

no extra libraries okay thank you so much for watching this video I hope you learned a little

tell your friends and 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 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

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

or just I’ll be able to keep making videos in general. So please do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night and I just wake up because I know

somebody subscribed or followed. It just wakes me up and I get filled with joy. That’s exactly

what happens every single time. So you could do it as a nice favor to me or you could troll me if

you want to just wake me up in the middle of the night, just subscribe and then I’ll just wake up.

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

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

Thank you.

The post Command Line Arguments in Yasm Assembly with GCC: A Practical Guide appeared first on NeuralLantern.com.

Hey coders, ever wonder why your program’s acting funky? Join me to master debugging with xxd! This vid walks you through inspecting text or binary file output at the byte level, catching sneaky characters like null bytes that mess up automation or school assignments. From assembly to redirects, learn practical tips to ensure clean output. Perfect for beginners and pros alike! Hit subscribe for more coding tutorials, and check my site for extra goodies. Let’s debug smarter, not harder!

Introduction to xxd 00:00:00
Purpose of debugging 00:00:12
Why debug output 00:00:23
Example assembly program 00:00:56
Running the program 00:01:26
Corrupting the message 00:01:45
Terminal vs automation 00:02:27
Installing xxd 00:03:16
Redirecting output 00:03:29
Using xxd to debug 00:04:33
Identifying newline issue 00:05:36
Finding zero in string 00:06:04
Debugging conclusion 00:06:32
Weird symbols warning 00:06:47
Debugging standard error 00:07:23
Closing remarks 00:07:40
Call to subscribe 00:07:56
QR code and website 00:08:45
Request for comments 00:09:09
Fade out 00:09:31

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, I’d like to talk to you about debugging your program’s output with xxd.

What am I talking about? Well, there’s a program called xxd that can sort of inspect

at the byte level the output of some text file or binary file. It’s really useful for

inspecting things. Why would you want to debug the output of your program? Well, I don’t know.

print a message from your program the program might be printing some extra characters somewhere

or some garbage and maybe maybe you don’t notice because you’re sort of looking at your program’s

output in the terminal but then maybe if your output is being sent to another program

for the purposes of automation or like you’re getting a grade from a class or something like

that then um well it can it can sort of it can sort of get you without you realizing what’s wrong

you an example real fast of what i’m talking about i have a simple assembly program here this is not

a video about how to write assembly code so just assume that you know if you want to know assembly

see my other videos but um i’m just going to print a simple message i’m just going to print

hello i feel awesome and then the length of the message i’m specifying here you don’t know you

don’t need to know too much about this for this particular video i’m just printing a string in

assembly that’s all i’m doing and then here you can see i’m just kind of like printing it and then

I’m just kind of like printing it and then I’m like exiting.

So if we go back to the terminal here, I can type make run.

This is not a make file video.

See my other videos.

I want to type make run just to compile and run the program.

And then here’s the message that it prints, right?

Hello, I feel awesome.

It looks good in the terminal.

I can’t be 100% sure though, because think about this.

What if I corrupted the message on purpose?

This can happen in assembly all the time.

Wrong or if you add extra characters at the end of it or even if you have you know a corrupted register somewhere

That either reads from the wrong spot

To get a string or maybe it it writes over the string for some reason. There’s a lot of things that can go wrong

So for now just suppose that I’ve corrupted my message somehow by I don’t know. Let’s put a zero

In between the string so I’m gonna say is that it’s gonna be like H E L

0 L O and what that should do is

lo and what that should do uh well it should look like just the word hello but if i’m automating

this program or sending it in to get a grade at a school somewhere then this should you know not

match what is expected if i’m automating with like another system in some way but it should look okay

in the terminal let’s see i’m going to do clear and make run notice how the message looks the same

I feel awesome. So if I was automating, you know, if I was sending this string to another program

for automation, I might be convinced that I’m not doing anything wrong. And I’ll, I’ll think it’s

the other side that is wrong or, or our computers are just buggy or something like that. But actually

I’ve outputted a corrupted message for some reason. So how can I really be sure that my

message is what I think I’m seeing in the terminal? That’s the XXD program. Pretty easy.

apt install xxd let me see if I have it on this system oh it’s already installed

okay good so I’m gonna do clear and make run again so there it is I would like to

just redirect the standard output pipe to a file with a special command in the

shell let me just show you real fast I am definitely printing to std out the

standard pipe which is just a number one file descriptor if you don’t understand

If you don’t understand that, I have other videos, but I’m going to run the program again,

but then I’m going to redirect the output to a file and I’m going to call it stdout.txt.

It’s probably a good idea to eliminate spaces.

I think I’ve made mistakes in other videos where I didn’t put a space before or after

this little redirector symbol and I ended up creating a file just called the number

two or the number one.

But pipe number one is standard output.

So I’m going to say anything that comes to pipe one, which is standard output, I’m just

output I’m just going to redirect it to a text file. So when I hit enter notice

how nothing prints to the screen but the standard output text file that I

specified is now created. If I spill the contents of std out it still looks

normal so don’t let that trick you but watch what happens if I use xxd.

xxd std out basically xxd is going to read it as a binary file and tell me

every single character in there while I oh I forgot to change the title of that

that’s not this video but notice right here where it says H E L L O and then

right before that there’s like a little dot if you look at the dot let’s see

what is the dot it’s one two three four five six it’s the sixth thing one two

one two three four five six seven eight nine ten twelve thirteen fourteen fifteen oh there’s

fifteen characters but there’s not that many i think probably they’re packing them by two here

let me see if that makes more sense now one two three four five six one two three four five six

yeah that makes a lot more sense so the sixth uh byte not the sixth uh word uh is basically

to this dot right here and if you recall oa is a decimal 10 which is uh the beginning of a new line

you know like a carriage return line feed um 13 comma 10 so that’s what it is right there

and then so now we know that there’s xxd is figuring out here or helping us understand

that there’s a new line between slash main and then the message which if you recall that’s

exactly what happened and then when we look into our hello string there’s a dot in the middle here

string there’s a dot in the middle here what is that dot well we just have to figure out what

number that corresponds to so the oa was that dot right there so we just got to go a couple more

bytes forward one two three four bytes forward one two three four bytes forward it’s this zero right

so xxd even though the terminal didn’t help us originally xxd has helped us realize that we’re

that we’re actually printing a zero under the hood and we can’t see it in the terminal.

So we have now debugged our output. You know, depending on where you print this,

you might see nothing like in the terminal. It didn’t really show anything. But if you’re on a

webpage somewhere or some other type of thing that’s going to print the data for you, you might

see a weird symbol. I mean, it really depends. This is not something you’ll see everywhere, but

you might see a weird symbol that kind of looks like a black diamond with a question mark inside

mark inside of it or some other weird symbol.

If you start seeing weird symbols all over the place or just in a place where you know

there’s not supposed to be a weird symbol, that might be an indication to you that you

have weird values sitting inside of your string.

And then you should probably try to debug with XXD.

So that’s it.

That’s the basics for debugging with XXD.

Just, you know, file output anyway, for your information.

If you wanted to debug the standard error pipe, you could also do this.

you know because the error pipe is just a two um and that’s basically it i’m not going to

debug right now because that’s that’s too easy but i hope you enjoyed this video thank you for

watching i hope you learned a little bit and had a little bit of fun 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 uh if you could do me a please

If you could do me a please, a small little favor, could you please subscribe and follow this channel or these videos or whatever it is you do on the current social media website that you’re looking at right now.

It would really mean the world to me and it’ll help make more videos and grow this community.

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe.

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

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

it would 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 I fade

into the darkness, which is coming for us all.

Thank you.

The post Master Debugging with xxd: Inspect Program Output at a Byte Level for Automation & Clean Code! appeared first on NeuralLantern.com.

Hey coders! In this video, I’m diving into CGDB, a powerful curses layer on top of GDB that makes terminal debugging a breeze. See your source code and breakpoints side-by-side in one clean interface. I’ll walk you through setup, breakpoints, and why CGDB rocks for C++, C, and assembly projects. Watch my GDB video first for the basics (link in comments)! If you dig this, subscribe and drop a comment for more coding tips. Let’s debug smarter! #CGDB #GDB #Debugging #Coding

Introduction to CGDB 00:00:00
Recommendation to Watch GDB Video 00:00:05
Explanation of CGDB and Curses 00:00:23
Building and Running CGDB 00:01:03
CGDB Interface Overview 00:01:56
Setting Breakpoints in CGDB 00:02:18
Managing Breakpoints 00:02:53
Benefits of CGDB 00:03:47
Closing Remarks and Subscription Request 00:04:00
Call for Comments and Suggestions 00:05:30

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 everybody! In this video I’m going to talk about CGDB which is just a debugging program.

If you haven’t seen my other video on GDB please watch that first because

I go over all the concepts of debugging an assembly program, a C++ program, a C program

and it’ll be much more useful than this video.

This video is just about CGDB which is really a curses layer on top of GDB.

on top of GDB. Curses is a library that allows programmers to kind of make

graphical interfaces in the terminal so the point of this video is just to show

you a slightly different way to use GDB that’s why I’m saying go check out the

previous GDB video first but you know I think you know sometimes people like CG

to be so what am I talking about for starters pretend that I have a program

I’ve got an assembly module a C++ module and a make file you don’t know

or C++, see my other videos.

This video is only about CGDB.

But I can do, you know, make build,

just to build my objects and my executable.

And then normally, if you know GDB,

you can go GDB main and just enter the GDB terminal, right?

This is great, you can do a lot of commands from here,

but it’s not very graphical.

It does have a graphical mode, to be honest,

but it seems to be kind of glitchy,

so I’m not really gonna talk about it.

going to talk about it anyway so instead of launching your program inside of gdb you can

launch your program with c gdb c standing for curses i don’t think this is installed on the

current system so i’ll probably have to install it right okay so you can go sudo apt install c gdb

and then just enter your password

Let me do clear and then we’ll do CGDB main.

And I just want you to see that it’s got two windows.

This is the whole point for me anyway.

The bottom window is actually GDB.

So anything you’ve learned there is going to apply here.

But the difference is that there’s a top panel that shows your source code.

So I don’t know.

Let’s suppose for the sake of argument, I’m going to hit escape so I can go up to the top panel and kind of scroll my source code.

Let’s suppose for the sake of argument, I want to break every time I hit line 36.

time I hit line 36 okay I’m kind of scrolling I just hit escape to get into the top panel

I’m gonna hit I for interactive mode which lets me go back down to the bottom panel

and then I’ll just say B for breakpoints main.cpp line 36 and then just double check that I entered

my breakpoints correctly and then I’ll run the program again if you don’t know GDB see my other

video but notice how I started to run the program and then it immediately hit a breakpoint and then

the top pointed to that line where it broke if you don’t believe me i’ll do another breakpoint

at line let’s see main.cpp line maybe uh 32 and then another one at uh 39 well maybe i should

have done 40. yeah i should have done 40 and then 33 so that means i probably want to uh

delete that one at 32 so i’m gonna delete whichever one shows up at 32 that’s number two

and then info breakpoints again okay so now if i continue the program also by the way notice how

the top panel is showing red line numbers for my breakpoints if i hit c for continue

and it hits the same breakpoint again if i hit enter to continue one more time it’ll do that

eventually it hits a different breakpoint and notice how the source code

moves down to the appropriate breakpoint so for me personally i kind of like to just regularly you

and then go back and forth between that and my code window.

But some people really love having both their code and GDB in the same terminal

so they don’t have to go back and forth between windows.

So if that’s you, then maybe CGDB is for you.

My little doggy wants to go pee.

Okay, that’s all I have for this video.

Thank you so much for watching,

and I hope you learned a little bit of stuff and had a little bit of fun.

I’ll see you in the next video.

Hey, everybody.

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 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 control 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 you

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 uh

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

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 CGDB: Boost Your Debugging with GDB’s Curses Interface in Terminal appeared first on NeuralLantern.com.

Hey everybody! Ready to crush those pesky bugs in your C++ and assembly programs? In this video, we’re diving deep into the GNU Debugger (GDB) – the ultimate tool for tracking down crashes, inspecting variables, and mastering your code. From setting up debug symbols to navigating call stacks, setting breakpoints, and even debugging assembly registers, this fun and relatable guide has you covered. Whether you’re a beginner coder or a seasoned dev, you’ll learn practical tips to level up your debugging game. We’ll also tackle null pointers, create GDB scripts, and explore why your program might be misbehaving. Stick around for a few laughs and some serious skills! Don’t forget to subscribe, hit that like button, and check out my website for more coding tutorials. Let’s debug like pros together!

Introduction to GNU Debugger 00:00:00
What is a Debugger 00:00:20
Debug Symbols Explanation 00:02:08
Compiling with Debug Symbols 00:03:13
File Size Comparison 00:05:30
Installing and Launching GDB 00:06:21
GDB Console Basics 00:06:55
Attaching GDB to Program 00:08:12
Running Program in GDB 00:09:09
Handling Program Crash 00:13:02
Understanding Call Stack 00:14:05
Navigating Call Stack 00:18:13
Inspecting Variables 00:19:08
Null Pointer Issues 00:21:25
Using GDB Script 00:25:10
Setting Breakpoints 00:27:04
Managing Breakpoints 00:28:37
Continuing Execution 00:30:41
Debugging Assembly 00:33:24
Global Variables in Assembly 00:35:43
Advanced GDB Commands 00:38:31
Conclusion and Call to Action 00:40:22

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 everybody! In this video I’m going to show you how to use the GNU Debugger to

debug your C++ and assembly programs.

You can also use it for C and some other stuff but we’re just going to focus on

C++ and assembly. What is the GNU Debugger and what is a debugger in the

first place? So for starters the GNU Debugger it’s like it’s called GDB and

the db you can imagine that stands for debugger something like that and the g stands for gnu i

personally don’t know how to uh pronounce gnu so i just say gnu because it it feels more fun to do

it that way it’s more interesting i think probably some people just say new but i don’t like that

because the gdb debugger is really old and robust and powerful it’s not a new tool it’s it’s an old

new debugger someone’s always going to ask what was the old debugger and then I say this is the

old debugger the new debugger is the old debugger anyway so we’re going to use the GNU debugger

if you haven’t yet watched my video on caveman debugging you probably want to watch that first

just for like some basics of you know why you might want to look at information in your program

but for now we’ll just assume that you already know what’s going on with just like why you would

know how to make make files see my other videos but here i just have a basic make file all it’s

really going to do is just sort of compile a very simple program and add debug symbols into it so

let’s double check that i’m actually doing that here yeah there we go okay so the first thing

that i should probably show you is uh we are compiling a c plus plus source module so i’ve

actually using c but i i have that left over in there anyway and then we’re assembling something

in yasm we’re linking with g plus plus because we want to have a hybrid program and we’ve got

all these flags here those are just variables and so uh so now before i can debug with gdb

i’ve got to talk about something called debug symbols what are debug symbols imagine just a

bunch of extra information explaining all of the design and variables and everything inside of your

about your code stuffed directly into the executable.

So imagine, you know, when we compile a C++ source module

into an object file, usually that’s just, you know,

assembly at that point.

But when we add debug symbols, we’ll have a bunch of information

that can help the debugger figure out where we are in the program,

what the variables look like, you know,

a bunch of extra information to help the debugger pretty much.

The assembler will put debug symbols into the object code

symbols into the object code that you generate the compilers will do that the linker will do that

and so it’s important to understand if you don’t generate debug symbols when you’re compiling and

linking your code then your debugger won’t actually be able to do anything it won’t understand what’s

going on you can debug it but like you’re not going to see anything that’s very uh that’s useful

so let me show you real fast i’m going to do make clean and then i’m going to say make build

that I do not have debug symbols.

All right, okay, if you don’t know how to compile and link from the command line, see

my other videos, but for now it looks like we’re not generating debug symbols.

So if I list the contents of my directory here, just note the size is real fast.

I have an assembly module here that I’m calling ASI.asm, ASI for assembly, and then we’re

assembling it down to an object file.

Notice how it’s just 656 bytes, very small.

plus plus module that I’m creating here is compiling to an object file that is

about four and a half kilobytes so you know not too big the final executable is

called main and it’s about 17 kilobytes so this is without debug symbols when

you’re compiling something on your own you need to add extra switches to enable

debug symbols so you can see here in this make file that I’ve made and again if

you don’t know how to make a make file or compile or link or anything see my

But for now, I’m just going to assume you kind of know your way around to makefile,

or at least you can kind of infer what’s going on.

So I’ve commented out a different version of this variable for the flags of my C++ compiler.

If I uncomment this and then comment out the other one,

you’ll notice the only real difference is this part right here, dash G dwarf 2.

Usually in C++ compilation, it’ll just be dash G to generate debug symbols,

and then the symbol format will default to a format called dwarf2 so I don’t know for these

tutorials I like to just specify the full format but you can just say dash g in your c++ compiler

and linker we do the same thing for the linker down here so I’m going to uncomment this

and comment that and the only difference is just g dwarf2 so I’m just telling my linker that I also

want debug symbols in there too then we do the same thing for the assembler so I’m going to

So I’m going to uncomment that and comment this other one.

And the only difference is that in the assembler,

we kind of have to specify it a little bit differently.

Instead of G dwarf dash two,

it’s just G dwarf two as just one string.

And I think with Yasm, you have to specify the debug symbol format.

So just keep that in mind.

So now I’ve turned on all the debug symbols.

I’m going to do real fast, make clean and make build one more time.

And then if I list everything,

list everything let me just double check that it’s building the symbols now right okay good

notice that the files are bigger so this asio um file is now 1.8 kilobytes instead of you know

half a kilobyte the main.o object file is now 36 kilobytes instead of only 4.5 and the executable

main is 36 kilobytes instead of just 17. so you can feel it already right like there’s a bunch

extra information sitting inside the object files and the binary which allows us to debug our program

okay so now that we’ve generated debug symbols in our program we can actually think about starting

to use gdb so gdb is a program just gdb by the command line if you don’t have it in your system

already you can go sudo apt install gdb or depending on what system you’re on maybe a or

or whatever your package management program is,

but we just need to install GDB.

On Ubuntu and Debian, I think,

there is a meta package called build essential,

which will give you a bunch of compilation tools

and make file stuff and whatever.

So I’m just going to assume at this point

you already have GDB on your system.

To launch GDB and go into its console,

just type GDB by itself.

So now we’re inside of the GDB console or terminal.

console or terminal. We’re no longer inside of a bash terminal. We can’t type normal commands.

Let me show you real fast. Here’s the first command you want to learn on GDB. It’s called

quit. Never quit. Never surrender. So, you know, normally if you’re at the command line,

you can do something like cat, etc. OS release just to see what operating system you’re using.

So you can see for this virtual machine that I’m using right now, I’ve got like Ubuntu 22 on there.

If we go inside of GDB, we can’t use regular bash commands anymore or regular operating

system commands.

We can’t say cat, et cetera, OS release because we can now only use GDB commands.

We’re inside of GDB already.

Notice how it says undefined catch command.

I don’t know what you’re talking about, dude.

Okay.

So remember we do a Q or quit to get out.

You can actually just type Q.

A lot of commands that I’m going to be talking about.

going to be talking about you can abbreviate them with one or two or three letters and it totally

works just for speed so now that we know how to enter gdb and now that we also know that we have

already compiled our program with debug symbols we can attach gdb to our program i mean what’s the

whole point of a debugger we most of the time we will just have our debugger attached to our program

and launch it or i guess launch it while it’s attached you can also attach to a running program

but we’re going to launch a program and stay attached to it.

And then we can sort of catch crashes and see what’s going on.

Or we could also tell the debugger to stop the program at certain points in time,

like when we hit a certain line number or when a variable changes or something like that.

And then we can look around.

We can look at all the variables, look at the state of the program,

even change things if we wanted to.

We can look at all the registers if you’re coding in assembly.

So it’s pretty useful.

Anyway, I’m going to go gdb and the next command we’re going to learn is file, which just tells

gdb to attach to a program so that we can run it.

So, you know, the name of our program here that we compiled is just called main.

And so if I type file main, then gdb should load up that file and try to parse its debug

symbols so it can begin debugging for you.

Notice how it says reading symbols from main.

you know if we did a typo or we had something with no debug symbols it will give us some sort

of an error message so for now i’m just going to quit and then go back in just to make sure that

it’s all clean and we’re going to do file main now it attaches once it’s attached that’s not i guess

it’s not technically attached because the program’s not running but once it has loaded the debug

symbols for that program we can run the program with the run command in gdb also kind of interesting

If you have debug symbols that are generated separately from your executable,

you could tell GDB to load the symbols file and then run your program.

That happens a lot in Linux where people release the non-debug friendly version of a program

and then they’ll release the debug symbols separately if you’re interested.

Anyway, so I’m going to type run and it’ll run the program.

Notice how GDB kind of tells us that it’s starting up now.

here’s like a thread debugger that’s being enabled and it says we’re using this library to do it and

then it says hello you know here’s the hello message so the program is actually running that’s

not my name i wish it was and then it prints the final result and then gdb says your program exited

normally on newer versions of gdb there’s a setting i think by default where it’ll ask you

if you want to start a debug daemon a debug info daemon or something yes or no you can usually just

without actually having to type n.

It’s a little bit faster.

So the whole program ran and finished.

If I type run again, it does the same thing.

In GDB, if you hit enter without typing anything,

it ends up repeating the previous command.

So I’m not going to type run.

If I just hit enter, are you serious?

GDB made me into a liar.

Well, most of the commands will repeat if you hit enter.

I guess not the run command.

So I’ll type run again.

And okay, I mean, the program is pretty good, right?

So if you watched my…

It’s not pretty good.

watched my it’s not pretty good it’s a nonsense program I mean it it doesn’t crash is what I’m

saying if you watched my previous video which you should on caveman debugging I had this uh you know

nonsense portion of code that just sort of updated a variable and we pretended that we were confused

and we didn’t understand what was happening and uh we used gdb to debug it so what I’m going to do

either let’s say we’ll start off with throwing an exception and then we’ll try to use a no pointer

and then we’ll see a crash and then after that I’m going to start using breakpoints where we can stop

automatically inside of our program to print the state of the program print the variables

and then I’m going to do that first in C++ and then hopefully I’ll remember to do that in

assembly right after it’s basically the same thing only with assembly you don’t really have

you know a bunch of variables everywhere you just kind of have registers and maybe some globals

globals but it’s going to be the same deal okay so let’s pretend that uh we are gonna have a crash

okay so this program just kind of runs later on we’ll figure out why the result is wrong we’ll

just pretend that it’s wrong but for now we’ll just say how about we uncomment this line right

here and what will happen is when we’re running the main loop at some point in the loop we get

When F gets called, the input will be looked at here.

And if the input is more than one,

which is definitely gonna happen like right away,

then we’ll call on the G function.

Then the G function will just throw an exception.

We’ll just pretend that something really bad happened.

You crashed or you actually did throw

and you didn’t catch your throw,

or maybe the system threw something at you

or another library threw something at you

and you didn’t catch it.

So just basically a program crash.

Let me run this real fast.

So make run just to show you that the program crashes.

Make run at this point is the same thing as just kind of executing the program.

But you can see that it says terminate called after throwing an instance of runtime error.

And then there’s the message, oh my gosh, and then aborted core dumped.

That’s not good.

So now let’s try to understand why.

Why did that crash?

Pretend you don’t know that it happened in G. You know, you’re trying to investigate.

So we could type GDB and then we could type a file to load the debug symbols, but it’s a little bit faster just to type GDB main and just sort of name the file that you want to load right away.

So if I do that, notice how it automatically tries to load the debug symbols from main.

Then I can just type run and then the program tries to run and notice how it actually catches the crash.

If you look down here, terminate called after throwing an instance of runtime error.

throwing an instance of runtime error so that’s what the program thinks is going on but then the

program is trying to terminate but then down here gdb is like wait wait wait i just caught you know

a termination uh getting invoked here and you can see this is sort of system code like we did not

create this source file p thread kill we didn’t write that that’s the standard library and there’s

a function here called p thread kill implementation with those you know fun c underscore prefixes

prefixes everywhere and so this is like some sort of a c source file and we don’t have that file on

the system so we can’t really debug that file lucky for you most of these standard libraries

work all the time so you don’t really need to debug them you need to debug your code instead

of the standard library code so the question really is how did i get here how did i get to

this crash so the next command we’ll learn in gdb is just the where command the where command will

I’m going to release a video in the future that kind of explains call stacks, but basically

imagine a abstract data type, a data structure called a stack. And every time you want to add

data to the stack, it just sort of stacks up on top of the last piece of data. So like if I add

something, let’s say I want to add the number five, then I would just add the number five on top of

the stack, right? If I wanted to add the number 11, then I would just add the number 11 onto the

off of the stack and the stack is a really good data structure to uh sort of give you a trail of

breadcrumbs to know where you got where did you come from so we call this the call stack because

what’s happening is every single time you call a function then the new scope and then you know the

new function that you’re invoking um it has something called a call frame full of information

current address is and all that stuff.

And we’ll just call that chunk of data that belongs to one instance of a function call.

We’ll just call that a call frame.

And so if you’re stacking call frames one on top of the other,

then we call that whole entire thing the call stack.

And this is what allows us to use recursion and all these complicated call graphs and everything.

It’s really simple, but it’s really powerful.

So you’re looking at the call stack.

Each one of these lines is the call frame or is a call frame.

And so for example, if you just look at number zero here, you’re looking at call frame zero,

which is the closest frame to wherever the crash occurred, which is if you look at it,

that’s exactly what we were looking at when we saw that original message, right? Call frame zero.

So that’s not really useful. You want to go down to higher numbered call frames or I guess

physically lowered number call frames and just kind of scan it until you find some code that

raise no abort no none of this stuff is ours live standard c plus plus no the first frame that

contains code that is ours is call frame number nine or i guess like nine away from our current

position so i guess find the physically highest call frame that is your code or the lowest numbered

call frame that is your code and it’s telling us right here all right we uh we actually seem to

So if I go to 65, right there, it tells you exactly where the crash happened.

If you’re still trying to figure out, well, how did I get to that crash?

I don’t know how that actually happened.

Just keep looking down further in the call frames.

The next one, call frame 10, says, well, we were inside of function f with input equals

three at main.cpb line 46.

So if I just go to 46, I can get another clue.

I can go, all right, so for some reason we called g.

Imagine again, this program is much more complicated.

And then if we’re still confused, we just look down at another one and it’s like, well, this all this whole mess started at CPP main dot CPP line 28.

So if we look at line 28, it’s like, well, we were inside of this loop and we we called the F function and then the F function called the G function.

And then G just kind of did a throw. So that gives us a lot of information.

All right. Next thing we can do is we can sort of move up and down the call stack, because right now we’re sitting at call frame zero, which is just the system code.

which is just the system code, but maybe we don’t understand why the throw actually happened at,

let’s say, line 65, right? So we can use up to go up in the call stack to a different call frame.

So if I hit up, notice how it mentions that we’re now in frame number one instead of zero.

And if I do up again, we’re now in frame two, which is a little bit closer. We can use the

trick finally where we hit the enter key instead of repeating the command. So I’m just going to

and hit enter a couple times until we eventually get to our code,

which I think was supposed to be at frame nine.

So I’m just going to hit it a bunch of times until we get to frame nine.

Now we’re looking sort of back in time at that point

because all these other frames actually did get invoked,

but we don’t really care about what was going on inside of them

because they probably did their job correctly.

We’re looking at our code, so we’re going back in time

right when we were doing this throw.

Oh no, we threw. Why did we throw?

well there’s another command in gdb called info locals

okay the info locals uh there’s there’s really not much to this maybe maybe let me do this again

a equals five and uh then i’ll just say a plus plus just so that we have a local variable

i forgot that gdb doesn’t consider the incoming arguments as locals so there was nothing there

real fast uh gdp oh let’s do make build and then gdp main and then run and then we have a throw

and then i say where and then i go up up up up to a frame you can also use the keyword down if you

go too far if you want to go you know back down in the call stack but i’m just going to use up

okay so now we have it here now finally i think i can do info locals just to see the local variables

notice how the a variable is there now because I just added a local variable a a moment ago

you can also print things directly you can say print the input incoming variable if you’re in

assembly you can also print registers you can say info registers like that and you’ll get a nice

print out of all the registers you could print individual registers you can say let’s print

register r12 you can print register r12 as binary by saying I think it’s p slash t

or print slash t yeah we can probably just do print slash t also

t stands for two because they’re it’s a base two number system

does that mean there’s a p slash h or a p slash f for 15 or 16 s for 16 i don’t know i haven’t

tried that is it going to work hang on p slash s bar 12 it’s not going to work nope didn’t work

i think it thinks it’s a character point or something but anyway so we can print a lot of

So we can print a lot of stuff.

And like I said before, we can go up and down the call stack.

So I can go down a couple times and then go back up again.

And now we can assume that we’ve kind of debugged, you know, where the source of the error was.

So I’m going to comment that call out to G and run the program again one more time with a different error.

So I’ve commented this code out from before, but just imagine now that we’re going to use some pointers.

We’re going to start off with a pointer called P.

a pointer called p we’re going to set it to null at the beginning and then we’re going to just

kind of allocate it and then we’re going to set you know a value and then we’re going to dereference

it and dereferencing a pointer just kind of sets the first value in an array you can do that and

then we’re going to deallocate the pointer and then how about right after that we do something

really really naughty we say p at some index is equal to a five this should be this should be a

a program crash because we deallocated p already at that point we would be dealing with junk data

if we tried to dereference p but to make it even more clear that it’s naughty we’ll set it to a no

pointer and then we’ll try to actually use it so let me let me just restart the program real fast

i’m gonna do quit yes and then we’ll do make a debug just so you know my make debug is just a

Let’s see, where’s that? Where’s that? Where’s that? Do I not have a debug shortcut yet?

Oh dear. I need to add that before this video is over. You know what? I’ll add it right now.

We’ll do this run and we’ll say debug, make debug, and it needs to build first. And then I’ll say

debugging the program. And then we will do the GDB binary and give it an argument of

the executable and then later we can we can upgrade this to take a little script of commands

because the commands are going to start getting out of control so now if i do make debug if i

didn’t screw it up now it at least goes in there and i’ll do run and then we have a seg fault and

notice how it tells us right away hey you have a seg fault right here you’re accessing invalid

memory let’s do info locals just to see what’s up oh the p is actually a zero that’s a null pointer

explicitly oh whoops you know oh what have I done but it’s a really good idea to set your

pointers to null after you deallocate because if you don’t you might end up with undefined

behavior where sometimes the program doesn’t crash while you’re overriding junk data or reading junk

data but sometimes it does and you’re not really sure like why does it work sometimes and why does

it not work sometimes so let me comment this out and see if it’ll crash uh let’s just let’s just

make debug and then i’ll do run and then if we do info locals oh yeah okay so this is uh

it did seg fault so that’s good uh if we were unlucky then the program wouldn’t have crashed

it would have just started behaving strangely and um when we print out the value of p notice how it

looks like a pointer still like if we were to debug the program and print the pointer value

then it doesn’t really it looks the same it looks the same after we deallocated it right so that

this is called a dangling pointer meaning you deallocated the pointer but you forgot to set

it to null afterwards so then later when you’re trying to debug the program it’s a little confusing

because you’re like that looks like a regular pointer what did i do wrong so um it’s really

good practice to set your pointers to null right after you deallocate them that way when you’re

debugging later because something crashed instead of seeing a memory location on p you’ll see

On P, you’ll see something that looks definitely like a null pointer and print P.

Then it’s way easier to realize, oh, whoops, I was trying to use a dead pointer, a pointer that I deallocated.

Hopefully that makes sense so far.

Next thing I want to do is a small upgrade.

I can’t remember if it’s dash X or dash EX.

I think it’s dash X.

But you can write a little script.

I have a little script here called Good Doggo.

called good doggo you can just make any file name it anything you want i’m so i’m just naming it

good doggo.txt because my dog’s taking a little nap behind me as usual um but you could name this

gdb.txt or whatever it is you want so you can put inside of this script file any command that you

want gdb to execute when it launches so let’s just comment this stuff out real fast and i’ll do

I’ll just do run maybe for starters.

Because whenever I’ve been launching for debug,

I launch with GDB and then I type run manually, right?

So I want to save a little time.

So good doggo is the name of the script.

So when I invoke GDB, I am going to,

where is it right there?

Okay, it’s GDB.

And then I’m going to go dot, I think it’s X.

And then I’m going to say good doggo.txt.

If it’s not dash x, then it’s dash ex.

One of those executes the command that comes after,

and one of those executes the command script that comes after.

Let me just double check that this actually is going to work.

So make debug.

All right, okay, so it was dash x.

Dash x specifies a script that will be run.

Dash ex just specifies a command that you can put right in there.

Like I could have said dash ex run, and it would have ran right away.

But the script is more convenient, right?

Because we can save typing.

So notice how it ran right away and then there’s a seg fault.

Okay, so now let’s go a little bit deeper.

Let’s change this to false again now that we understand like null pointers and all that

stuff.

So we can just basically deal a little bit more with only what the main loop is doing.

Suppose we just still don’t really understand what the loop is doing, why our answer is

you know, good or bad.

So maybe I want to do a breakpoint at the top of that for loop.

loop gets to the top of its iteration, I want the program to pause so I can look around.

So I’m going to set up a breakpoint on line 22. And here’s how you set up breakpoints

in GDB. I’m going to go ahead and maybe do the terminal for now. And then I’ll stick that into

the script next. I will not remember that it’s line 22. That’s okay. I’m going to do quit.

And I’m going to do make build. Then I’m going to go GDB main just to jump in there.

and then i’m going to say break or just the letter b just to make a break point you type the name of

the source code file that you want to break in and then a colon and then the line number where

you want it to break so i think i think it actually was line 22 oh i can see it and then

maybe i want to have it break at line i don’t know maybe right here line 25 right before it increases

And then so I’m going to do an up arrow to just repeat the command so I can edit it real fast.

And then I’ll break again at line 28 and then maybe 30 and then 32.

So I’m going to go 28, 30 and 32.

30 and I’m just making up break points.

I just want to inspect the program and then maybe I’ll break at line 36 so I can see what the final answer is.

So I just have a bunch of break points set up.

Remember when the program is running now under GDB, every time it hits one of those lines,

every time it hits one of those lines the program will pause and i’ll have a chance to look around

at the variables and things so i’m not sure if i’ve set up the breakpoints correctly i can say

info breakpoints and it’ll show me all of my breakpoints notice how you can enable them and

disable them so let’s say for the sake of argument i want to disable the breakpoint at line 30 because

maybe i don’t really need that right now but i kind of want to keep it in the system for later

disable four because it’s number four.

It’s breakpoint number four.

So I can say disable four.

Then if I do info breakpoints again,

notice how there’s a little N on there,

meaning breakpoint four is disabled.

So I could re-enable it with a four

and then go info breakpoints again.

So now they’re all enabled.

I am going to maybe copy this into the script file real fast

so I don’t have to keep typing this over and over and over again.

Imagine if every single time you changed your program and recompiled it you had to type all of the breakpoints from scratch

That’s why I want you to use this little breakpoint script

So we’re going to do B to break at main.cpp line 22 and 25 and

28 and

30 and 32. I should have copy pasted the three dang it 36

And after we’re done setting up all the breakpoints

show me the breakpoints just so I can have a visual reminder. Keep in mind if you change too

much of your source code then you’re probably going to have to update these lines and that’s

okay but it’s a good idea to just at least you know kind of look at them a little bit so that’s

why I’m saying info breakpoints. And so then remember again the makefile all it’s doing when

I type make debug is it’s just launching this command right here it’s just saying gdb with the

with my gdb script so let me quit to get out of this and then i’m going to say clear and make

debug and notice how it did all that stuff for me it added the breakpoints it showed me the break

points and then it ran the program like i told it to and then it already broke on a breakpoint it

already break it break breakened it’s broken i don’t know i don’t think it’s broken uh so we’re

So we’re on breakpoint number one on line 22.

And here’s the for loop.

I can type all of my inspection stuff.

I can say info locals.

I can say print I, I can say print A, I can print whatever I want.

And then when I’m done kind of looking around and inspecting things,

I want to continue the program.

I don’t want to just stop it here.

So I’m just going to use the command continue.

And it goes right to the next breakpoint.

If I want to, you know, continue again, I can hit C.

continue again i can hit c or i can just hit enter you know to just sort of keep continuing as i

inspect and print things let’s see when can i get to break point number one is that what’s going on

here hang on a second what is break point number one oh i know what to do info break points

break point number one is that main.cpp line 22 is that actually going to get hit oh it’s

having issues here with my GUI. Okay. Line 22. Okay. So it’s not really hitting that anymore.

I guess it’s not going to think that it hits the top of the forelip. Okay. So I guess breakpoint

two is where we’re always going to be hitting. So let’s just suppose that I’m continuing until

I hit breakpoint number two. Suppose that the next 10 times I see breakpoint two, I don’t

actually want to stop and break on it. I just want to skip the next 10 iterations for some reason.

some reason you can say continue 10 and it’ll skip the next 10 times that it hits the number two

notice how if i hit continue a bunch of times we’re not really seeing the break point number

two anymore we’re seeing other break points and then eventually if i hit it enough times

we’ll probably see two again oh my god oh my god are we seeing it yet no

Okay, wait, are we seeing I’m freaking myself out.

Okay, so let’s continue 10 times on breakpoint three, then we’ll only see

breakpoint four, I guess.

So we can do continue 10 times on breakpoint four.

What is going on here?

Did I write this program in a weird way?

Hmm.

Well, trust me on this.

Let’s continue 100 on breakpoint three and then continue 100 on breakpoint four.

breakpoint 4. Okay, so now we’re just done with the whole entire program. I guess there must have

been a 2 there that I missed. So now we’re finally on breakpoint 6, which is when everything is

finished. Let me show you real fast that we can add more breakpoints in assembly just to prove

that we can debug assembly real fast. So if I want to debug assembly, I just have to type the name of

that source code file. If it was nested in a folder, like if you had like a complicated hierarchy of

of source code files you would just need to type the relative path but for now I’m just going to

be able to type the name of the file so assy.asm and let’s suppose that I want to break at line

16 just so I can see the registers that I set up so I’m going to do 16 and then I’m going to break

at assy.asm line 16 and then I’m going to run and that actually never gets called does it no no it

called does it no no it gets called I think I have a call up here somewhere

nope I don’t have a call okay let’s make a call this is gonna throw off all of my

C++ breakpoints so I’ll just comment them all out right now comment them all

out so I don’t have to redo them and this is a hybrid program so I’m gonna go

extern what is it extern C make a block where I name the function the reason we

name mangling so the AC symbol is going to show up as just its regular function

name rather than a bunch of extra stuff indicating the prototype so that we can

do overloading so we’re just going to disable that and then at the very top of

the program I’m just going to call it this should hopefully work let me just

do a regular make run just to make sure the whole program compiles okay now

debug script we’re gonna break on line 16 which is going to be letting us see

the registers okay so I’m gonna go make debug notice how it hit the breakpoint

in the assembly just the same as the C++ and we can print whatever we want now so

I’m just gonna say info registers and if we look carefully we can kind of see

that we modified racks REX is 15 so that’s expected RDI is 20 which is

R12 should be a giant number. Where’s R12? Right there. So you can see the state of your program at any point in time just by breaking on it.

I’m breaking on a certain line. So this is tremendously useful for debugging not just for higher level languages but also assembly.

What else can I do? Oh let’s put a global in the data section. So I’m gonna do, I don’t know, my thing or something like that and we’ll call it a byte array and I’ll just go hello.

I’ll say we have a thing one and a thing two.

Something like that.

And maybe thing two is a null terminated string,

whereas thing one is a regular thing.

We should be able to print those symbols.

If that’s not true, I’ll come back at a later time

and show you how to do it.

Anyway, so we’ll do make debug

to just kind of assemble everything again.

And we know how to do info registers.

We can print, you know, one register in particular,

print R12 if we wanted to.

History has not reached.

History has not reached 12.

Oh, I got to put R12.

Yeah, then we can get the, wait a minute, wait a minute.

Oh, I threw off the line numbers because I added the variables up here.

So now we’re going to break at 21.

Let me just fix that.

21.

We’ll do a quit.

Make debug again.

And now we’re at 21.

If I say info registers, we can see R12 is that big value.

you, but we can also print R12 directly. And we should be able to print my thing one, hopefully,

has an unknown type, oh, we have to cast it. So we can do like basic casting in GDB. So I’m going

to say this is a character pointer. Remember, all of the assembly symbols are basically pointers,

unless it’s an EQU, EQU variable. In that case, it’s more of a define. So I’m going to print

and then it says error cannot access the memory add address

what the heck did i do wrong how about that cannot access that all right i’ll come back in

another video because this wasn’t something that i prepared for just to print strings in globals

i’ll come back at some later date in the future like five years from now and i’ll just show you

how to print globals but i hope if you’re in assembly you probably don’t need to worry about

You just have globals, but the real problem for you is going to be what’s inside of your registers and so forth.

You can also deref, I think.

Let me see.

Okay, I’m going to move on from that.

So anyway, we got a script and we got a lot of basic GDB commands.

Is there anything else that I wanted to show you?

Let me just look at my notes real fast here to make sure I’m not forgetting to say anything.

make sure I’m not forgetting to say anything.

So we’re going to do debug symbols, console, quit, attach to binary,

launching the program, uncaught exception, breakpoints, info, delete,

enable, disable, run, continue, end times, info registers, printing.

Oh, we can print a register in binary.

Forgot to show that.

So we are at a breakpoint, I think.

And if we printed R12 with the regular print, we can also do P slash T to just

p slash t to just sort of print it in binary if you want to i think i might have said that already

either that or i said that like a couple days ago to some and then we can do info locals and

then print a variable and then we get the script file and then we can quit okay so i think this is

pretty much everything that i wanted to show you you now have a basic idea of what we can do inside

of gdb but keep in mind there is so much more you can do in gdb than i can fit in one video

can type help and you can see a list of other major you know areas that gdb can handle um you

can do uh let’s see i think it’s help and then like we’ve got information on aliases breakpoints

data you know whatever we can do i think help breakpoints to see more information on breakpoint

commands yeah so all of the things you can do with breakpoints is like all of these commands here

one page we have to enter to see one more page or see to see all of the results without using

paging anymore so i’m just hit c and so there’s like you know we can save trace points we can

try to catch exceptions we can enable disable break points there’s like unwinders which i’ve

never even used we can bookmark things we can you know start tracing memory we can rethrow

variables so just keep in mind gdp is incredibly powerful this video barely scratches the surface

but for a programmer who is new to debugging i think this will be very useful to you i hope it is

anyway thanks for watching this video i hope you learned a little bit of stuff and had a

little bit of fun um i will see you in the next video rest yourself and take a nap and have fun

and hug your your loved ones okay I’m out see you later 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

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

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

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

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

videos in general so please do 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

That’s exactly what happens every single time.

So you could do it as a nice favor to me,

or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe, and then I’ll just wake up.

I promise that’s what 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.

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

watching this video and enjoy the cool music as I fade into the darkness which is coming for us all.

Thank you.

The post Master GNU Debugger: Debug C++ & Assembly Programs with GDB Like a Pro appeared first on NeuralLantern.com.

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

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

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

Why watch?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

It’s just to show you that you know

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

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

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

So, um, let me run the program real fast

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

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

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

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

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

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

What did I do wrong?

TempResult was not declared in this scope.

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

Line 59, I probably left something out.

Oh, because I just changed it.

I forgot to put it back in there.

Return tempResult, we should just return input times two.

And I’m just making this up.

It’s not really like a valid algorithm.

Okay, so we run our program.

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

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

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

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

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

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

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

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

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

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

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

So I’m just going to go Cout.

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

which usually goes to the terminal.

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

So we’re going to do Cout.

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

if you are programming in assembly,

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

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

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

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

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

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

but I want to try to label the for loop.

And maybe instead of leaving those parentheses blank,

I could say iteration number i right there,

or maybe I could do iteration i.

That would be pretty good.

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

so that the i keeps increasing.

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

and I’m going to say i.

Then I’ll print a new line.

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

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

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

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

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

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

And then maybe at the bottom of the for loop,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

when we were finished with the iteration.

It seems to have gone up by a certain amount.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

and then

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

I’m gonna leave that be for now though

leave that be and

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

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

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

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

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

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

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

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

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

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

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

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

And then another new line.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Do an end L.

And then I’ll make a temporary variable here.

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

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

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

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

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

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

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

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

calling some other function and so forth

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

you know, block out the rest of the statement.

That’s called a short circuit.

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

Okay.

And do that.

And then the C out there.

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

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

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

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

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

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

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

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

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

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

And if you’re writing assembly or some simpler language

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

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

that just takes a couple arguments.

You could write a function that takes a string to print

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

something simple like that.

And then in the function itself that prints,

you could call it debug print if you want.

Have it look at a global variable or define

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

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

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

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

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

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

but you can do it basically the same concept.

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

Okay, so it still works.

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

If I just change the true to false,

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

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

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

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

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

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

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

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

Just basically print everything.

Print all of your decision points.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

video

whoops what the heck

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

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

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

subscribe and follow this channel or these videos

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

us all.

Thank you.

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

Hey everyone, let’s talk linkers! In this video, we unpack the general idea of linking in programming—taking your source code, turning it into object files, and stitching them into an executable. We dive into virtual memory, how programs use offsets, and why jump instructions matter across modules. Using simple assembly and C++ examples, we’ll show how linkers lay out modules, handle labels, and make function calls work. Whether you’re a beginner or a coder curious about what happens under the hood, this is for you! Hit subscribe, scan the QR code for more tutorials, and drop a comment with your thoughts or video ideas. Let’s keep learning and have some fun with code! #Programming #Linker #VirtualMemory #CodingExplained

Introduction to Linking 00:00:00
Compilation and Object Files 00:00:05
Linker Overview 00:00:32
Virtual Memory Explanation 00:00:42
Program Memory Offsets 00:01:18
Jump Instructions in Modules 00:02:54
Module Address Space 00:03:38
Assembler and Label Jumps 00:04:02
Linker’s Role in Module Layout 00:07:15
Function Calls Across Modules 00:08:04
Marking Labels as Global 00:09:31
External Function Calls 00:10:23
Data in Executables 00:11:12
Conclusion and Call to Subscribe 00:12: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, I want to talk to you very quickly about the general idea of linking your programs.

In previous videos I’ve described exactly how to perform the linking stage when you’re compiling

a program. So you write some source code, you compile the source code into object files,

you know each file becomes one individual object file, and then when we’re done we take all the

object files and we link them up into an executable program. So I’ve talked about that

I just wanted to talk to you about the general idea of the linking stage in general.

Like what is the linker? What is its job? What is it actually doing?

So try to keep in mind for starters, each program uses virtual memory.

It uses a virtual memory space.

So obviously on your computer you have real memory,

but there’s lots of layers of abstraction between the physical hardware

the physical hardware and the program that’s running for starters the operating system uses

a paging system the memory stick the memory circuitry might be doing something else for

error checking or just you know transport or whatever so so try and bear in mind that each

program thinks that it’s it thinks that itself is kind of the beginning of memory you could imagine

it as each program thinks that its first memory location that it has assigned to it is memory

location zero but that wouldn’t necessarily be the case on the computer

your operating system probably would have come up with an offset let’s say

for example you know your computer decides to launch your program it

creates a process it finds a chunk of memory that’s available across you know

one or more pages of free memory and let’s say for the sake of argument that

the starting offset for the for the quote-unquote real forgetting the other

layers layers of abstraction the real memory location of your program is going

of your program is going to be let’s just say like a thousand I know that’s

real unrealistically too low but let’s just say a thousand and then let’s say

that your program then thinks that it starts at memory location zero that

means if your program wants to access memory location 100 then under the hood

at the last moment right before you actually hit the RAM stick or hit the

page file system a translation has to be performed so if your program is trying

what actually happens is you know the general offset for the entire program

gets added to memory location 100 and then that tells the computer or the

operating system that what you’re actually trying to do in your program is

access memory location 1100 so keep in mind all of this memory is virtual

and the modules themselves also need to know where to jump when I say where to

Well, suppose for the sake of argument, you have a program that has some jump instructions

or go to instructions or like some conditional branching instructions, anything where execution

is not just going to go to the very next statement.

Execution is going to go somewhere else.

Like maybe you have an if else block.

It’s got to maybe jump sometimes down to the else part instead of the top if part.

And then when it’s done executing, it’s going to jump until after the whole block, you know,

There will be lots of times in all of your programs where execution kind of has to jump

around somewhere if the program is even a little bit complicated.

So that could be a jump instruction, go to in a higher level language, not assembly necessarily,

jump if not equal and so forth.

So if you imagine writing one module, you could also imagine that the module has its

own virtual memory address space.

Just imagine it for now.

And maybe it starts at zero.

at zero that’s that’s not what we’re going to say but just like imagine the module only really knows

about itself and so sometimes when you’re jumping for example if we’re going to jump uh when

something is not equal to something else we’ll jump to some label and in order to jump to that

label the assembler needs to know you know where is that label inside of your source code so pretend

just for a moment this is not like a real assembly program but just pretend for a moment that we have

and maybe this is like I don’t know the main label that gets jumped into from GCC and

so then we have like a label down here outside and we’ll do stuff and then jump back to the

original point so we probably have to do a label here main finish this is this is bad form but I’m

So if we jump, let’s compare, I don’t know, one with two or something.

Let’s compare RAX to RDX and we’ll just move RAX the value one and move RDX the value two

so they’re not actually equal.

And then we compare them and then we say, all right, jump if they’re not equal to this label.

So definitely now we know, oh, we are going to jump down to that label.

So execution is going to go directly down to here.

we’ll do something and then eventually maybe we want to jump back so we’ll say uh

maybe let’s do it again let’s do let’s do like a whole set of statements again we’ll say jump

if it is equal and we’ll just like load those two registers so one and one and then compare

them and then say jump if it is equal to main finish this is not a video about conditional

branching or jumping i’m trying to make this as simple as i can but i hope you understand the

but i hope you understand the point is just basically we’re jumping around within the same

module right so it’s easy for the program to understand where to jump if it’s in the same

module or i guess the the object file when we’re assembling it it’s easy to understand where to jump

because if we’re at line 8 here when we start to jump and then the actual label here has its first

instruction at line 17 well then it you know the amount of instructions to move is just the

the difference you know so it’s easy to say all right if our virtual address is you know this

when we jump and we’re going to jump this much of a difference based on where the label is then now

we can just compute the new virtual address to jump or the absolute address or whatever you want

to whatever you want to do on that particular run but how does it know where to jump in another

module because when we assemble this module as an object file the assembler is only running one pass

one pass on just this object file it doesn’t really know the addresses in the other modules

it doesn’t know their offsets of its labels even if it’s a c plus plus or a c module it doesn’t

really know the offsets it doesn’t know where the functions start and end doesn’t know anything

because right now if we assemble this one source code it’s only going to know about this one source

code right and the same goes for the other modules if we compile a c plus plus program to an object

a function or you know do a go to statement or something into one of these labels from this

module the c plus plus program won’t really know where it is it won’t know what address it’s at it

won’t know the offset right so that’s the job of the linker the linker looks at all of these labels

and all of these uh conditional branching statements and jump statements and everything

and it just decides for starters it decides where each module is going to start in memory so maybe

I don’t know if your C++ module starts up here somewhere and then it’ll say this assembly module

starts right after it and then another module right after that and it’ll just kind of decide

where every module will start in the final executable that we’re actually linking together.

Once it decides the layout then it knows the offset of all the different modules and therefore

it can compute the additional offset that it would take to get to all the labels. So then at that

Your C++ module will make a function call inside of, you know, some assembly module like the one we’re looking at, assuming it was written a little bit differently.

Main finish return.

I guess the way it’s written down here, it’s returning to main if we just kind of execute it as we’re looking at it.

But another module could could call main finish as a function and still get a return statement.

That would actually work, even though it’s probably bad design.

that your assembly sorry your C++ program wants to call a function called

main finish inside of this module the linker having already laid out the

modules and and being aware of all their offsets it knows okay so you know this

assembly module it was underneath the C++ module so it’ll just take that offset

and add it to the offset of the label itself within the module and then also

add that to the the virtual address or I guess the operating system will do the

address. But you know, the point is the linker coordinates all the jumps and the conditional

branches where the functions start, lays out all the modules, gets all the offsets,

and then starts replacing all of the conditional branches and jumps and things with the real

offsets that make it actually doable. Like let’s jump to exactly this memory location

in code exactly in quotes, because we’re still using virtual addressing.

idea of the linker it knows how to jump between modules um wants to link or discuss okay that’s

all i really wanted to say don’t forget if you want a label to be available to jump into or to

call as a function from outside the module you got to mark it as global so if i actually wanted

somebody to be able to call main finish as a function i just have to mark it as global same

thing for some label if i say global some label then now at this point another module could call

call this as a function or jump into it probably bad form to not put a return a return statement

at this point which means when i’m calling it up here instead of jump not equal to i probably have

to add more complicated logic so i can use a function call that gets jumped around if it is

equal but so i’m not going to go that far right now kind of complicated just for this video

and then also of course if you intend to jump somewhere else remember that you have to mark

So let’s say there’s a function in your other module, your C++ module or your C module or your assembly module.

You just have to mark it as extern in the text section, in the text segment, like some other function somewhere else, something like that.

And then once I do that, now I could actually call it, I could say, call, you know, this.

Actually, that’ll never get reached because the jump equal thing is at the bottom.

equal thing is at the bottom but I could do this I could say call it if it was actually a function

or I could say jump if it was just a jump point or I could say you know jump not equal to

the other function instead of some label something like that so lots of stuff you can do and now you

kind of understand the idea of linking is taking all the modules stuffing them inside of the final

executable and also putting data inside of the final executable you know like if you’re creating

So, you know, like if you’re creating a string variable in your globals area of your assembly

program or hard coding, any kind of string anywhere in your C++, then it’s got to be

inside of the executable.

Otherwise, it wouldn’t be anywhere when we ran the program.

So, yeah, it sticks the data in there.

It sticks the segments in there.

It, you know, calculates the jumps and all that stuff.

I just want to point out you could put strings in a configuration file.

of a vanilla C++ or assembly program you probably are making strings directly in the program.

Anyway, so I think that’s the gist of everything that I really wanted to say about what is the

general idea of the linker. Thanks for watching this video I hope you learned a little bit and

had some fun. I will see you in the next video. Hey everybody thanks for watching this video again

it i do hope you did learn something and have some fun if you could do me a please a small little

favor could you please subscribe and follow this channel or these videos or whatever it is you do

on the current social media website that you’re looking at right now it would really mean the

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

videos longer videos better videos or just i’ll be able to keep making videos in general so please

and subscribe. You know, sometimes I’m sleeping in the middle of the night and I just wake up

because I know somebody subscribed or followed. It just wakes me up and I get filled with joy.

That’s exactly what happens every single time. So you could do it as a nice favor to me or you

could troll me if you want to just wake me up in the middle of the night, just subscribe

and then I’ll just wake up. I promise that’s what 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,

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 send me a comment whatever I also wake up for

I wake up in a cold sweat and I’m like, it would 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 I fade into

the darkness, which is coming for us all.

Thank you.

The post How Linkers Work: Linking Code, Virtual Memory, and Module Jumps Explained 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.

Hey there, coders! Want to master Git? This fun, beginner-friendly tutorial covers all the basics: what Git is, how to track changes, commit code, create branches, push to remotes, and collaborate with others. Whether you’re coding solo or with a team, Git’s got your back. Avoid losing code, recover old versions, and learn pro tips to dodge merge conflicts. Subscribe for more coding tutorials, and let’s make version control a breeze! #GitBasics #LearnToCode #ProgrammingTutorials

Introduction to Git 00:00:00
What is Git 00:00:07
Git for tracking changes 00:00:18
Git for non-code documents 00:00:24
Why use Git 00:00:45
Code versioning benefits 00:00:50
Recovering deleted code 00:01:15
Collaboration with Git 00:02:35
Git repository basics 00:04:33
Installing Git 00:04:44
Creating a Git repository 00:05:08
Using git status 00:06:36
Adding files to Git 00:07:51
Committing changes 00:08:18
Checking Git log 00:11:21
Viewing changes with git diff 00:12:21
Pushing to remote 00:19:44
Cloning a repository 00:17:01
Branching in Git 00:23:27
Merging branches 00:25:21
Tagging releases 00:16:00
Pulling changes 00:26:55
Branching strategies 00:29:55
Avoiding merge conflicts 00:32:52
Backup and fresh clone tip 00:34:00
Conclusion and call to action 00:35: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

Hey there, I’d like to talk to you today about the basics of Git and what is Git.

Git is an awesome system that you can use to track changes to all your code as you write

programs and work on things. And in fact, you can use Git for tracking changes to a wide variety of

documents, not just code only. There’s a special tool that I used a while back where I could track

used a while back where I could track changes to just regular office documents.

But if you’re writing text files of some sort or even like, I don’t know, making SVG graphics

files or something like that, you can track changes to all sorts of stuff. Okay, so it’s

mostly for coding. So what is Git and why would you want to use Git? Okay, so we talked about

Git being a code versioning system. It will track your changes. Imagine this.

Imagine you’re writing code and you spend all day, maybe like all month writing a really,

really good algorithm or a really good function or something like that.

And then maybe a year later, you haven’t been using it.

And you kind of think to yourself, you know, whatever happened to that giant function that

I wrote, that was really good.

And then you realize, oh no, I accidentally, I think I deleted it like several months ago

because I thought I didn’t need it anymore.

I didn’t need it anymore.

And now I’ve changed my mind.

I wish I had that back.

But then by then it’s too late because the code is gone and maybe you don’t have a backup

or maybe your backup is just, you know, only a few snapshots deep or whatever.

And so you’re kind of screwed, right?

So one way that Git can help you is Git lets you look back in time to the state of your

code at any other previous point.

Like every time you make significant progress with your code, you log it in Gits database.

You can just look back in time.

You can look back to see what your code was three years ago.

It’s awesome.

You can also, you know, revert changes.

You can sort of like branch your code off in two different directions.

Maybe here you’re just going to be working on bugs and on another branch, you’re adding

one feature that you think might be a good idea.

a really good idea you could merge that branch into the main branch or if you think that feature

is and is going to be trash and it sucks and you wish you never did it you can just delete that

branch and it doesn’t affect your main code branch it’s really cool it’s also a good tool

for collaboration because multiple people can can push to the git database and they can get

each other’s changes it’s kind of a way also to cloudify your code you know like if i’m writing

writing a program, I can commit some changes and I can push some changes to the cloud.

And then my colleague can pull my changes and they get everything that I just worked on.

And then they can commit some more changes and push it back up to the cloud.

Then I can pull it.

And so we’re sort of like collaborating and in a way where every single change is logged,

your boss can look at, or you, you know, you can look at all the logs in your commit,

in your git commit database and see who changed what you can see what lines were changed when

when they were changes you can see who introduced a bug there’s a function in

git that is called git blame where you can look at a source code file and you

can see who is responsible for every single line you can bookmark states of

your code you can do so much it’s wonderful but anyway I just want to

touch on the basics today I hope I’ve kind of convinced you that git is a

little bit of a good idea I used to just sort of code and then you know do copy

paste as my backup copy and it was okay but when I started using git even by

started using git even by myself without collaborating um it was tremendously valuable

there were many times when i wanted to look back at a previous state of code and git let me do it

many times when i wanted to revert some mistake that i made and git let me do it

okay so you see my terminal here maybe maybe i should reduce the transparency just a little bit

to like maybe like 85 opacity.

That’s a little bit better.

Okay, so I’m gonna go into a documents folder.

I’m gonna go into a temporary folder

and I’m gonna remove everything that is, whoops.

Okay, that was just something I was working on earlier.

Okay, so I’m in a folder.

So what is a Git repository?

Actually a Git repository is just a folder

with some extra information inside of it.

Let me see, I don’t remember if I installed Git on this machine.

I did.

Okay, if you don’t have Git, you can get it pretty easily with sudo apt install git.

Or if you’re on Windows or some other operating system, you can just go to Git’s website.

It’s git-sem.com or something like that.

You can just find the installer and just get it in there.

But, so let’s say, let’s say I want to make a repository.

directory my repository okay so I’ve got like an empty folder I’m going to go inside of it

and this is just a folder it’s not a repo yet I can convert this folder into a repository by

just using the command git init oh gosh here’s like a message oh you got to choose what branch

you want I think it’s actually okay at this point I think they’ll choose one for me when you see

this you can read them and obey them but they’re not necessarily mission critical while we’re just

learning so notice how when i list the directory it’s no longer empty there’s a there’s a git

folder inside of there so if i go inside of the git folder i mean this is really not so much for

humans you can kind of do configuration stuff in here but um this is really gets database of

everything it knows about your code you know when you change stuff what’s the configuration

So if you actually remove this folder, I’m going to remove the Git folder.

That’s all it takes.

Now this folder is just a regular folder.

It’s no longer a Git repository.

So you probably don’t want to do that once you’ve initialized it,

but I’m going to reinitialize this again.

If I had a bunch of history inside that folder,

then it would have been gone already.

But we’re just learning.

This is just an empty repository.

So I have a Git repository here.

here. First thing I want to do is try to figure out what Git thinks about the repository. So I’m

going to use the command git status. Whenever you’re not sure of what’s going on, if you think

you need to commit something or push something or pull something or whatever, it’s probably a good

idea to use git status. I use it all the time. Git status and then git will tell you what to do.

It’s basically telling you that you haven’t done anything at this point. So that’s okay.

a readme file in markdown, my, oops, my project.

You don’t really need to know about markdown to use Git,

although the two kind of go hand in hand on GitHub.

But I’m just going to say, well, here’s my project.

This is my super cool project.

Okay, so pretend this is a program, a complicated program.

So I’m saving it.

We can verify that I actually like put something into that file.

So now I’m going to ask Git, you know,

you know, what do you think about the state of this repository?

So I’m going to say git status.

Git is telling me now that we’re on the master branch

and there are no commits yet.

And I have an untracked file.

This means that the readme file is not considered part of the git repository.

It’s just sitting in the directory tree.

So I want to add that into my repository so I can start tracking changes.

So I’m going to say git add and then the name of the file.

What have I done?

Okay, here we go.

What have I done? Okay, here we go.

That’s not how you spell add.

So now that I’ve done git add, I can say git status one more time to see what

Git thinks about the state of my repository.

Git says, well, you definitely use the add in order to put the changes on a stage.

Git likes to bunch up changes on a stage before you actually commit things to the

database. The reason for that is maybe

maybe you spend an hour doing a bunch of work in a bunch of different areas of your

different areas of your program, but maybe there’s only like a few files over here that

are part of a logical change.

Like this is feature a that I was fixing, but you also changed a bunch of other files

that were related to something else like feature B that I was fixing.

It doesn’t really make sense to take all of those changes and make them one commit because

you want a nice clean commit log that shows exactly what you were working on.

And it makes sense.

you just worked on a bunch of different files,

you can add all the feature A files to the stage first

and then commit that as one change

and then go over to the feature B files

and add those to the stage

and then commit that as a second change.

So it’s kind of a way to get you out of the mess

you’ve put yourself in

if you’ve just been working too long without committing.

You should really do a git commit

every time you make significant progress.

Like, I mean, it depends on where you’re working

where you’re working or who you’re talking to. You definitely don’t want to commit every line

that you change. You definitely don’t want to work for like a month and then do one commit at the end

of the month. The sweet spot is somewhere in between. Your boss will probably tell you what

to do. For me personally, every time I fix something, I’ll make a commit. One thing,

you know, I made significant progress in my program by adding a new feature. One little

feature, I’m going to commit it. Some people like to do commits at least once a day so that if

to do commits at least once a day so that if they’re working on a huge new feature, then

they’ll do like one commit a day. And then they’ll sort of like call those several commits

part of like a new feature. It’s up to you. But at this point, we just have the one file

that we made up on the stage. It’s ready to be committed. We used git status. So git

is just telling us how to commit it. It’s like, oh no, it’s not telling us. It’s just

saying we need to commit it. It’s not saying how. If you want to unstage it, then here’s

commit command is just git commit now it’s going to ask me for a commit message this is what you

will see in the log so don’t just put work don’t put change don’t put something that doesn’t

describe what you did you should describe exactly what you did so so what i’m going to do is for

the commit message i’m going to just sort of say what i did you can imagine writing something like

i created the readme file it should always definitely describe exactly what you did

um but it seems like a lot of people use uh i guess grammar and and and terseness

just to make the commit message sound like they told somebody to do something so create the readme

file instead of i created the readme file create the readme file so i’m just going to make that my

commit message save the buffer and then uh now that i’ve committed the changes i have to ask

you know git status what did i do you know what’s the state of the repository it is now saying that

that the repo is clean, everything looks pretty good.

So that means my changes are recorded in the Git database.

I can now actually use a command called Git log to see what changes have been recorded.

Notice how there’s only one change.

It’s just, you know, my name here, when it was changed and then what I did.

There’s a hash here.

This little hexadecimal string is called a hash.

to show me what happened in any specific commit by saying git show and then I give it a hash

and it’ll tell me exactly what files were created or changed or deleted or whatever

and there it is right there this will get more interesting in a second let’s make a change

I’m going to say edit the readme file and we say this is my super cool project this is my first

So I’m going to say git status to find out what’s going on.

Git says, oh, you made a change there.

It’s not saying that this file is not part of the database.

It’s just saying that we made changes.

I want to see the changes that it’s talking about.

I could say git diff.

And it’s telling me that I added this line.

My dog is growling at me.

about peeing oh my gosh hang on

so i’ll let him back in he’ll try to lie to me and he’ll try to get free treats

okay so uh we can use the command git diff to see what our changes are we can also say

git diff whoops git diff and then name a file and it’ll tell us what’s changed in that one file

second line so great back to get status it’s saying we need to stage that change

so I’m just gonna say get add and then the name of the file get status again

so that we know what’s up it’s saying all right well you just need to commit

the changes on your stage if you’d like to so yeah sure I’m gonna say get commit

and I’m gonna say you know changed the readme or something okay get status

So now if we do git log, there’s two entries.

Imagine that this happens every single time

somebody makes a significant change.

You know, it’s just like it goes in the log.

You can figure out who changed what.

Watch this.

Let’s do cat readme so we can see the readme.

Notice how it’s got the second line at the end.

I could also go back in time

and see what the state of my project was

was after that first commit so i could i’m going to copy paste that first commit and i’m going to

say git checkout and the commit hash it’s now telling me something hey by the way now you’re

looking back in time you should not change anything you’re on a detached head if you’re

ever unsure of where you’re actually at in git you should do git branch all and it’ll just sort

of show you where you’re at i was on the master branch now i’m on a detached head but notice if i

But notice if I spill the contents of the README file.

Hang on, what did I do wrong?

Change the README.

Oh, sorry, it’s in reverse order.

I always forget that.

I copied the wrong hash.

So let me check out the first commit that I made.

So I’m going to say git checkout the first commit hash.

Okay, now I’m going to concatenate the,

or I’m going to spill the contents of the README.

Notice how the readme looks like it did when we first made it.

So we’ve gone back in time.

Think of how useful this could be if this was a huge, big project with a bunch of files

and a lot of lines per file.

So once again, we’ll do git, actually let’s do git status.

Status is reminding me that we’re on its attached head.

and we can also use git branch to see that we’re still in the detached head you want to get back

onto the master branch or whatever branch you’re working with before you continue working so we’ll

status and you can see that we’re on the master branch.

Then we can say get branch all.

And there we go. Maybe we want to bookmark this.

Maybe we want to remember, oh, this is a perfect state of our of our code.

Maybe this is version one point.

We can do get tag version one point.

Oh, and now we have a bookmark forever.

How can we find the bookmarks?

Well, we can say get tag just by itself, and it’ll give us a list of our bookmarks.

When we push this to a remote server, the server will be able to show it like

remote server, their server will be able to show it like GitHub or GitLab or whatever.

And then later we can do something like, you know, get checkout and then just check out the

name of a tag. So it’s kind of the same thing as checking out a commit hash, but it’s like

a bookmark that’s a little bit easier to remember. So let’s look at remotes for a second,

because right now we’re not pushing code anymore. We’re just remembering what we changed in our

Okay, so I’m inside my repository.

And now I’m going to go up a level on this right pane,

and I’m going to make a new directory.

But I’d like to clone the original repository.

Imagine that this repository, it’s a folder to us,

but it could be for all we know, sitting on a remote server

and accessed with a special URL.

So you can go to like GitHub or somebody’s server,

and you can copy their get URL for their repository.

repository. Over here in our local file system, we could clone the original repository.

Usually you would have to copy paste like a big get URL, SSH URL or HTTPS URL or whatever.

But you can even do this locally so I can tell get I would like to clone this local repository

denoted by this folder name. And I would like to call it my clone or something. So I’m gonna say

So I’m going to say get clone repository my clone.

It says cloning and done.

Now we have two folders.

And if we go inside of the my clone repository,

we should have the same state of code that we just cloned.

So that makes sense.

Now think about collaboration.

We can change our code from the clone.

And as long as the clone has permission to push back up to the remote,

back up to the remote then it actually would work.

So let’s edit the README file real fast.

So I’m going to go nano README and I’m going to say this change was made by the clone.

Okay, so I did that.

And actually just to make things interesting, I’m going to change my git identity only inside

of this clone.

You can do that in git.

config and you say something like user.name, you know, you can put your name here, your email,

whatever, for like user.email. There’s this thing that you usually do where you say get config

global. And that means you’re changing configuration that is account wide. So like

your entire account on this machine is going to be changed when you use that global flag.

But if I don’t use the global flag, it’s just changing my configuration for only this one

this one repository so i’m going to make my name clone dude and make my email

clone dude at laptop or whatever at server so now if i say git status over here it’s telling me hey

i have like a change i say git diff and it tells me oh look i you know you changed that last line

so i’m going to add that change to the stage and then i’m going to commit it and i’m going to say

I added something to the readme.

Okay.

Git status.

Notice how git status is saying something a little bit extra this time.

Before, we were just in a local file system only.

And now we’re working inside of a clone.

So this is like, you know, you clone some code from GitHub

or from your friend’s server or whatever.

And when you do a clone,

it actually automatically links your local repository

repository to the remote repository. By the way, in Git, everything is considered a local copy. So

it’s not like you’re working with something different than the server has. You actually

have the entire Git history and all the code and everything that Git has on the remote,

except for maybe some like configurations or something. But when you pull, you’re just making

you’re making a copy later we can push our changes to the server and that just makes

the two repositories talk to each other sort of and reconcile changes and make sure that both sides

have the differences i guess so it’s telling us we need one more step it’s saying git status and

it says you’re on the master branch your branch is ahead of origin master by one commit what’s

origin master you can find out all of your remote connections and get by saying git remote v so when

so when you clone it automatically makes an origin remote it calls it origin and

then it has the URL or in this case just the file path of where the remote is so

it’s telling you that our remote where we’re connected to is the my repository

folder that we were at in the left pane so it’s telling us also if we go back to

just status it’s telling us that we should use git push to publish my local

my local commits to the remote because at this point we’re out of sync if uh if somebody else

cloned the remote repository and then made a bunch of changes and then pushed then i would now be

totally out of sync with that new person who cloned and also the remote server and it would

create something called a merge conflict which is like a little bit more advanced than this video

and we’d have to take steps to resolve it so the smartest thing to do is um well if you’re

Make sure that everybody is designated a certain file or set of files to work on and you all talk to each other.

Hey, I just pushed some code.

You need to pull.

Hey, I’m about to push.

Hold off a second.

Hey, I just pushed.

If you’re working on something, you’ve got to pull my changes before you do a push.

Always push after you commit so that everybody has the latest copy on the remote so you don’t cause conflicts with your teammates or whatever.

and always try to do pulls regularly.

Anyway, so I need to push my code.

I’m going to say git push.

And it’s saying, oh gosh, what is it saying?

Oh, okay, okay, okay, okay.

This is going to be a special setup that I have to do.

Let me just very quickly revert what I’m doing here.

I think I have to…

Oh, I know what to do. I can just make it a little trick.

Usually the thing is they don’t want you to push onto a branch that the remote has currently checked out into the file tree.

But usually remote servers, they don’t have a branch checked out.

So you won’t even see the file system on the remote.

It’ll actually all look like just this.

There’s a flag called bear that you can use to make that happen.

But I don’t really want to go through all the steps right now.

So what I’m going to do is I’m just going to make another dummy branch and then just kind of sit on it for a while.

dummy branch and then just kind of sit on it for a while.

That way I’m allowed to push to the master branch.

So I’m going to say get branch.

This is how you make a new branch.

I’m going to say dummy or something.

Whoops, got to spell branch, right?

Then get checkout dummy and then get branch all and then get status just to make sure

I’m now sitting on the dummy branch.

And then this will cure the problem that we had a moment ago where we’re not

allowed to push to a branch that the remote has checked out.

branch that the remote has checked out so i’m gonna say git oh wait hang on gotta go back in there

my clone git push okay so now it works uh so keep in mind if you’re pushing to you know a remote

that has a branch that’s checked out like it’s another file system like it’s a friend’s computer

you’re gonna have to worry about this sort of thing but if it’s a server like github or just

someone who has set them set the repository up properly uh you won’t have to worry about it so

Forget about that for now.

So I pushed to the remote.

If I do git log over here, there’s a mix.

It shows, you know, Mike created it and then changed it.

And then the clone dude added something too.

Okay.

So if I say git log, we should now see the history for only the dummy branch.

So that’s just two things.

And if I say git checkout master, and then I check out and then I look at the log for

I can see all the changes that the other person made.

Pretty cool.

I could also go back into the dummy branch if I wanted to.

I actually used to do this a long time ago before I realized you should do bear repos.

Let’s see.

Check out dummy.

And then I’ll say git log just to confirm that the changes aren’t in there.

So now we have two branches that are kind of diverging a little bit.

the master branch has one more commit than the dummy branch and if we let this go on for far too

long it might be more of a hassle to make the branches merge again but i’m just going to merge

them right now so i’m going to say git merge verify that you’re sitting on the correct branch

that you want to be the destination branch so i’m sitting on the destination the dummy branch so i’m

going to say git merge and i’m going to give it the name of the branch that i want to merge changes

It’s telling me that something happened.

So if I do get branch again one more time, I’m still on the dummy branch.

But if I do get log, notice how I have that latest log entry.

Pretty cool.

So now I’m going to go back onto the master branch because I want to do some work here.

This is a little clumsy.

If we’re talking about a server client paradigm, just bear with me.

Now I’m going to make another change.

Hi, Mr. Clone.

clone. Can you read this? So I’m going to make a change that I want the clone person to see.

Git status, git add, the readme. You could also do git commit dash a, but I kind of don’t like

to because I’d like to remind myself that the stage is a good idea. Git commit new readme

okay so I’m not I don’t have a remote I am the master so there’s nowhere to push

but now in the clone I can say git status it doesn’t yet know that the that the

remote has changes I could do git pull to actually pull all the changes or I

can do git fetch fetch will sort of talk to the remote and pull the changes into

this repository’s local copy of the remote.

So if we do git branch all, you’ll notice that we have a master branch here.

So the master branch is my master branch.

And all these other branches here are local copies of the remotes branch.

So we’re just making lots and lots of copies.

That’s kind of how git works.

But now that we did a fetch, that talked to the remote, it grabbed changes.

Now Git understands that we’re actually behind the remote by one commit.

And it’s telling us, well, you need to use Git pull to pull all the changes.

Usually you kind of don’t need to do Git fetch.

If you have a remote, you just say Git pull.

You only do Git fetch if you want to kind of see what’s going on with the remote first before you

actually try to pull all the changes into your branch.

It’s a more complicated situation.

So if I say Git pull, now inside of my Git log, I have that last change.

that last change that the master gave us.

So this is like a very, very basic workflow for Git

in terms of making changes to your program,

committing the changes, checking out the log,

checking out what was changed,

pushing to a remote and so forth.

The only difference, by the way,

between using a remote that’s a file system

and using a remote that’s GitHub

is just what URL you put in clone.

in clone like if i put if i said git clone i put a file path here originally but if i just

put a clone url that github gave me or your friend’s server gave you right there then it

would work basically the same way it’s pretty sweet um let’s see so those are the basics of git

always make sure that you push to the remote so that the server has your changes and if you’re

using github or another website uh it’s it’s usually a really good idea to push and then go

to the website to double check that your changes actually made it.

So we talked about tags and branches.

This video is not going to be for advanced branching strategies,

but there are lots of cool resources you can check out.

Actually, you know what? I’m going to pull one up. Let’s see.

I’m going to edit this out if it ends up being like a really bad search result.

Get branching strategy.

big project with a big team let’s see there’s one that I used to love where the heck is it

I think this month no that’s not the link I remember I should have bookmarked it but there

are lots of different strategies for how and why you would want to use um branches let’s see one

of these has a good diagram this is it this is not the same web page but I think this website

diagram that I remember.

So we’ve been on the master branch.

That’s like the right side here.

You know, this little, these little blue dots.

Imagine that every single time you want to create a new feature,

you just create a branch and you name it after the feature that you’re creating.

I think I mentioned that before that allows you to sort of keep working on the

master branch independently of the feature that you’re working on.

And then later when you’re sure you want to merge the feature into the master

branch, then you just use a get command to make the two branches merge.

command to make the two branches merge.

Or if the feature turns out to be a bad idea, you can just delete the branch.

Usually, at minimum, most people will do something like this.

They’ll have a development branch.

So here you can see the yellow dots.

That’s development.

And what they’ll do is they’ll make all of their commits to the development branch.

And then only whenever the program is in a really good state, like it’s sort of presentable,

you can actually release it.

let your friend run the code or whatever, then you’ll merge the dev branch into the master branch

without deleting the dev branch. So you’ll merge the dev into master every time the code is in a

really good state. And then you’ll come back on to dev to continue developing. I think most people

call it develop. Actually, I call it dev for mine. And that way, the master branch usually only ever

is in a state that is good that people could clone from and just compile the program or use the

or use the program or whatever.

And that is in addition to adding tags

whenever you think the master branch is in a state

that you think is like a significant release.

So like version 1.0 or 1.2 or whatever.

So branches for development

where you’re always there most of the time.

Branches for feature when you’re kind of experimenting

and trying to figure out

if you’re going to be able to add something.

Branches for, there’s a branch for the master

where it’s like this is the state

that the public should see,

the state that actually works.

actually works. And then, you know, you might do a temporary branch for a hot fix.

And sometimes people will do a new branch for a future release. Like if you’re going to release

version 2.0, you might make a new branch and call it version 2.0 and then just work on that and

kind of like merge changes from dev in that and just make sure that it’s all good and it’s great.

And as soon as you think that the feature branch is perfect for your release, sorry, not

Sorry, not feature branch.

Release branch is great for your release.

Then all at once, you’ll merge that whole thing into master.

You don’t have to do it that way.

It doesn’t have to be that complicated,

but sometimes it can be that complicated.

For me personally, I usually just do a development branch

and a master branch.

And then sometimes when I’m taking a risk,

I’ll make a feature branch for the new thing that I’m trying.

So I just kind of wanted to show you that for branching.

for branching and

we talked about pulling and pushing and cloning

yeah so just uh i guess one more warning to make sure that you don’t

end up with merge conflicts when you’re collaborating with other people

or even actually this happens to people who work by themselves and they just

switch computers a lot make sure that when you first sit down

and you’re about to start coding you always pull

team of people communicate with them and tell them you’re about to pull tell them you’re about

to start working on something tell them tell them what you’re about to start working on unless you

have like a manager who’s telling you exactly what to work on then it’s their problem um

and then do your get pull and then work and then every time you make significant progress

do a commit and then tell everybody i’m about to push and then push and then make sure that you

So if you go on your lunch break, make sure you push before you go on your lunch break.

And when you come back from your lunch break, make sure you pull right away.

Because if you don’t pull and push enough, you’re either going to get merge conflicts

on your end or you’re going to cause other people to get merge conflicts.

And sometimes it takes a lot of time to resolve the merge conflicts.

So you really don’t want to deal with that.

And then a beginner’s tip, or I guess like maybe like an easy tip.

I do this actually sometimes.

up totally forgetting to push and pull and you do a lot of code and you kind of like wreck everything

and you don’t want to deal with a gigantic merge conflict resolution type of situation sometimes

it’s easier to just copy paste your folder somewhere else rename it remember a git repository

locally it’s just a folder so you can copy paste it or rename it or whatever you want to do

you just kind of copy paste it somewhere and then perform a fresh clone from the remote

then there’s not going to be a merge conflict because the fresh clone is going to be directly

from the remote which is not conflicted on its own then you’ll have your fresh clone and then

you’ll have your little backup copy of what you just screwed up then you can manually inspect the

difference between the fresh clone and then the thing that you just screwed up or you can just

start copy pasting some of your changes and then do like a commit and then do push and then it

Git Basics tutorial. I hope you learned a little bit of stuff and had a little bit of fun.

I will 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 media website that you’re looking at right now.

It would really mean the world to me and it’ll help make more videos and grow this community

So we’ll be able to do more videos longer videos better videos or just I’ll be able to keep making videos in general

so please do 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

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

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

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

fade into the darkness which is coming for us all.

Thank you.

The post Git Basics Tutorial: Learn Version Control, Commits & Branches for Beginners appeared first on NeuralLantern.com.