Join us for a clear, engaging look at x86-64 program segments! We break down the text, data, and BSS sections, explore stack vs. heap memory, and show a real stack overflow in C++. Learn why segmentation faults happen, how virtual memory works, and tips to avoid crashes. Whether you’re new to assembly or leveling up your coding skills, this video is packed with insights to boost your understanding of low-level programming. Subscribe for more coding deep dives!

Introduction to x86-64 program segments 00:00:01
Understanding segmentation faults 00:00:12
Importance of segments in assembly 00:00:32
Overview of assembly program structure 00:01:09
Defining segments in Yasm assembly 00:01:49
Data section: Initialized global variables 00:02:20
BSS section: Uninitialized variables 00:03:23
Text section: Code and functions 00:03:59
Global and extern function declarations 00:04:41
Stack: Local variables and return addresses 00:07:11
Stack overflow example in C++ 00:08:48
Heap: Dynamic memory allocation 00:11:31
Stack vs heap memory growth 00:11:56
Virtual memory and memory allocation 00:14:00
Demonstrating memory overflow with heap allocation 00:16:59
Summary of segments and their purposes 00:17:59
Closing remarks and call to subscribe 00:18:47

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

Hi there!

Let’s talk about x86-64 programs and their segments and the purpose of the segments.

Probably when you’ve been programming in the past you’ve seen segmentation fault errors.

If you’ve accidentally crossed the bounds of some appropriate memory location, if you

have an array and you try to index it way outside of bounds or something, you might

have seen a segfault.

SegFaults basically come from the idea that you have crossed a segment boundary.

Segments used to be really, really important.

They’re a little bit less important now that we have virtual memory.

I’ll just talk a little bit about them.

I’m going to be discussing this from the perspective of an assembly program,

just because even in higher level languages,

your languages will typically be compiled down to assembly

first before they actually hit machine code and your actual executable binary.

So if you’re not interested in Yasm Assembly,

Yasm assembly I think this could still be worth it for you to watch because

you’ll be able to see the different segments and just kind of get a better

understanding of what they are okay so I’m gonna actually write a very very

very quick program in assembly it’s not gonna really do anything I just want you

to show I just want you to see the segments that are involved so for

starters let’s just pretend that I’m writing a an assembly program here we’ll

This is a comment just so you know what I’m about to type.

Perhaps actually this is not the best editor.

I don’t know why I pulled this up.

Let me get Gene here.

It’s a little bit better.

Gene.

There we go.

Maybe I’ll save it somewhere.

I’ll say segments assembly.

And then now the comment gets highlighted.

Okay.

So in assembly in the ASM assembly,

we denote various segments by using the section keywords.

keywords so we’ll say section and then dot something indicating the type of segment that we’re

defining so section text and then up here we’ll have another one section dot bss and you know if

you already program assembly you know that somewhere in here is where the code goes right

between these sections so just a quick recap of what the data section is it just is where you

can name and initialize at the same time at the very top.

Globals are not great, but sometimes you want to do that in assembly, depending.

It’s better if you stick all your variables on the stack.

Like if they’re a local variable, it’s a little bit better.

Think of higher level languages.

You typically want to avoid global variables if you can possibly avoid them and make

everything else a local variable or a member variable.

So that means somewhere else other than data, probably the stack, but or the heap.

Anyway, you know, this is like the basic pattern.

We’ll say, you know, my variable and then we’ll decide to say what data size it is.

In this case, it’s DB for one byte of data.

You could put a, I think DD in there or a DW for a word.

Sorry, sorry, DW would be for a word.

And then I think DD would be a double and then DQ would definitely be a quad word.

So here quad word is eight bytes.

And then I can sort of initialize it to some number.

some number and now I have a global variable so not like a huge deal the BSS section is basically

where you have uninitialized variables but there you can make huge amounts of variables you can

make an array of variables so if I say my array something like that I could put resource queue

to say I want the type of one item to be a quad word so you know eight bytes per item and then I

could just say I want you know a hundred thousand items or something and I’ll

double check that after I stop recording this video and correct it if I’m wrong

it’s been a while since I actually typed BSS here and then in the text section

this is where you put code and functions and things you typically want to have at

least one entry point somewhere you know if you want to make like if you want to

make this the entry point of your entire program you’ll probably do global main

main and then this assumes that you use the GCC libraries and just sort of return from the label

sort of makes it a function assuming you didn’t ruin any of the other data.

So those are the three sections that we can start off looking at the data section,

the BSS section, and the tech section. It’s important to note that besides marking functions

as global so that they’re accessible to other segments or other modules, we also mark

We also mark functions and labels that we would like to access that are in other modules.

So if we’re using the GCC libraries, we could say something like global printf,

and then right away we’re able to call the printf function.

Or say if you have another function in another module,

like a different source code file that’s compiled somewhere else,

we could say, you know, my other function.

Something like that.

Just mark it as global.

Or sorry, not global.

Extern.

Xtern. Global is when you have the function in the current module and you want it to be available to other modules.

Xtern is when the function or label is in another module and it’s already been made available to you,

but you want your current module to know that it can access it for the purposes of assembling the program.

So that means inside of here we could do something like call.

We could say, let’s call my other function.

my other function that will work if the other function is actually a function

with a return statement and it respects the ABI you know it pushes registers that

it’s going to modify if they’re callie saved if it’s not another function maybe

we’ll say extern my other jump point so like not a proper function but just

something that you might want to jump to then instead of using call we would use

jump, you know, and so forth. So those are the basic sections. Let’s see, for the BSS,

I definitely talked about token size and count. And then there’s resource B, resource W, resource

D, resource Q for the different sizes. So basically just take all the different sizes you could put

in the regular data section and assume that that could be popped on to the end of RES inside of

the BSS section. If you’re interested, this is a segments video, not an assembly video.

assembly video um another segment uh another segment that we’re not showing here in this

source code is the actual stack probably i guess the best way that i could show it is

i don’t know by messing around with the stack pointer increase uh

oh rsp why did i think it was the instruction pointer we could increase the stack pointer and

stack pointer and then decrease the stack pointer.

It doesn’t really help a whole lot.

But in another video, I’m gonna talk more in depth

about what the stack is and how to use it and such.

But just keep in mind that the stack

is where local variables are stored

and you can use it in assembly and C++

and other higher level languages.

You can even make virtual stacks

in any type of program almost

to just sort of have a stack like structure.

But in C++, if you make any local variable,

any local variable, then it’s usually going on the stack.

And the stack tends to have a fixed size.

And so if you sort of put too much data on the stack,

you risk a stack overflow, which will crash your program.

Besides local variables, the stack will hold other information that the current scope needs,

like its return address.

So when we make a function and then let’s say we call another function inside of it,

actually just up here even when we call another function on line 22 the stack will receive the

return address of where we currently are so that later when we return from the other function you

know the program knows where to jump back and forth it’s actually under the hood just jump

instructions when you do call it’s it’s not it’s not like a special thing it’s just jumping to

another location and then pushing the return address on the call stack so that’s other stuff

other stuff that the stack holds, which means if you have like an endless or like a infinite

recursion happening in your function where just a function calls itself over and over

and over again, or you have some complicated call graph and you end up calling too many

functions without ever returning, you could overflow the stack.

So that’s not good.

Let me show you a quick example that I’m going to make for you real fast.

Oh shoot.

Did I actually make this?

Where is the, it’s on the desktop.

Okay, I guess I’m going to make more on the desktop.

Let’s do a stack overflow.

Let me do desktop here.

Let’s do stack overflow.

That’s CBP.

I’m just going to make a quick program.

In C++, that doesn’t really do anything except overflow the stack.

So I just want you to know the stack can overflow.

I’ll make a function called F.

And F just calls itself.

calls itself. So that’s going to be an infinite recursion.

And that means, you know, every single time F calls itself,

the return address of like line five is going to get pushed onto the stack again.

So it’s just going to get pushed and pushed and pushed and pushed.

The stack will overflow faster if I had local variables because every scope that

gets called, even if it’s the same function name, it’ll have its own allocation on

the stack. So if I just sort of like call this from main and then I’ll just need

and then I’ll just need to make a little uh a little make file that just kind of compiles

I don’t really even need to make a make file I could do a build script but I’m going to do it

anyway we’ll say g plus plus standard equals c plus plus 23 show all warnings show pedantic

the input file will be stack overflow cpp and then the output file will be main

main and then assuming that succeeds I’ll just run main so this is like not a make

file video I have other videos for make files let’s see let me get to the

desktop if I run the make file with just the word make you should see a stack

overflow we should also see a warning about the fact that there’s infinite

That’s funny, I must have done something wrong or different because on a different computer

not too long ago I did the same thing and I saw a warning.

Okay, well thanks for not warning me.

But anyway, you can see that we have a segmentation fault here because the stack overflowed.

We just made a stack that was too huge.

This is a reminder that the stack is not necessarily as dynamic as the heap.

You can definitely overflow it.

It’s not really meant to store gigantic amounts of data.

What am I talking about when I say the heap though?

So just keep in mind that whenever you allocate dynamic data,

well, maybe, well, what do you think?

Maybe, maybe inside of, instead of calling F, let’s call G.

The heap is where you allocate dynamic data.

So anytime you use the malloc operator in C or the new allocator in C++,

you’re creating like a dynamic allocation of data.

I’ll do a new integer and then I’ll do like a thousand integers so this is

basically going to allocate a thousand new integers in the heap which is a

segment that is right up against the stack I should mention also that the

stack it’s important the stack its memory locations go down as the stack

grows keep that in mind because typically when you when you imagine a

stack I’ll make more videos in the future so you can visualize the stack better but most of you who

know what a stack is already you imagine that the stack grows upward visually right but in your

computer the memory locations of the stack grow downward so if I add something to the stack then

the new stack head pointer is actually going to be a lesser address and the reason for that is the

stack and the heap they grow in the same direction towards the same unallocated space we’ll call that

We’ll call that space the unallocated memory space or the unmapped memory space.

And it’s just, you know, a segment stack in the heap.

And then there’s the unallocated space that they grow towards each other.

If they ever meet, then your program is out of memory and it’ll crash.

But the heap actually can be dynamically allocated to store tons of RAM.

I’m probably about to crash this computer.

So maybe this video won’t finish recording.

recording so maybe I’ll try to crash this at the very end I just wanted you to

see let me let me do this I’ll say while true we’ll just allocate a new integer

this is kind of bad form because when you allocate you know a new variable

somewhere you want to have access to it after the allocation you would usually

send that into a pointer you’d say like you know integer pointer P equals new

in something like that right but in this case I don’t really care I’m not gonna

that memory i just want you to see how fast the memory can grow when we did the stack overflow

seemed like the program died pretty quickly but here we’re going to be able to see the memory

boom pretty pretty big before the whole computer just starts to you know fall to its knees

so i’m going to do a call to g here and then i won’t actually run this until

i’m ready to crash this whole video let’s see what else can i say

Oh, the reason that the heap can grow so much larger than the stack is our programs now in the modern era, they use virtual memory.

So it’s not like when we allocate, let’s say we’re accessing a memory location via a pointer inside of our program.

It’s not that the pointer has the absolute memory location through the whole system.

Like it doesn’t, it’s not able to name locations outside of the current program.

Every program sees its own start memory location as just zero.

And then under the hood, there are some extra tricks so that when you try to access a memory location,

let’s say memory location 100, because you’ve made, I don’t know, this many integers or whatever.

Then under the hood, the computer will know what is the start offset of the program’s memory.

So maybe the start offset is 1000.

It’s like totally unrealistic, but just pretend.

The start offset is 1000.

1000 then that means if it’s trying to access a pointer with memory location 100 it just gets added to the offset the virtual offset

So it’ll be a thousand and 100 is the real you know physical memory location or at least at that point

It’ll probably go to the paging system, but that’s that’s another video

So just know that it’s virtual which means the program thinks it has the full range of of the 64 bit memory address space

Even if you don’t even have that much memory on your computer, which there’s no way there’s no way you have so much memory

there’s no way you have so much memory that it’s going to overflow or even meet

64 bits at all but the program thinks it can so it’s just going to grow and grow

and grow until you actually run out of physical memory and then eventually

probably your program is going to start going to the page file or to the swap

file and then when you run out of that then your whole computer probably is

going to start crashing to be honest it’ll probably start crashing as soon as

it hits the swap file because at that point none of the other programs really

None of the other programs really have enough leftover memory to to breathe to do extra

allocations and things so everything’s going to start slowing down it’s going to be pretty bad

and well i think that’s all i really need to say this is not supposed to be a really long video

let me uh let me show you this crasher i’m going to say goodbye now thank you so much for watching

the video i hope you learned a little bit and had some fun too and and that way i’ve already said

if it actually crashes the computer. So I’m going to open up this and then I’m going to do maybe

HTOP so that I can see memory. So if you kind of like look at HTOP real fast,

this is just a Linux command line tool that you can install. It’s pretty cool.

What the heck’s going on here? Oh, that’s my recorder. You can see here’s the memory allocation.

So I’m using two gigs of eight gigs on this virtual machine and then I’m not using any swap

space which means I have not exhausted all my memory and and I have not been forced to go to

the disk for like additional memory but in a second we’ll see that will probably change

so I’m going to do make just to run that it looks like it’s stuck but if you keep looking at the

memory allocation oh it already hit eight gigs now it’s into the swap already probably

The out of memory killer, the OOM, successfully killed the program.

Thank goodness.

Or the whole computer would have been down.

I always forget that that’s going to happen lately.

But you can see it spiked, right?

It went right up to the full physical memory allocation of 7.75 gigs.

And then the swap file went all the way up to 2 gigs.

You can see that the swap file still has about 700 megs inside of it.

That just means that there’s memory that isn’t really being accessed.

the operating system doesn’t feel like it’s necessary to pull it back out of swap and put

it into RAM but I wonder if the video skipped when I did that or stuttered or anything I’m

interested to find out now okay so that’s the end of this video I hope you have a decent basic

understanding of segments and then you know like the segments and their purpose you know the heap

and the stack they grow together the heap can dynamically allocate to grow bigger notice how it

Whereas the stack will crash a lot faster.

If the stack and the heap meet, then you’ve ran out of memory.

At that point, you know, you probably want to like resize the heap or the stack just crashes.

And then we got the text section of the program and the data section and the BSS section of the program.

And these sections are a little bit less relevant in the modern era because we have, you know, virtual memory and stuff.

That definitely means you have tried to access outside of your segment and it’s a no go.

Okay.

Thank you for watching this video.

I will see you at a later date and time.

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

as you do on the current social media website

that you’re looking at right now,

it would really mean the world to me

and it’ll help make more videos

and grow this community.

So we’ll be able to do more videos,

longer videos, better videos,

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

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping

in the middle of the night

and I just wake up

because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

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

And I just subscribe and then I’ll just wake up. I promise that’s what will happen

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

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 again thank you so much for watching this video and um enjoy the cool

Enjoy the cool music as I fade into the darkness which is coming for us all.

Thank you.

The post Demystifying x86-64 Program Segments: Stack, Heap, and More 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 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, Linux newbies! Ready to unlock the power of the Linux command line? In this fun and approachable guide, we dive into the Ubuntu terminal to teach you the essentials of command-line magic. Perfect for beginners, this video covers everything from launching a terminal (like the awesome Terminator emulator) to mastering commands like ls, cd, mkdir, and rm. You’ll learn how to navigate the file system, create and delete files, edit code with Nano (sorry, Vim fans!), and even compile C++ programs with GCC. Plus, we’ll show you how to install cool programs like GIMP using apt and wield sudo like a pro. Whether you’re switching from a GUI or just curious about the terminal’s hacker vibes, this video is your gateway to a whole new world of open-source tools. Stick around till the end for a quick peek at graphical editing and a heartfelt call to join our community! Hit that subscribe button, scan the QR code to check out more tutorials, and let’s keep exploring Linux together. Drop a comment with your favorite command or what you want to learn next! #Linux #CommandLine #Ubuntu

Introduction to Linux Command Line 00:00:00
Ubuntu Linux Terminal 00:00:04
Benefits of Terminal Usage 00:00:09
Desktop Environments (XFCE vs. GNOME) 00:01:07
Launching the Terminal 00:01:55
Terminal Emulator (Terminator) 00:02:06
Understanding the Shell (Bash) 00:04:00
Echo Command and Variables 00:04:06
Clear Command 00:07:34
Navigating File System (PWD) 00:08:21
Listing Directory Contents (LS) 00:08:56
Using Man Pages 00:10:37
Changing Directories (CD) 00:13:15
Creating Directories (MKDIR) 00:14:51
Going Up Directory Levels 00:15:57
Creating and Deleting Files (Touch, RM) 00:19:03
Editing Files with Nano 00:21:00
Editing Files with Vim 00:26:24
Installing Programs with APT 00:28:06
Using Sudo for Root Access 00:32:29
Updating and Upgrading System 00:34:54
Graphical File Editing 00:36:05
Compiling C++ Programs (GCC, G++) 00:39:53
Executing Programs 00:40:57
Conclusion and Subscription Call 00:43:04

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. Today I’d like to show you a little bit about the Linux command line

inside of a terminal. More specifically I’m going to be doing this on Ubuntu Linux.

This is great for beginners to start to get to know how to issue commands and do

things like that and if you’re used to doing everything in a GUI in a graphical

user interface then you probably have no idea how much fun it is to actually

work inside of a terminal. There are tons and tons of programs that you can gain

can gain access to once you start getting more comfortable with the terminal.

When you look around at the open source world and all the wonderful tools that people make,

you’ll find out pretty quickly that a lot of programmers just write tools that only

work with the command line.

And you know, maybe later if someone else comes along and wants to add a graphical

interface for it, then they do.

But lots of times that doesn’t actually ever happen.

And so you sort of open up a whole new world for yourself when you learn to use the terminal.

when you learn to use the terminal.

Anyway, and then you also look really cool like a hacker.

So I’m on a desktop engine called XFCE

or a desktop environment called XFCE.

Most new Linux users who are on Ubuntu

are probably looking at the GNOME desktop.

So let me just say real fast,

if you have a desktop that looks nothing like this

and you think you’re on GNOME because you just installed vanilla Ubuntu or something,

then you probably want to take a look at the top left corner of the screen

for a little button called Activities,

or at the bottom left of the screen for a button that I think is like nine dots.

Both of those buttons will allow you to search for programs on the system.

What you should do is basically click one of those buttons

and then start typing in the word Terminal

until you see a terminal pop up and then you can click on it

and then you can launch it.

and then you can, you can launch it. Okay. So for me though,

I already have this set up on my desktop.

So I’m going to click on my little terminal icon and I’m going to launch a

terminal. For those of you who don’t know what terminal I’m using right now,

this is called terminator. I think it’s really cool.

I’m personally a huge fan of this terminal. Uh,

the main reason is that it’s really easy and fast to split the panes.

So you can do multiple, uh, sessions.

If you’re connected to multiple remote machines at the same time, um,

machines at the same time, you know, later in your career. It’s really convenient. It’s actually

kind of broken right now a little bit, but not too bad. I still love it. Okay, so I open up a

terminal. Technically, this is called a terminal emulator. The real terminal would just be like a

completely black screen, and you wouldn’t be able to see anything else graphical. So this is sort of

like a windowed program that runs another program under the hood that helps this program talk with

talk with the operating system and it sort of performs two-way communication and shows you

what the operating system is saying to you and doing and things like that. So,

but for all intent and purpose, this is a, this is a terminal. I always call this a terminal.

Okay. Let’s see. Maybe I need to increase the font size real fast. Um,

I got a profiles out if I do mono space and I just do it like a little bit, a little bit bigger

bigger than the default so it’s easier to watch on a video. Okay how about that is that better?

I think that’s probably better. Okay so for starters uh you’re looking at a command line

interface you’re looking at a terminal this is a terminal emulator program uh we have like a

blinking cursor you can enter commands and stuff like that it’s important to understand at first

that um you’re actually already inside of a program remember I said that the terminal emulator is a

and it helps go between you and the operating system.

There’s also another program that sort of interprets the things that you’re saying

before sending that off to the operating system.

The program is different depending on what environment you’re using,

but in Ubuntu, it usually defaults to bash.

So I’m going to type a quick command.

We’ll explain what these commands do in a second.

And I’m going to type echo shell,

and that’s going to tell me what interpreter we’re using.

So by default, we’re using an interpreter called bash.

So if you hear anybody say, hey, I’m in bash or I got a bash script.

Well, this is what it is.

It’s a program that will be understood by bash.

Okay, so what did I just type?

I typed echo and then I typed a dollar sign and then I typed shell.

So on the terminal, you know, you can type any command you want.

It may not actually work, but you know, you can type.

The way that your command is usually interpreted is if you type just one thing,

then that’s considered the program that you want to execute.

the program that you want to execute so if i type the word echo by itself and hit enter

then bash or i’ll just say you know the shell or the terminal is going to look for a program named

echo and if it finds it it’ll execute it um there’s a there’s a special way that it searches

for programs like uh the the program echo for example it has to it has to go somewhere in the

operating system right there has to be a path so if you type which echo you can see exactly where

system so slash user slash bin slash echo so that’s where it is but i can just type echo by

itself because the system knows how to go search through special system paths looking for the echo

program that you typed so it can find the real location anyway so i type echo and this program

launches and it doesn’t really do anything the thing about the echo program is if you just type

actually receive what you typed after after the echo program executable name

and it’ll just print it back to you.

So what’s happening here is the bash interpreter, the shell,

it’ll always take the first argument.

We call these arguments, words or symbols separated by spaces.

The first argument is echo.

That’s considered the program that you want to run.

And every argument after that is actually just sent into the program that you launch.

thing that’s actually launching here is the echo program and then hello is a string that gets sent

into the echo program you can do as many arguments as you want actually i don’t know if there’s like

a huge limit huge limit you can probably type a lot of these before you run out and so i’ve typed

three arguments technically the echo program is is argument zero the first argument but um i’ve

typed out three arguments that will get sent into the echo program and you can see that echo received

three of them and just printed them out and that’s it so it’s the echo program is pretty simple but

if i if i type a dollar sign and i like actually let me just type shell by itself if i say echo

shell it just prints the word shell because that’s interpreted as just like a regular string but if i

put a dollar sign in front of it then bash considers that to be a variable and so what it’ll do is it’ll

go into memory wherever the variables are stored and it’ll try to find a variable named shell

variable named shell and if there is one it’ll take the value that’s inside of shell which in

this case is just you know bash and it’ll convert the symbol dollar sign shell into

the actual variable value and then it’ll print that it’ll send that into the echo command

so if i say echo shell step one it looks for variable name shell step two it grabs bin bash

and replaces that where the dollar sign shell was written and then it sends that into the echo program

into the echo program.

So now you know how to launch a program.

Here’s another program.

It’s called clear.

If you just type the, you know, the command clear, then a program called clear gets launched.

And all it does is just to help you clear the terminal.

If you want to keep things a little clean, just to prove to you that this is a program,

we can type which clear and notice how it actually has a path in your operating system.

User bin clear.

This will be different if you’re on a different operating system than mine, but it’s all okay.

It’s all okay.

All right.

So where am I?

Because you can see that I’m at some sort of a location.

It says Mike at lectures.

That sounds like the name of my computer and the name of my profile.

But where am I in the file system?

Because your computer is like, you know, a big file system.

There’s lots of files and folders all over the place.

Where is the terminal sitting?

Is it sitting anywhere in the file system?

It actually is.

It’s sitting in your home directory by default, unless you’ve made some customizations.

unless you’ve made some customizations, I can access the current working directory

by typing the command PWD, print working directory.

And again, this is a program and its whole job is just to print

where the working directory currently is.

So the working directory means where you’re currently at,

where you’re situated, where you’re looking at.

And it’s saying that I’m in my home folder.

In Linux, the home folders are usually slash home slash your username.

So if I want to see what’s inside of my home folder,

I can use another program called LS, which just lists the contents of a folder.

So I’m going to type LS and it tells me I’ve got all these folders,

desktop documents, downloads and so forth.

LS takes arguments.

Remember, we have arguments like if we did echo hello,

then it’ll print the word hello, but we can give the LS command some arguments too.

We can say LS, I’d like you to do, you know, some stuff.

So what do we want it to do?

Let’s make it print all the files and folders,

even those that might be hidden because they,

on Linux, if a file or folder starts with a period

in the name, it’ll usually be hidden by default.

So if we want to print everything, we can say dash a.

And if I want to print in a vertical list style,

I can put an L in front of there.

So I can say LS, which is the program

and then dash LA is the arguments I give it.

And that’s going to tell it to print my directory

with all hidden files and folders shown.

Notice how all this stuff showed up

that wasn’t there before,

like bash history.

I have a cache folder.

But then there was also some stuff

that was there before,

like the documents folder,

the music and the pictures folder,

and so forth.

So you saw these things before.

Like, let me just at least highlight one.

So you saw the videos folder there before.

You just didn’t see all those other hidden ones

because they had dots

in front of their file name.

in front of their file name or folder name depending on what they are okay and

then of course you can see that this is a vertical list and you’re getting a

little bit better now at giving arguments to programs so how did we know

that ls takes dash la as an argument or as some arguments you could search on

the internet which is pretty fast usually you can also use a program

called man the man program will give you information on another program most

programs have MAN entries so when you install the program there there will be

like a new manual page that shows up in the MAN program so I’m going to type MAN

LS and hit enter I’m basically going to launch the MAN program and I’m going to

tell it that I want information on the LS program so I hit enter and then it

sort of shows me like a big you know little instruction thing a little sheet

a little well it’s actually not little depending on the program this could be

tells you all the things that we can do with this program. So right here you can see the

dash LA part that we did earlier. Whoops, what did I do wrong? The dash LA part that we did earlier.

That’s the dash A. And we could also instead have just said dash dash all.

That’s what the manual is telling us. Where’s that dash L, the listing? Let’s see, it’s somewhere in

here. H I J K L, maybe I should do a page down.

Maybe I should do a page down.

Yeah, there we go.

So, well, there’s no dash dash list.

I was hoping that there would be a dash dash list,

but this tells you at least that you can say dash L to use a listing format.

And there’s tons of other options that you can learn and read about

if you just take some time to explore the man page.

Kind of cool, right?

Okay, so how do you get out of this?

By the way, how do you search for stuff?

I’m going to search by using the slash key.

key so like you know the the web slash key I’m gonna hit slash and then I’m

gonna type something I’m gonna say maybe block and then hit enter and notice how

it highlights on the first match I can do a regular end to go down to the next

match or I can do shift in like a capital N to go backwards up to the

previous match so this helps you you know kind of search through man pages and

things like that and the cool thing about what the man page is using right

It’s using a way to display itself.

I think it’s either using a program called less or it’s using a program that works very

similarly to a program called less.

So the program less, it’s just, it loads up a document for you and it lets you do things

like this, scroll up and down, search for things, go to a line number, you know, and

just, you know, it’s, it’s, it’s very convenient, right?

Like it pages in the terminal.

If you want to exit this, you just got to hit Q.

So I hit Q right now.

So I’m going to do man LS again, hit Q, and then I get out.

So now we know a few commands.

We know how to see where we’re at in the file system and list directories and things like that.

Let’s go into the documents directory with a special command called CD.

So CD stands for change directory.

And if I just say documents and hit enter, now the shell itself is inside of a different folder.

It was in my home folder before.

Now it’s in my documents folder.

If you’re ever unsure of where you are, use the PWD command again to figure out what’s going on.

Okay. Oh, look, I am inside of my documents folder.

If you ever find yourself in some sort of a deep, deep subfolder, let’s see.

I don’t even let’s do like user live live.

LiveX32.

Oops.

What am I doing?

There we go.

What about this library?

I’m just going into a random folder right now just to show you that we can go pretty

deep.

So I think that I’ve reached the end of that.

Okay.

So suppose I’m navigating around and I’m in some, some kind of a folder and I’m at,

I do PWD and it says, oh no, you’re like way deep in some other folder.

How do I get back to my home folder?

Well, you could type out the whole home folder if you wanted to, but the easiest way to get

pwd with no arguments.

Once you hit enter, it’ll drop back down to your home folder.

And if you’re not sure, then use the pwd command.

Okay, so we’re doing pretty well.

We’re kind of like navigating in here.

Let’s make a directory.

I’m going to go into my documents folder again.

And let’s see.

So right here I’ve got like, whoops, I’ve got some documents.

Let me make a directory called temp with the command make directory.

so uh well mkdir is the name of the program the first argument i gave it was temp and so it just

created a folder for me called temp so if i say cd temp i can now go into the folder that i just

created if i list the contents of that directory again it’s empty because i just made it pwd lets

me know where i am just to make sure when you’re new to the terminal you actually i still use this

customize my terminal so it doesn’t print the full the full path there it just prints the current

directory name so i kind of get lost sometimes so you just use the pwd command to figure out where

you are and by the way just as a reminder we could always do man and the name of a program so i’m

going to say man make dir and there’s options even for making a directory i’m not going to go over

those but just to let you know there’s a lot to explore okay so now i’m inside of the temp directory

I’ve made a folder. What if I want to go one level up? What if I don’t exactly want to drop

to the home directory, but maybe I went one level too deep and I want to go back up one level.

Well, again, I could type out the whole thing. I could say go home and I could say documents

and whatever. But by the way, I’m hitting control C when you see that care at C that usually tries

to get the current program to stop. But when you’re inside of bash, it’ll just sort of like

abort the current command and go to another line.

Okay, so how do I go up one level?

Well, in Linux, there are two special directories

that have periods in the name, well, they are periods.

The directory known as period,

actually, let me show you the full,

yeah, okay, well, the empty directory listing,

notice how it actually does show me two things.

It doesn’t show me nothing,

it shows me these two directories right here,

that’s not a mistake.

So this directory, the one with just one period, that always represents the current directory

that you’re in.

So if I use just a period to go into a directory or to do something to a directory, that period

will represent something different based on where I am.

Am I in my home folder?

Am I in the desktop?

Am I somewhere else?

The period changes based on where you are.

dot it always means i’m getting used to this new pen setup it always means it always means there we

go it looks like a emo guy with his hair like to the side um it always means the parent directory

so remember before we could type we could type cd and then some directory name right to go into a

directory uh now we can type cd dot dot and that’s basically saying we would like to change directories

change directories, we would like to go to the documents directory.

Why?

Because the documents directory is the parent directory of the temp directory.

So if I say cd dot dot, notice how it goes up one level.

Let’s do that again just to be sure.

So I’m going to say pwd, and if I say cd dot dot, and then pwd again,

notice how we were in temp, and as soon as we went up one level,

it went to documents.

So it’s just kind of a quick way.

you know, use a bunch of directory names separated by slashes.

You can also put dot dot in any directory that you want.

So like imagine I’m in the temp directory again.

I could say let’s go up one directory and then a slash and then up another directory

and then a slash and then up another directory.

And I should end up in the home folder.

Isn’t that kind of funny, right?

So I’m saying like give me the parent directory of the current directory

and then give me its parent directory and then give me its parent directory.

So I went up three levels.

its parent directory. So I went up three levels.

So let me drop to my home folder and go back into documents and go back into

temp. Whoops.

I forgot to do CD.

Now we’re getting pretty good at navigating. Let me make another directory.

I’ll call it delete me because I intend to delete this directory.

There’s a program called RM remove that lets you delete stuff.

Actually first, before we delete that, let’s use a program called touch.

and the program touch just sort of like creates a blank file.

I think if the file already exists, it won’t mess with the contents,

but let’s do an experiment in a moment.

So I’m going to say touch blank file.

It should create a file for me called blank file.

So now I’ve got a directory and a file called blank file.

Now I can remove the blank file with the RM command.

So just RM and then give it the name of the file.

Be careful with RM.

He’ll destroy your file system if you’re not careful.

and now let’s remove the delete me folder when you try to remove folders you have to tell the

remove command that you intend to delete a folder by specifying also the dash r command which means

this is a folder i would like you to recursively delete it so let me just type it without that

real fast and it says hey i can’t do it it’s a directory so i’m going to say all right now

And it did it.

Some other useful flags you might want in the future.

The first one that I like is V for Verbo.

So it’ll print everything that it deletes.

And F for Force.

If you’re absolutely sure that you know exactly what you’re about to delete,

then Force will make it so that this program won’t start asking you,

are you sure? Are you sure? Are you sure?

So it’s kind of dangerous, but it’s also pretty convenient.

Imagine that.

Anyway, so let’s see what else can I when I talk about here, we know how to like touch to create a blank file and create a folder and navigate all around. Let’s edit a file. Let’s actually edit a file in the terminal. So there’s kind of like an age old argument between the Vim people, or the V people, and the nano people. And so I just want to say that if you were a Vim person, don’t ever talk to me again for the rest of your life.

again for the rest of your life just kidding you’re okay we can sort of be

friends but I’m personally a nano person so what am I talking about nano is just

another program it may or may not be on your system I think on a boon to it

should be there by default let me just double check yeah it should be there by

default we’ll talk about how to install programs in a second I’ll go sudo apt

install just to remind myself but so you type nano to execute the nano program

of a file that you want to edit.

So let’s edit a file called my program.

Whoops, program.cpp, just if you’re writing some code.

And this tells the nano program that you would like

to edit this file named my program.cpp.

You hit enter and you have like a nice little editor

that shows up.

Notice at the bottom,

you have a bunch of little shortcuts, right?

So if you do, actually let’s look at this one

Actually, let’s look at this one over here first.

If you hit control O, that means save the file, write it out.

If you hit control X, that means you’d like to exit the editor.

So if I want to get rid of the editor and just like, you know, go back to the terminal,

the normal command line, I’ll do control X.

There’s a bunch of other stuff you can do.

And there’s like a big help menu.

alt n to see line numbers in nano so that makes it a lot more convenient for coding so i’m going

to do alt n to get those lines off let me just type the word hello real fast hello

okay so now i want to save this let’s do uh we can do control o to just save it but we’ll stay

inside of the editor or we can do control x to save it and then exit the editor so i think i’m

going to exit them say control x notice how at the bottom it asks me do i want to save the modified

That just means I’ve been editing inside of this like, you know, temporary area.

Do I want to actually save it?

So I’m going to hit Y for yes.

Then it asks me, you know, what’s the name of the file that you want to save?

Well, since I specified my program when I launched Nano, it already knows what I want to do.

If you didn’t specify the name of a file, then you could provide it here.

So I’m just going to hit enter.

And now the program exits.

If I list the contents of the directory, I can see that I now have

the world’s worst C++ program ever because it’s just hello that’s not going

to compile so how do I see the contents of a file with the terminal well for

starters obviously you could just type the name of the program again for nano

and it’ll show you there it is I’m gonna hit ctrl X to exit out of it but

there’s another popular command that people like to use called cat cat

basically will go to a file load it into memory and spill it onto the terminal

to the terminal for you. I mean really what it does is it prints to something called standard

output and then the shell interpreter grabs standard output and it you know renders it to

the terminal but we’ll just say that this prints it to the terminal. So if I say cat and the name

of my program then it prints it to the terminal so you can check any program this way. Do yourself

a favor well do me a favor and do cat at the following path etc os release. The etc

The etc directory off of the root of the file system in Linux is usually where all of the

configuration files get stored.

At least the ones that are system wide.

So like system wide programs, their configurations are usually in the etc folder.

So there’s a special file in many operating systems, definitely Ubuntu, called OS release,

which just describes the operating system to you.

So here, if you’re not sure what operating system you’re using, or if you just want to

and kind of see information on it.

Well, you can say cat, etc.

OS release and see your OS.

So there it is, all this stuff.

Pretty fun.

Okay, so we did my program.

Let’s edit my program real fast.

I’m going to go myprogram.cvp.

And if I want to just say, I don’t know,

maybe I want to make this look a little bit more like a program.

So I can say integer main and we’ll just pretend that we’re not going to do any arguments.

Return zero.

So this probably would compile.

I think this would compile.

If not, then you might have to go into the number of arguments and then…

Don’t worry about this.

This is not a programming video.

A character pointer.

I can never remember if the brackets go before or after the variable name.

a new program i usually compile it both ways and see which one works um okay so oh i did it too

fast okay so i edited and uh if i want to just save my changes i’m going to say control o

notice how it asked me again at the bottom do you want to save it under the same name i just say

enter to say yes if i uh wanted to instead just exit the program i do control x and then

inside a weird area where you can’t really hit keys and you can’t exit very

well you might be inside of Vim some some operating system use Vim as the

default or some some programs so I’m gonna just enter Vim manually whoops

what am I doing is it Vim or V so I’m not a Vim user okay there we go so Vim is

like you know it’s very complicated some people say it’s lightning fast and it’s

By the time you need so many features,

you might as well just mount the remote file system

and use an actual graphical editor.

I’m just not a fan.

Don’t hate me.

You know, we can still be friends.

So if you’re inside of Vim, you hit the insert key

and then you can kind of like type and stuff like that.

So it’s whatever, but what?

Insert?

Okay.

I’m getting lost already inside of Vim.

I’m just going to delete this stuff that I created and so if you want to exit from

Vim hit the escape key first to make sure you’re not inside of insert mode or any

special mode and then say shift holen to enter command mode you’ll know you’re in

command mode because you see this little colon here next to your prompt or next

to a prompt and then I’m gonna say write quit write quit means save the file and

and then quit if you want to quit without saving the file you can just put q but uh vim will

complain if you’ve actually changed something and you’re refusing to save the changes so if you are

absolutely sure you want to discard the changes just say yes i want to quit with an exclamation

point so q exclamation hit enter now you’re out of vim hopefully you’ll never go back for the rest

of your life sorry okay so now we know you know a lot of a lot of stuff that we can do in the

Maybe we should learn how to install programs real fast or search for programs.

And then we’ll do a little bit of some graphical stuff.

Alright, so here’s the command that I wanted to remind myself of.

So how do we search for programs?

If you didn’t know this already, almost every single Linux distribution has a repository

of pre-compiled programs that are open source that you can use for free.

better and a lot safer than the old Windows method of just sort of like going

to random websites online and downloading programs and just kind of crossing your

fingers that you didn’t just download a virus.

What happens is the people who run the operating system, they’ll take the source

code for popular programs and packages.

They’ll compile it for you.

They’ll store the binaries, which are just the compiled executable files.

And then you can use certain command line tools to install those programs one by one.

those programs one by one there’s so many available that it wouldn’t make sense to install them all

by default because you’ll probably never use the vast majority but so we have a nice package

manager in ubuntu called apt it’s the apt package manager if you want to see more information about

it let’s see is it called aptitude or just apt we can say man apt yeah it’s just a command line

interface this actually i think this talks to d package under the hood but you know it’s just a

the package manager one of the sub commands for apt is search so we can say uh launch the apt

program with apt then we could say apt i would like you to search and what would you like app

to search for i don’t know how about a program called mousepad it’s one of my favorite text

editors on linux so what it does is it searches the ubuntu repositories and it tries to find you

know a package or a program that matches and if it does it’ll show you the listing okay so what do i

listing. Okay, so what do I have here? Mousepad is already installed on this system. Yeah,

that makes sense because I think I was just using it. And, you know, some other stuff that

you could find. So you can just kind of search for for anything like do you want a free accounting

program that you don’t have to pay for? It’s not necessarily going to be the best, you know,

but it’s free and it works and it’s good and a lot of people swear by it. Well, you can search

and there it is i don’t have it installed on this machine but new cache free accounting software

do you want to learn to make memes against your enemies well there’s a program for that called

gimp it’s basically it’s kind of like at this point i think an old school photoshop clone

not clone but alternative it’s really good for memes and there are actually a lot of very

talented people who use gimp to do like very artistic things so there it is right there gimp

and it’s GIMP because it’s the GNU image manipulation program.

There’s also another one that’s a little bit more artistic, I think.

I haven’t used it.

I think I used it once.

It’s called Krita.

Oops, sorry, not apt-Krita, apt-search-Krita.

And there it is.

So there’s like a bunch of different choices for any idea that you could have.

Just think of what you want.

You want another browser, another image editor.

You want accounting software.

accounting software you want an audio let’s see is there I think there’s one called our door let

me see apt search you want to like mix music at home so I want to type the name of the program

our door but I want to see if I can find it by just searching for a music term let’s say a

DAW digital audio workstation let me scroll up a little bit yeah there it is okay so I searched

program that came up right here it’s like a very very very popular free and open source

digital audio workstation with like so many tracks that you can mix and and effects and

you can record with it and do all these crazy things um so i’m just trying to show you that

linux is not just for you know coding and and boring stuff there’s there’s a lot of fun stuff

on linux that you can access for free uh through these repositories okay so let’s actually install

Suppose I’m ready to make memes against my enemies.

So I’m going to say sudo apt install instead of search install.

And I’m just going to type the name of the program GIMP.

Oh wait, hang on.

I’m not supposed to show you sudo just yet.

So let’s do sudo, let’s do apt install GIMP.

By the way, sudo is supposedly outdated and people are saying you should use something

else, but I don’t know.

Old habits die hard.

apt install GIMP, the system is telling me that I don’t have permission to install a program

on this machine. And that makes sense. That’s probably a good thing, right? You don’t want to

just let any user totally, you know, redo your system. So it’s saying, you know, could not open

the lock file permission denied. Oh, no. Unable to acquire the d package front end lock. Are you

root? Oh, okay. So what this is basically saying is that in order for us to do root level activities,

like install a program on the system, we need to elevate the command line to root.

And how we do that is we pretty much just say sudo, which is the name of a program that

helps us quickly elevate. It also actually does like a lot of other stuff, but

for now, we’re just going to use it to elevate the command up to root.

So if I say sudo apt install gimp, what’s happening is the sudo program gets invoked,

and then it just executes apt install GIMP as root.

Let me just prove to you that sudo will elevate a command.

So if I go, who am I?

It’ll tell you the name of the current user.

If I say sudo who am I,

then sudo will launch who am I as the root user.

And then who am I should tell us,

whoops, got to enter the sudo password.

You actually have to be an admin to use sudo, just FYI.

So if I say sudo who am I, notice how it prints root.

So if I say sudo apt install gimp, it’s really just going to invoke apt install gimp as the

root user and it should allow me to install that program.

Gimp is already installed.

Okay, I guess I was making memes earlier and I forgot about it.

Well we could remove it.

Gimp.

Then it removes it.

Yes.

I don’t think I was making memes on this machine.

I think something funny is going on here.

And now that it’s removed, I could install it again if I wanted to.

I could say sudo apt install Gimp, and then it might ask you to push yes and enter.

And then it just kind of finishes.

Also if when you’re trying to install things, you get a message that says, repository could

like a 404 error cannot be connected to not found your repos out of date you know whatever that

might just mean you need to update your system so i’m going to say sudo apt update telling apt that

i would like to update its idea of all the packages and then sudo apt upgrade

so update just contacts the server and gets an idea of what packages there are and their versions

the system or it actually upgrades the system when you’re done with that you

usually want to do auto remove to just kind of get rid of any junk that’s left

over if you happen to remove things recently this stuff up here this is sort

of like a corporate upsell you can probably ignore that at least for now

but yeah so we know how to like do lots of stuff in the terminal just just to

open up the let’s see we’re inside of the temp folder okay so I have the temp

folder inside the terminal I’m gonna open up my file system here and I’m gonna

go into the same path so we were inside of let me just show you again with PWD

we were inside of home mic documents temp so let me go inside of the home

folder it’s not downloads documents temp and notice how I have the same file

I can right click on this or even double click on it and I can open it up with

Mousepad or even this nifty little code editor called genie if you’re interested in genie

It’s actually pretty nice pseudo apt install genie and it’ll tell me that this program is already installed

I like to use it because you know vs code and other IDEs. They’re great for productivity

But they kind of help you a lot and if you’re trying to learn, you know coding or whatever

or whatever sometimes it’s a little bit better if you just use something kind of plain because

then you’ll learn more it’s harder uh you know that’s up to you anyway so i’m gonna right click

on this and i’m gonna say let’s open this up with the how about mousepad i guess

now i am graphically editing uh this file because maybe maybe you want to you know edit everything

in nano maybe you don’t maybe you only want to use the terminal when you have to but uh well

have to but well here you are let me do a cat command let’s see my program cat

notice how it’s the same exact file I can I don’t know maybe put some empty

comments up above the function name for fun and save the document and then just

kind of do the cat command again and you can see that my changes have been

updated so you can delete in the regular file system here in XFCE the file

thunar and there should be a symbol somewhere or if you just kind of hit the start menu let’s see

how about office where is thunar usually oh it’s in accessories okay and then if you’re on a gnome

uh it’s probably just called files or i forget what the name of the file system is but you know

something that just looks like a folder um so we’ve edited that we’ve got all the basics here

we know how to navigate we know how to get to our home folder we’re like making directories

deleting directories removing files touching files editing files we’re doing a lot and just to let

you know there’s like so much more you can do on the terminal for instance you can let’s see do we

have gcc on this computer no gcc is what people use to code in c plus plus right so i’m gonna say

package on Ubuntu called build essential.

I think it’s singular, not plural.

And this is sort of like a meta package, which means it’s like a dummy package

that installs a bunch of other packages.

So build essential.

It’ll grab all these other programs for you for like,

it looks like a bunch of C++ stuff and there should be like GNU Mac in there

and some Perl stuff, I guess.

Yeah, I’ve never actually looked at this.

That’s not a lot of stuff that I use.

There’s just a few things that I use in there.

But anyway, you install that and then you’ll get GCC,

which will help you code in C++.

You can also do sudo apt install,

Yasm to install your assembler.

What else?

So GCC and G++ and Yasm and make and an editor.

I think that’s kind of like almost all you need.

Well, you can install a debugger,

Well, you can install a debugger sudo apt install

GDB to install your GNU debugger, which is already installed.

Okay.

Anyway, well, just to let you know, we can do GCC to compile some programs.

It’ll complain.

We don’t have anything.

Let’s see.

Actually, let me go in there.

Let me go to documents temp.

Let’s see if it’ll compile this just as is GCC my program output.

And I’ll just say that we want a program called main.

It’s going to work.

main is this going to work did it actually work oh my gosh i got it right on the first try even

though it was an empty program doesn’t really do anything oh by the way um in linux or in the

command line you probably will see a lot of people do this sort of thing where it’s like dot

slash in the name of a program the thing is in order to execute a program uh i’ll tell you about

permissions in a second first it needs permission to execute but then you need to provide a path

path to the program. You can’t just type main as is because the system, you know, the shell is going

to think that you’re talking about a system program somewhere. So it’s going to look in all the system

areas and it doesn’t find a program named main. So you have to give it a path to your custom

programs to run. So I’m going to say dot slash main. And basically remember the dot was a special

directory that meant the current directory. So if I type dot main, it’s actually kind of the same

home mic documents temp main.

So if I just type this whole path right here, it runs the program

or I can do, you know, dot slash main.

It also runs the program.

In both cases, it works.

Let me edit this real fast to see if I can just get something exciting going on here.

I’ll stream and then I’m just going to go.

Okay, so I’m just going to like do that.

just gonna like do that let me try to compile again gcc my program output to

execute what called me oh what did I do wrong oh gcc is for just regular C

programs you’re not supposed to do that I want to use G plus plus and then I’m

gonna say standard library I don’t know C plus 21 or something std what did I do

Is 21 not a valid year?

I don’t even remember.

I’ve been using C++17 forever.

What did I do wrong?

STD equals C++.

Okay, 17 I know definitely works.

What am I doing wrong here?

Okay, so 17, I guess 19 wasn’t a thing.

Been using 17 for a long time.

Okay, so I just compiled the program again with the C++17.

Well, then what the heck was I doing yesterday?

Was I using 23?

Hang on, sorry.

I forgot what standard I was on yesterday.

Okay.

So then if we run the program again, it prints a message.

So maybe I should retitle this video, your first C++ program, because that’s literally

what we just did.

You know, I’ll make another video.

the basics of the Linux command line.

And well, you’re off.

Well, I hope you enjoyed this video and you learned a little bit of stuff.

Keep watching all the other videos and I’ll see you in the next one.

Hey, everybody.

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor, could you please subscribe and follow this channel or these videos or whatever it is you do on the current social media website that you’re looking at right now.

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

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to 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 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

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 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 Ultimate Beginner’s Guide to Linux Command Line: Ubuntu Terminal Basics & More appeared first on NeuralLantern.com.