Get hands-on with x86-64 YASM assembly in this in-depth tutorial on writing functions! Perfect for beginners and seasoned coders, we cover the basics of function creation, calling conventions, argument handling, and return values. Learn to avoid crashes, respect the ABI, and use prologue/epilogue for clean code. From printing messages to returning integers, see practical examples and tips to simplify your assembly programs. Subscribe for more low-level programming tutorials and take your skills to the next level!

Introduction to Functions 00:00:00
Makefile Overview 00:00:19
Assembly Program Setup 00:02:01
Data Section Definitions 00:02:08
Text Section and Entry Point 00:03:02
Basic Assembly Program Demo 00:03:38
Return Codes Explained 00:04:30
Function Concepts Introduced 00:06:10
Creating a Simple Function 00:07:04
Function Call vs Jump 00:08:00
Adding Return Statement 00:09:06
Moving Print Logic to Function 00:09:48
Benefits of Functions 00:10:01
Calling Function Multiple Times 00:11:58
Creating Print Function with Arguments 00:14:00
Handling Function Arguments 00:15:45
Respecting the ABI 00:17:16
Prologue and Epilogue 00:23:15
Stack Operations 00:24:34
Calling Print Function 00:25:25
Avoiding Recursive Loop 00:34:17
Modifying Print Function to Print Line 00:35:21
Adding CRLF Function 00:30:13
Printing Multiple Messages 00:37:00
Returning Integer Values 00:37:48
Preserving Registers in Entry Point 00:41:50
Final Program Demo 00:43:24
Conclusion and Call to Subscribe 00:45:16

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 functions in x8664 Yasm Assembly.

I’m just going to give you the basics of how to write a function.

So let’s get started here. First thing I want to show you is just a makefile.

This is not a makefile video, so you don’t have to worry about it too much.

I just have it up because I need it for this demo.

If you’re interested in makefiles, that would be a really, really good thing.

thing i’ll probably make videos in the future about them but for now we’ll just say you hopefully have

a script or method already set up that allows you to compile or assemble assembly programs

so i’m just going to skim through it real fast if you’re interested you can kind of study it

but basically i have like a little define here that allows me to print out a message that looks

nice and then i define the repo path as the current path and i take the absolute path of that

This is where the real work happens.

I have Yasm flags because I’m using the Yasm assembler.

I’m going to be assembling to x86 64.

I like to out.

I like to convert all of my warnings to errors to make sure that I don’t write sloppy code

export debug symbols and export debug symbols for the linking stage to the name of my executable

is going to be called a main.

have set up and well I can just do make run or make debug as a little shortcut

to run it in GDB if you don’t know GDB don’t worry that’s going to happen in a

future video and make clean which just cleans the build area I like a clean

build area and then this is the main command here we’re going to be using LD

to do our linking because this is going to be a pure assembly program instead of

a hybrid program which would require GCC or something else and then here’s my

And then here’s my program main ASM is going to get compiled down to main.o and

That’s it for the make pile

Okay, so for the main assembly program I have some stuff written up already here, but I think I’m going to modify it for this video

For starters, we have our data section which hopefully you understand already

I’m just going to define a bunch of stuff in the data section like I’m going to define

The system call code to write a string so I can print a message pretty easily

so I can print a message pretty easily the system call code to actually exit the program

remember when you’re writing a pure assembly program that has start as an entry point

you need to be you know you’re responsible for exiting the program so the system call code is

60 there and then I’m going to say exiting for success is a zero that’s kind of a standard thing

and then I’m going to make two file descriptors for the standard input it’s going to be zero and

the standard output it’s going to be one actually I don’t think we need that for this video we just

We just need standard output, but not standard input.

And then I’m just going to make two strings.

That’s not my name, but I like those names.

And then the BSS section.

Actually, I’m going to get rid of that

because we don’t really need that for this video.

And then I have a text section, which is where all the code is.

We’re going to begin our entry point.

If you are writing a pure assembly program

and this is your entry point module,

make a function called underscore start.

It’s not actually technically going to be a function because it won’t return anywhere.

It’ll actually just call the system exit service.

And then I mark start as global so that the operating system can go into it,

can call it from the outside.

And then all I’m doing right now is I’m printing a hello.

So far, this is not really a demo of functions.

This is just like a very basic pure assembly program.

All it’s going to do is it’s going to enter.

going to print the hello message and then down here it’s going to do a system call to exit the

program with zero for success so let’s just see what that looks like real fast I’m going to do

make run and then make run you can see the first line it just kind of prints and then the second

line that’s make sort of echoing the command that I’m issuing it’s just going to assemble the main

dot asm into a main dot o and then it’s letting me know that if there are any warnings it will

It will refuse to compile.

And then I use the LD linker to link the main executable.

And then I actually run the executable.

So only below this line that I have highlighted right now

is gonna be the actual program.

So you can see all it really did was just,

you know, print the message and then exit.

Just, you know, a little note here.

I’ve probably said this in other videos,

but the return code zero is kind of a standard

to indicate success for programs,

which is very useful if you want programs to automate other programs.

If I change the system, let’s see what is it, exit success.

If I just change that variable to a 3 so that I will exit with a return code of 3 instead of 0,

then the operating system, or actually bash, since we’re in a terminal emulator,

should consider the program to have exited in error.

So you can see now it’s like, hey, hey, hey, the makefile system,

oh not bash, the makefile system is like that program exited with code 3,

three something went wrong and normally if you don’t add any extra stuff into your make file it’ll

just refuse to continue at that point well so i’m just going to change it back to a zero and make

sure that it still works and then we’ll get on to actually writing functions so i’m going to go clear

and make run so it’s a little bit faster for me to run this repeatedly you can see actually the

first time that i did that um the make file recompiled notice how it recompiled um and

and relinked because I changed that source code.

This is not a make file video, but I just want you to be aware.

One of the great reasons to use make or a build system in general

is because it makes it really easy to compile your code faster.

Notice how if I didn’t actually change, let’s see.

So I recompiled it because I just changed it again,

but now I haven’t changed it since I’m going to recompile or rerun.

Make just kind of like skips reassembling that file because it hasn’t changed.

it can make your compilations and assemblies much, much faster.

So anyway, functions. Functions in assembly are kind of simple and you’ll realize that

some of the stuff that we take for granted in higher level languages is being done for us

automatically by the compiler. But in assembly, we have labels. So for example, this start entry

some valid symbols like characters underscore numbers I don’t think you can start a label with

a number correct me if I’m wrong but I don’t think you can so we have like a label which is just like

this collection of characters and then we have a colon after it and so you can jump into a label

which I’ll talk about in a different video but you can jump into a label you can call a label as a

function and so a label isn’t actually a function by itself you have to treat it in a certain way

the abstract so notice how there’s no return statement at the bottom here let me write a

function real fast and maybe i will have it so that i have a function that just says hello for

me so i’ll make a label down here function that says hello and i’ll give it a label and i’ll say

maybe like say hello and i’ll do a little label there first thing that you should do when you are

trying to create a function is just put a return statement at the very end of it.

That way it will return to the caller because if you don’t then it’s just going to continue

to execute downward until it reaches no code and then the program will probably crash. In fact

maybe I should do that. I’m going to do say hello as a label with no return so it’s not really a

function now. It’s more of just like a label that you can jump to but there’s no code under it so

I’m not even sure this will assemble, but it’ll definitely crash if we can call into this.

So let me do, at the very start of our program, I’m going to type call say hello.

Or actually, you know what, maybe first I’ll jump to hello.

Jumping is going to be for a different video, but jumping just means go to that place.

It’s a go-to statement, essentially.

You’re not supposed to be able to return from a jump.

but it doesn’t really follow the same design pattern logic as a function.

So I’m going to immediately jump to the say hello logic and see what happens.

I think that it’ll crash.

Here we go.

SegFault, core dumped, oh no.

So, hey, it crashed.

So instead of jumping there, let’s do a call.

Now we’re treating it a little bit more like a function.

We still don’t have the return statement down here.

So it should still crash, I think.

Let’s try that again.

Yep, it crashed again.

Because you’re supposed to exit from the operator, or you’re supposed to exit from the program

properly to the operating system.

So now I’m going to do a return statement here.

There’s never an argument for the return statement.

You just simply return to the caller.

This uses the stack.

If you don’t know what the stack is, I’ll probably make another video about that in

the future.

But the stack, you know, it helps your program understand where it just called to and how

to get back from it.

to get back from it it also stores local variables and things but so if i have a call it should jump

down to the hello function and then return meaning it’ll just return to the caller immediately without

actually doing anything but the program should be able to continue without crashing notice how

there’s no crash here all it does is print out the welcome message and then no problem all right

printing stuff and I’m just going to cut it and stick it inside of the say hello

function that way when I call that function it should still print hello but

now notice how we have less code to deal with in this primary function you know

one of the first things that that programmers learn is that you know we’re

human beings we’re not computers it’s really hard for us to write complex

logic in a program without tools to help us and design patterns to help us to

help us stay on track to help us you know make sure that we’re not going to

we’re not going to be forgetting anything or screwing something up or you know to debug so

you know one awesome design pattern is to write functions because you you you realize in your

program you might be calling the same logic several times so you’re sort of like repeating a bunch of

code that already is bad it’s really hard to debug repeating code and it’s really hard to make updates

to it and it becomes unwieldy right so as soon as you realize you’re repeating the same logic

places you should think about taking it and putting that logic into a function

and then just simply calling that function many times it makes your coding

a lot easier and then once you put all the work into getting a function to

work you’re just you can just be done with it as soon as you’re sure that

this function actually works you can just put it to the side and just forget

about it you can stick it at the bottom of the source or just ignore it put it

into a different module whatever you want to do and then the other parts of

of the program that you’re still working on they become a lot more simple and so you know because

we’re human beings we need all the advantages we can get to write powerful code so i am now just

i’m not i don’t have to think anymore about all the system call things that’s happening

to print the hello message all i have to do is think about calling the say hello function

and of course this is simple but you can imagine using this for more complicated

concepts in the future so let’s see if this still works if i didn’t screw this up

It printed the same exact message.

And if I keep running it, you know, the make file doesn’t compile as much, but it still

runs the program.

If you don’t believe me that this is inside of a function now, let’s actually just call

that same function many times.

We’ll call say hello.

Let’s say we call it five times.

This should work.

I’m going to run the program again.

Notice how it printed that message five times.

Just to reemphasize my earlier point, wouldn’t it be a huge pain in the butt if you wrote

all the code for the system call and the message printing five duplicate times?

Wouldn’t that be hard to update? What if you had a hundred of those in there?

What if you had something that was really complicated and you called on it like

50 times,

wouldn’t that be so much better than maintaining 50 different versions of the

exact same idea of code and, and, you know,

making sure that if you needed to upgrade it or change it in some way,

you actually got it right for all 50 copies. So this is way better.

All right. So that’s the basic idea for a function.

for a function let’s see what else can i do um let’s let’s make a function that just prints

anything because that would be kind of a good little practice in the uh in the arguments that

we can use remember in c plus plus and other languages you have function signatures that

you can use so for example say hello we know for sure that say hello is not actually doing anything

it’s not receiving any arguments and it’s also not returning anything so if we know it’s not

returning anything. So if we know it’s not returning anything, we can say that it’s a

void function if we’re talking C++. We’ll do the name here. We’ll say say hello. And in the

argument list, we know that it doesn’t take any arguments. So it’s just say hello with nothing,

right? Okay. So let’s make another function that just prints something. And this function will

kind of be a little redundant because if you just sort of look at the system call here,

we have to load up the system call with the standard output and the system write code.

So that’s going to be repeated.

So we could move that into the print something function, but then, you know, giving an argument

of like, here’s the string I want to print.

And here’s the length of the string that I want to print that, that is something that

we can pass as arguments every time.

So we’ll be saving like a little bit of work, but it’s still, I think, I hope illustrates

the idea.

Maybe we will, oh, print something.

Okay.

So print something.

Maybe we’ll do the signature here.

Print something will not return any value.

So we’ll just give it a void return type.

And I’ll do a description up here.

Print a message given by a character pointer.

A pointer to a string.

character is also a pointer to a C string, not a regular string class, but a C string.

So I don’t know how to describe it. I think I’ll just say a pointer to a C string

and length and integer length maybe. So that means the print something function should take

two arguments. We want to be able to call that function and tell it, here’s a pointer to the

string I want you to print. And here’s how long the string is. So still talking about C++, I’m

character pointer p and maybe i’ll put like string just to remind myself when i look at this later

it’s a pointer to the string or like p char for the pointer to like the first character in the

string something like that and then length so the length is going to be a long because we’re using

64-bit integers in this video long and i’ll just say maybe size or length or something so now we

I want to use the same symbol that I’m describing in this little prototype here.

So I’m just going to copy paste it and use a colon.

And then because it’s a function, I immediately want to put a return statement at the very end.

Okay.

So then what I need to do is grab the incoming arguments.

Okay.

So, well, the first thing that every system call that prints a string should do,

at least if it’s going to print it to standard output,

to print it to standard output is it should start setting up the system call code registers or the

system call registers to say all right the system call wants rax to describe what the system call

is going to do we already have system write set up so that just means we’re telling syscall that

we want to print something where do we want to print it we want to print to the standard output

which if you look at earlier in the video that was just a file descriptor of one so that’s fine

up the system call and then the next two things can be kind of variable uh you know we can we

can grab that from incoming arguments so rsi wants a pointer to the string we’re not going to load

hello string but we’re going to load whatever character pointer we were given in the incoming

RDI is the first incoming integer argument.

We’re not going to talk about mixed arguments with floats.

If we just assume that we’re only going to use integer arguments or pointer arguments,

then the first one is going to be RDI.

So that means by the time print something gets called,

by the time we come into this code right here,

RDI should be loaded with the pointer to the character to the C string that we want to print.

Again, this follows something called the ABI, which you should absolutely respect,

which you should absolutely respect even if you’re the only one writing any of the code that you

interact with your code will be bad and considered not good if you don’t respect the abi on this type

of architecture so we definitely still need to load rsi with the string pointer but art whoops

but rdi is what’s going to have the string pointer so we actually already just ruined rdi when we

probably either load it up backwards or i think probably a better way to explain functions is

let’s just use another register so i’m going to use another register to sort of store our incoming

arguments i personally like to do this i admit that this will cost you cpu cycles to sort of

like move things around in registers but it’s still way faster than sticking something into

a global variable because then you’ll be hitting memory so first i’m going to say let’s move

to r12 and I want to store the incoming argument so I’m just going to write here save the

the p care you know c string character pointer or something like that so we’re going to save it

and then the next thing we need to do is save the size because as soon as we load up rsi we’re also

going to be destroying the second integer argument which should come to us in rsi

Okay, so I’m going to save that too, I guess, with R13.

So I’m going to move something into R13, RSI, and then save the size of the C string.

Okay, so we saved both of those.

Now, when we load RSI, we can just sort of say, RDI is saved.

And then when we load RSI…

Oh, that’ll be when we hit RDX.

Oh, that’ll be when we hit RDX. Okay, I got confused. So we stored R12 was the character

pointer. And then for the length of the string, we stored that as R13. Also for me personally,

I feel like it’s a pretty good idea to kind of make a comment at the very top, because this is

assembly. It’s really, really hard, right? Make a little comment at the top, just kind of reminding

yourselves what you use all of the registers for. I know sometimes you’ll use the same register for

sometimes you’ll use the same register for multiple purposes.

You could either write that down

or you could consider breaking up your function

into multiple functions.

That’s totally valid

and it probably will make your life a lot easier.

Anyway, so I’m gonna say register usage

and then I’m gonna say R12 pointer to string, C string.

And then I’m gonna say R13 is gonna be

size of the string. And that seems simple but remember assembly especially when you’re new

it’s really confusing and for me when I was first learning and even sometimes now I’ll be staring

at a big blob of assembly code and I’ll just be like what register was I using you know or I’ll

look at a register and I’ll be like what was that thing even for? So just make yourself a little

comment up here to help you understand and then you’ll thank yourself later when you get a little

a little bit too overloaded or maybe even if you come back to your code a month from

now probably having totally forgotten what you even wrote then you’ll just have a nice

little reminder here.

It’s good to document and this is one of the ways that I recommend.

Okay, so we’re saying that R12 and R13 are going to be used.

We’re loading them up here from the incoming arguments.

Now RDI and RSI are free to be destroyed if we want and of course we have to destroy them

because RDI and RSI were incoming arguments when this function first came in but now that

first came in but now that we’re going to be doing a system call we have to use

them for incoming arguments to the sys call so they’re just they’re just meant

to be constantly destroyed so we’re gonna do call code there and then the

standard output is gonna be the first argument and then the string that we did

which is an r12 is going to be the second argument and then rdx is going to

be the next argument which is r13 which came into us through the second argument

wait wait wait the string to write came into us through the first argument the

came into us through the second argument but if you just kind of look at what we’re doing to the

system call it’s actually the second and the third so I mean just forget about it okay so we set all

that up let me make sure I’m not forgetting something by scrolling up real fast yeah so now

we can do a system call one other thing that’s very very important about functions is you have

to respect the ABI and that doesn’t just include using the right registers for incoming arguments

out a call but you also have to keep in mind which registers are denoted as callee saved

if something is callee saved then that means you know if i’m inside of print something

i’m being called that means i’m the callee so that means if i’m going to use r12 and r13 which

are designated as callee saved maybe i’ll pull up that my favorite assembly book after this

but if i’m using registers which are designated as callee saved then i have to preserve those

then I have to preserve those registers, meaning those registers,

they should have their same values from when they first came in on the call

when I exit the function. So when I exit the function, those registers,

register values should appear to be untouched to the caller.

Remember these registers are not local variables.

They’re global to the entire system. There’s only one R12 on the whole CPU.

So every program that runs every function that gets called,

see the same exact R12 register. So if we’re not careful about preserving when we have to,

we could end up crashing other programs or our own program. So anyway, let’s do something that

I like to call the prologue and the epilogue. That’s another nod to my favorite assembly book,

which I’ll probably show at the end of this video. So prologue is just, hey, let’s preserve

the stuff that we need to preserve. We will preserve the R12 with a push and we will preserve

and we will preserve the R13 with another push.

We then have to restore them.

So right now when we do this push,

that just means that whatever value R12 and R13 had

is going to go to the stack.

So we’re going to hit memory.

That’s not great, but like we have to in this case.

We’re going to push it onto memory

in order to preserve the value.

And now we’re free to destroy the value if we want.

And then right before we return,

we’ll just pop those values.

So that means we’re going to go to memory.

We’re going to go to the stack.

to go to the stack we’re going to grab the values that we just pushed and put them back onto the

registers oops forgot to do 13 and 12 and I’ll call this the epilogue just meaning like we’re

done we’re cleaning up and of course look very carefully at the fact that the push and the pop

sequence are in reverse order notice how we push 12 first and we push our 13 second then at the end

Then at the end, we pop R13 first, so it’s backwards.

It’s like a little shell, you know, the R13s are on the inside

and the R12s are on the outside.

That logic would persist if we pushed,

or if we had to preserve more Kali saved registers,

if we were using more stuff.

The reason we do that is because the stack as a data structure

will return data to you backwards in the reverse order

that you returned it or that you sent it into the stack.

it into the stack so if i send a 12 and a 13 let’s just say the number 12 and the number 13

into the stack then if i start popping stuff out of the stack it’s first going to give me the most

recent item which is going to be the 13 so it’s going to give me backwards data and then it’ll

give me the art the 12 seconds so um the type of data structure a stack is is first in last out

last out no that’s a that’s a queue anyway so we’re preserving the registers we’re doing the

system call we’re probably okay to call this function now so let me see if i can do this

i’m going to comment out all of these things that the the say hello function does and i’m just going

to call on print something in order to call that function but i have to load up my arguments i have

pass arguments remember in the print something function it’s got a signature

it wants a character pointer and a size we can’t just call it without giving it

those things or it’s going to look at the registers anyway and just grab

whatever junk data happened to be in there so that would be bad so first we

have to load up the registers load up argument registers and call print

load up the argument registers and call print something.

So the first thing is going to be RDI, so we have to move something into RDI

and then the second register for the second integer argument is going to be RSI.

As far as I recall, if I’m wrong this is going to go horribly wrong.

I’ll double check the book after this.

And what do we want to do?

We want to basically, inside of say hello,

we could assume for now that say hello hardcodes the pointer and the length.

So we’ll just say it’s going to grab the string from global and it’s going to grab the string

length from the global variables.

So it’s going to load up those two arguments and then call on print something.

This still ends up being three lines.

That’s why I was saying before, we’re not going to save too much, but we did save, you

know, these two lines right here, you know, and the system call line.

So it’s like slightly faster to do.

You just load up two pointers and then you make a call.

in this video so I can’t really make the function better but in the future when

you learn how to loop and and learn about null terminated strings you could

basically just pass a pointer to just the string only and then call on a

function if the function was smart enough to scan through the string and

figure out how long it was based on where the null terminator was but that’s

gonna happen in another video anyway so if we call print something it should

Notice also that we’re having a function call another function, which is pretty cool.

So we have our entry point, it’s going to call on say hello, and then once we’re inside

of say hello, we’re just going to load up some arguments and then call on the print

something function.

The print something function then does most of the work for the printing, and I think

we’re ready to go.

Let’s see if this works.

All right, so we’re going to clear and then just run the program.

Oh, that was so fast.

That was so fast I don’t even feel like I’ve proved anything.

Let’s comment out the system call so that all we really do is just load up some registers

and then don’t do anything.

And then you should see here that the print something function no longer actually does

anything because it was too fast.

Now if I uncomment the system call, you know that the print something function is actually

doing something and it’s printing the message five times.

We can also make some more messages if we wanted to,

just as a way to make this video slightly more interesting.

I’ll say msg1 is going to be a string of bytes,

and I’m going to say this is message number one.

Boring, sorry.

And we’ll do a crlf there.

Actually you know what, let’s make a function that does a crlf.

Okay, let me just finish message one length,

and we’ll do it equals that special string that you can do in yasm am i doing this right yeah okay

so this is message number one so now we’ll call again with message we’ll call say hello just once

and then we’ll call on print something loading it up first move something with rdi and then move

message one is that what I had message underscore one and then RSI is going to

get message underscore one length so basically we’re just you know print the

first message it’s always a good idea to put comments on each line when you’re

learning so that you don’t forget what’s happening in addition to like a comment

for the whole block but I’m not going to do that here let’s just make sure that

make sure that this actually works so it should print two different messages now

one okay nice let’s enhance this a little bit more later i think i’m going to have us print like a i

don’t know a character or maybe we’ll do a return value from something so we can just show you how

to do the return values but i’m just going to enhance this a little bit more we’re going to say

let’s make another function we’ll call it crlf the crlf function i don’t want it to do all the

system call stuff because print something already does that for us i’m instead just going to make

message so now that means i’m going to go crlf and that’s just going to be a 13 and a 10. remember

you can define a c string with quotes but you can also separate quoted strings by commas and also

integers just to sort of tack it on so you know this variable right here it’s going to be a

sequence of characters representing the string that you see and then at the very end of the

string it’s going to have a crlf carriage return line feed so that the cursor goes to the next line

goes to the next line so I’m actually gonna take that off of message one

because it’s gonna be here just on CRLF and then I’ll say CRLF length is gonna

be two I could also do that special thing probably a little smarter CRLF

yeah I mean it’s it’s better to avoid hard coding things if you can avoid

hard coding the number two or any number just do it I guess I have to hard code

So, so CRLF and then length.

And so that means in my CRLF function, let’s see, let’s do CRLF, CRLF immediately return

because it’s going to be a function.

I’ll just say void CRLF with no arguments and prints a carriage return new line, also

known as CRLF.

and so that just kind of describes it and I don’t need to preserve RSI and RDI

because those are not callie saved registers so respecting the ABI kind of

helps you in this case I’m just gonna copy paste here and maybe I’ll copy

paste that comment real fast too so I don’t have to like type that whole thing

out and instead of doing hello string we’ll just say CRLF and then for here

And now when I call CRLF, it should just make the cursor go down a little bit.

So let’s test that out.

I took the CRLF off of message one.

So if we actually run this right now on modified, it should have the cursor.

Now, what did I just do wrong?

On number 28 and 29, instructions expected after label.

I guess I forgot to complete something.

Oh, I forgot to put, it’s a byte sequence right there.

there and I forgot to put that this is basically a defined sequence you know

that EQU okay my bad okay so now it prints notice how the message line it no

longer does a new line and no longer jumps to the next line CRLF so that

means when the program exits the terminal prompt is on the same line as

the program just printed that’s ugly and awful so let’s call

We could either say, let’s call CRLF after printing the first message,

or we could just assume that print something is like print a line.

I don’t know how you feel,

but I think if we always called CRLF after every time we printed a message,

I would probably be a little irritated.

So maybe let’s change this to print line and then make it call CRLF.

You can just keep adding this like 1013 at the end of every string, but I think I want

to try to make this as compact as possible.

So let’s add the CRLF for now and then we’ll change print something later.

So we print the message.

Now the prompt should be, you know, a line further down.

So great works.

I am now going to take the CRLF off and I’m going to put it inside of print something

so that right after we do the system call to print the string in question, we’ll print

we’ll print a new line this should now accomplish the same thing that we just saw

oh no what did i do i think i did uh i think i have a infinite loop of recursive calls in there

somewhere i had a stack overflow probably so let’s see what did i just do say hello is call

print something and then crlf is call print something oh whoops print something calls crlf

at the end so i should do one or the other and not have them call both so maybe just because crlf is

special maybe i’ll just use a direct system call inside of crlf i thought i was so clever

but i was wrong so we’re going to repeat a little code for the crlf and we’re going to load it up

with um crlf dang how embarrassing i like to say this is the most public of my many humiliations

of my many humiliations. But anyway, so now we don’t need to rely on print something. So this

won’t be an infinite loop and it should work if print something calls on crlf now. Do it again.

Okay, it works. So now let’s modify print something so that it is just print

a line. Print a line. And then that, in my eyes, you don’t have to do it this way. It sort of

to do it this way it sort of justifies printing a crlf at the end every single time so this is

just my personal thinking and then maybe i’ll add a comment after prints a crlf

so now when we call print line we no longer have to call crlf

and then when we print that message should be pretty good oh we got to update that to print line

Then for say hello, let’s just double check.

We can get rid of this system call code here.

Probably a good idea at this point.

And then we just say print hello string.

And then from the hello string, we can get rid of this CRLF at the end of it.

So I’m just going to get rid of that.

Actually, let’s do it first without getting rid of it.

Just so you see, oh, what did I do wrong?

Lion 61, forgot to update the symbol name.

Oh, there we go.

call print line because we don’t have print something anymore and try it again notice how

the first message hello my name is it has two line feeds after it because it is calling print line

which will do a crlf but then also in the string itself there’s a crlf so again the point is i’m

to my advantage.

Okay, so we got that working now.

I’m just going to print like five different kinds of messages.

How about three?

So we don’t have to sit here and watch me typing for too long.

So I’m going to say message two and then I’m going to do message three.

Message three.

This is message three unless I got that wrong.

One, two, three, one, two, three, one, two, three.

Now we can just call a print string on three different messages.

And I’ll just change this to say, you know, print the second message, print the third

message.

And then I’m going to change that to message two and then message three.

All right.

So then I’m going to do that again.

And then all three messages get printed.

Nice.

So now one more thing.

I just want to show you how to return an integer to the caller in a basic YASM x86 assembly function.

Again, this will not cover floats.

This does not show you how to return floats.

With floats, you have to use a different register called xmm0.

That’s going to be a different video.

But for now, I’m going to say all integer or pointer return values, like longs is going to be what we’re using,

that is the register that is designated for return values.

So what about this?

Instead of just returning the exit success code

that I’ve defined up above,

we’ll return whatever some function call gives us.

Maybe I’ll make another function down here

and then I’ll say a function

that just returns a simple long value.

And we’ll call this function gimme long.

We’ll call this function gimme long.

It’ll take no arguments because we’re just keeping this simple for now.

And instead of having a void return type, it’ll have a long return type because we expect

RAX to be loaded up.

So then I’m going to say gimme long and immediately do a return because it is a function.

And then I’m just going to load up a value from somewhere.

Obviously, it’s better if you’re doing something complicated to stick with registers as much

or defines and hit memory only if you need to.

And try not to hard code immediate into your code

if you can possibly avoid it.

It’s probably a lot better to define a value up at the top

in the data area than to just hard code it here.

But I’m gonna just hard code something here.

No, I always second guess myself.

I’m gonna say exit gimme.

I’m gonna define something up here.

So it’s easy to find what value I’m gonna return

for the gimme.

I’m just going to say 88, 89, 90, I don’t even know.

About 33, I don’t even know.

So we’re defining exitGimme as a symbol

to just be a replacement of just the number 33.

So down here, I’m going to say,

let’s have gimme long simply return exitGimme into RAX.

Nice, okay.

And so that means it’s the official return value

once you call gimme long.

call gimme long so that means up here get our whoops get out it’s coming from inside the house

get our return value from gimme long and again imagine gimme long might be a big complicated

function that decides what a return value is going to be or does something so i’ll start with saying

call gimme long because gimme long does not take any arguments i don’t have to load up any registers

load up any registers nor do i have to worry about preserving them or setting them up or doing

anything i just call but then let’s see inside of this function we’ll use rax in order to you know

load up the system call to let it know what function or sorry what function we want from

the system call so we got to give rax system exit so that means down here we can’t actually use rax

those other registers again I’m going to use I’m going to use the r12 register

I’m going to do like a little comment here that says register usage and I’ll say r12

maybe I’ll do a tab r12 is going to be old return value

or the syscall to exit you know whatever and that’s all we’re going to do so in the prologue

I’m going to push R12.

You should probably even preserve registers in the start function

because something might, or in your entry point,

because something that called you might be counting on those registers.

This is going to be probably especially true if you’re using GCC

to have a main entry point within a hybrid program.

So I’m just going to go prolog, push R12,

and then pop R12 at the very end.

Pop R12.

That’s not going to work because by the time we get there,

because by the time we get there,

it’s gonna exit the program.

I’ll do this here.

I’ll just try to be a good citizen.

I’m not actually sure if we need this

for a pure assembly function,

but it’s just a really good habit to get into.

And what is it gonna cost you?

Just a touch memory,

just one time right before the program exits.

It’s not gonna be a giant for loop or anything.

Okay, so epilog,

probably I might be showing you bad practice

by preserving things in the underscore start function.

But again, you will definitely wanna do this

Again, you will definitely want to do this for the main when you return from main.

So we do prolog R12, epilog R12.

I made a comment there.

And then we’re going to store the return value in R12.

So that means here we’re going to move something into R12.

It’s getting precarious because we restored it right before the system call,

but I think it’ll be okay.

system call but i think it’ll be okay we’re going to grab rax because rax is supposed to be the

return value register so when we called gimme long it loaded up rax with our return value

we then send rax into r12 so we can use r12 uh even though our rax has been you know destroyed

we’ll still have the return value that we wanted to use so i’m just going to load r12 up into the

first argument of the sys exit call let’s see if i if i got this to work or if i totally ruin this

work or if i totally ruin this okay all right so let’s see here what was

why is it not erroring gimme 33 exit gimme should i did i load the wrong value exit gimme what is

it doing exit gimme it’s moving rex into exit gimme so you call gimme long and then you move

r a x into r 12 and r 12 i wonder if that destroyed it

hmm let me get rid of this push pop pair because it’s supposed to be giving me

an ever message that the function or that the program did not exit maybe this is proof that

you don’t need to preserve inside of the underscore start function let’s see here

yeah okay i guess that proves it hey don’t take my word for it i’m wrong all the time

For yourself, be a scientist, be a computer scientist.

Try it out.

Try to do something different.

Okay, so I guess this is proof we don’t really need a prolog and epilog in just a pure assembly,

at least the entry point for start.

But if you were calling any other functions, then they definitely need to preserve.

And again, if you’re using GCC, so you can have a main for your entry point, then you

still have to preserve.

you know print the message and then print our other three messages and then the return code

is going to be 33 that was the gimme code that we did so now we know how to return a value from a

function and um let me set this back to just zero so the make system thinks that we succeeded

run it again succeeded all right i guess this concludes the video i hope you had a little bit

and I hope you learn a little bit of stuff and I’ll see you in the next video.

Hey everybody, thanks for watching this video again from the bottom of my heart.

I really appreciate it.

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

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.

world to me and it’ll help make more videos and grow this community so we’ll

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

keep making videos in general so please do do me a kindness and and subscribe

you know sometimes I’m sleeping in the middle of the night and I just wake up

because I know somebody subscribed or followed it just wakes me up and I get

filled with joy that’s exactly what happens every single time so you could

do it as a nice favor to me or you could you control me if you want to just wake

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

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

which is coming for us all.

Thank you.

The post Mastering x86-64 YASM Assembly: Functions Made Simple 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.

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

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

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

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

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

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

What does it mean to link a program?

What does it mean to execute a program?

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

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

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

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

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

We’ll call it first.cpp.

First.cpp.

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

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

do main.

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

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

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

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

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

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

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

I just wanted you to know real fast.

Okay.

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

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

Cpp.

STD.

And L.

Okay.

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

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

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

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

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

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

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

There are a bunch of other standards you can use.

We can turn on all warnings.

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

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

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

And then we’ll give an input file.

We’ll say burst.cpp.

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

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

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

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

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

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

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

That just means it has execute permission.

The compiler does that automatically for you,

but essentially this is like just, you know,

an executable binary file.

It’s not a text file.

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

We can look inside of it real fast.

There’s a program called XXD on Linux,

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

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

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

right?

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

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

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

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

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

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

That makes sense.

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

How do you execute the program?

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

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

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

even if it’s in the current folder.

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

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

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

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

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

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

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

And we know that you need execute permissions.

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

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

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

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

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

Notice how it’s not in green anymore.

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

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

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

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

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

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

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

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

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

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

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

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

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

know, like C++.

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

better about specifying the name of the output file.

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

a script that will compile our program for us.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Can do that pretty easily. There’s something in

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

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

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

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

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

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

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

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

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

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

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

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

So let me first remove a dot out.

And then let me try first to execute compile.

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

Remember we talked about that before.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

I could just put that into the script.

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

I guess it gets too messy.

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

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

Notice how it compiles and then lists everything for me.

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

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

Let me see if I can do that real fast.

If not, I won’t waste time.

This is not an LS video.

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

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

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

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

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

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

It’s like a level lower than assembly.

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

So we’re skipping a ton of steps.

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

Oh, whoops.

I’m on the wrong machine right now.

Okay.

Where’s that?

Oh, the machine that I’m recording on.

There we go.

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

fine-tuned control over your compiling

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

stage maybe i should do a comment linking stage

compile the c++ program or source or something

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Let me remove star dot O.

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

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

Okay. So let’s nano compile.

Let’s create a second source file actually.

Okay. So let me get out of this.

Let me get out of this.

I want to create a second source file.

I’m going to call it second.c.

It’s going to be a pure C program.

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

I’m just going to say, you know,

standard input output dot O for the header.

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

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

a little message.

So I’m going to say hello from second.

And then do a new line.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Sorry, I got sidetracked.

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

Maybe it doesn’t matter.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

I think it’s not going to print it.

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

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

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

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

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

We’ll do it one more time here.

Notice how it seems to work.

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

I’ll put a bunch of Zs there.

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

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

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

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

Functions whoops. I’m in the wrong language

Let me go back to the compiler

make a function in bash

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

that we want it to alert us of.

So I’m going to say echo,

I’m going to say we are dying now.

Previous exits code was,

maybe I’ll do a little variable here,

I’ll do a local variable.

Exit code is going to be the first incoming argument.

This is a bash program, not C++.

And then here I can just say exit code.

Okay.

So then after writing all that,

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

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

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

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

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

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

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

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

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

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

I wanted it to be fancier.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Let me fix that.

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

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

a little bit more automatable.

Yeah, now it stops right away.

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

Let me fix the first source code real fast.

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

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

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

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

than just typing things on the command line, right?

You can take this as far as you want.

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

So let’s see.

Well, let’s do another source code.

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

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

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

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

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

Does that mean I have eye problems?

I am kind of old now.

I don’t know.

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

So I don’t have to do it elsewhere.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

And I want it to output the third object file.

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

Okay. So now this might work.

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

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

and compile.

Unrecognized debug format, dward.

Why didn’t you stop me?

It’s g dwarf.

Let’s see, what did I do wrong?

g dwarf, oh, dwarf dash two.

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

Sorry.

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

Yeah, okay.

Let’s see if that works.

What did I do wrong?

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

Okay, I had it right the first time.

Doop doop doop, okay, so it probably linked.

Let me run it and see what happened.

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

So now we’ll do the same thing.

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

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

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

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

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

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

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

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

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

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

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

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

So let’s do it again.

Compile it and then run main.

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

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

what’s happening in here

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

or not.

Then I’m going to try to run main.

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

Let me show you what I’m talking about.

I’m going to remove main.

You’re okay.

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

So obviously if everything works, then everything works.

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

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

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

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

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

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

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

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

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

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

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

Sometimes these lines get really, really long, right?

And it’s messy and irritating.

At least for me.

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

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

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

It’s the drive slash.

I don’t remember forward slash backslash.

I just say web slash and drive slash.

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

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

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

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

Maybe M64 on its own line.

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

And maybe these two on their own line.

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

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

And then the output file on another line.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

So let’s see.

We got G dwarf two, G dwarf two.

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

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

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

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

So I’m going to go GCC flags.

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

And I’ll just insert instead GCC flags.

And if you want to be extra careful,

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

Probably should be fine.

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

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

So wall pedantic, just paste that.

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

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

That means I can get rid of those two flags.

And then wall and pedantic are going to show up.

No pi is kind of a linker only thing.

So is the no exec stack.

I think probably that will be okay.

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

Oh no.

Unrecognized command line option.

Wall pedantic GCC.

Oh, I guess because I quoted it.

I shouldn’t have done that.

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

I should have remembered.

So I’m going to unquote it right now.

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

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

Let me try one more time.

Yay, it seems to work.

Okay, we got a warning here.

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

but not for C.

Okay, so basically I made the mistake

of trying to send a C++ object,

which is this right here, or sorry,

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

into a C compiling command.

Not great.

So what if I did this?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

And then we could have linking flags.

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

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

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

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

And we’ll just manually add that dash C.

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

and organize these things any way you want.

So I’m gonna do,

well, this might actually work.

I’m getting distracted.

I think it works.

Okay.

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

There’s a two in there still.

Let’s debug that if it happens again,

then I’m gonna remove main.

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

Okay, let’s see.

Is there gonna be a two in there now?

Is there going to be a two in there now?

No, is that only when it fails?

Only when something fails to compile?

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

You know what?

Leave a comment somewhere letting me know

where you think I went wrong with this two,

and maybe I’ll release another video

or something in the future,

at some distant point in the future.

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

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

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

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

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

I’ll see you in the next one.

of my heart i really appreciate it i do hope you did learn something and have some fun if you could

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

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

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

we’ll be able to do more videos longer videos better videos or just i’ll be able to keep making

Do me a kindness and and subscribe. You know sometimes I’m sleeping in the middle of the night

And I just wake up because I know somebody subscribed or followed it just wakes me up and I get filled with joy

That’s exactly what happens every single time

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

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

Also, uh, if you look at the middle of the screen right now

You should see a QR code which you can scan in order to go to the website

go to the website which i think is also named somewhere at the bottom of this video and it’ll

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

the services and tutorials and things that i offer and all that good stuff and uh

if you have a suggestion for uh uh clarifications or errata or just future videos that you want to

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

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

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

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

coming for us all

Thank you.

The post Compile, Link, Execute: A Beginner’s Guide to Linux Programming with C++, C, and Assembly appeared first on NeuralLantern.com.

Hey there, coders! Want to master Git? This fun, beginner-friendly tutorial covers all the basics: what Git is, how to track changes, commit code, create branches, push to remotes, and collaborate with others. Whether you’re coding solo or with a team, Git’s got your back. Avoid losing code, recover old versions, and learn pro tips to dodge merge conflicts. Subscribe for more coding tutorials, and let’s make version control a breeze! #GitBasics #LearnToCode #ProgrammingTutorials

Introduction to Git 00:00:00
What is Git 00:00:07
Git for tracking changes 00:00:18
Git for non-code documents 00:00:24
Why use Git 00:00:45
Code versioning benefits 00:00:50
Recovering deleted code 00:01:15
Collaboration with Git 00:02:35
Git repository basics 00:04:33
Installing Git 00:04:44
Creating a Git repository 00:05:08
Using git status 00:06:36
Adding files to Git 00:07:51
Committing changes 00:08:18
Checking Git log 00:11:21
Viewing changes with git diff 00:12:21
Pushing to remote 00:19:44
Cloning a repository 00:17:01
Branching in Git 00:23:27
Merging branches 00:25:21
Tagging releases 00:16:00
Pulling changes 00:26:55
Branching strategies 00:29:55
Avoiding merge conflicts 00:32:52
Backup and fresh clone tip 00:34:00
Conclusion and call to action 00:35:00

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hey there, I’d like to talk to you today about the basics of Git and what is Git.

Git is an awesome system that you can use to track changes to all your code as you write

programs and work on things. And in fact, you can use Git for tracking changes to a wide variety of

documents, not just code only. There’s a special tool that I used a while back where I could track

used a while back where I could track changes to just regular office documents.

But if you’re writing text files of some sort or even like, I don’t know, making SVG graphics

files or something like that, you can track changes to all sorts of stuff. Okay, so it’s

mostly for coding. So what is Git and why would you want to use Git? Okay, so we talked about

Git being a code versioning system. It will track your changes. Imagine this.

Imagine you’re writing code and you spend all day, maybe like all month writing a really,

really good algorithm or a really good function or something like that.

And then maybe a year later, you haven’t been using it.

And you kind of think to yourself, you know, whatever happened to that giant function that

I wrote, that was really good.

And then you realize, oh no, I accidentally, I think I deleted it like several months ago

because I thought I didn’t need it anymore.

I didn’t need it anymore.

And now I’ve changed my mind.

I wish I had that back.

But then by then it’s too late because the code is gone and maybe you don’t have a backup

or maybe your backup is just, you know, only a few snapshots deep or whatever.

And so you’re kind of screwed, right?

So one way that Git can help you is Git lets you look back in time to the state of your

code at any other previous point.

Like every time you make significant progress with your code, you log it in Gits database.

You can just look back in time.

You can look back to see what your code was three years ago.

It’s awesome.

You can also, you know, revert changes.

You can sort of like branch your code off in two different directions.

Maybe here you’re just going to be working on bugs and on another branch, you’re adding

one feature that you think might be a good idea.

a really good idea you could merge that branch into the main branch or if you think that feature

is and is going to be trash and it sucks and you wish you never did it you can just delete that

branch and it doesn’t affect your main code branch it’s really cool it’s also a good tool

for collaboration because multiple people can can push to the git database and they can get

each other’s changes it’s kind of a way also to cloudify your code you know like if i’m writing

writing a program, I can commit some changes and I can push some changes to the cloud.

And then my colleague can pull my changes and they get everything that I just worked on.

And then they can commit some more changes and push it back up to the cloud.

Then I can pull it.

And so we’re sort of like collaborating and in a way where every single change is logged,

your boss can look at, or you, you know, you can look at all the logs in your commit,

in your git commit database and see who changed what you can see what lines were changed when

when they were changes you can see who introduced a bug there’s a function in

git that is called git blame where you can look at a source code file and you

can see who is responsible for every single line you can bookmark states of

your code you can do so much it’s wonderful but anyway I just want to

touch on the basics today I hope I’ve kind of convinced you that git is a

little bit of a good idea I used to just sort of code and then you know do copy

paste as my backup copy and it was okay but when I started using git even by

started using git even by myself without collaborating um it was tremendously valuable

there were many times when i wanted to look back at a previous state of code and git let me do it

many times when i wanted to revert some mistake that i made and git let me do it

okay so you see my terminal here maybe maybe i should reduce the transparency just a little bit

to like maybe like 85 opacity.

That’s a little bit better.

Okay, so I’m gonna go into a documents folder.

I’m gonna go into a temporary folder

and I’m gonna remove everything that is, whoops.

Okay, that was just something I was working on earlier.

Okay, so I’m in a folder.

So what is a Git repository?

Actually a Git repository is just a folder

with some extra information inside of it.

Let me see, I don’t remember if I installed Git on this machine.

I did.

Okay, if you don’t have Git, you can get it pretty easily with sudo apt install git.

Or if you’re on Windows or some other operating system, you can just go to Git’s website.

It’s git-sem.com or something like that.

You can just find the installer and just get it in there.

But, so let’s say, let’s say I want to make a repository.

directory my repository okay so I’ve got like an empty folder I’m going to go inside of it

and this is just a folder it’s not a repo yet I can convert this folder into a repository by

just using the command git init oh gosh here’s like a message oh you got to choose what branch

you want I think it’s actually okay at this point I think they’ll choose one for me when you see

this you can read them and obey them but they’re not necessarily mission critical while we’re just

learning so notice how when i list the directory it’s no longer empty there’s a there’s a git

folder inside of there so if i go inside of the git folder i mean this is really not so much for

humans you can kind of do configuration stuff in here but um this is really gets database of

everything it knows about your code you know when you change stuff what’s the configuration

So if you actually remove this folder, I’m going to remove the Git folder.

That’s all it takes.

Now this folder is just a regular folder.

It’s no longer a Git repository.

So you probably don’t want to do that once you’ve initialized it,

but I’m going to reinitialize this again.

If I had a bunch of history inside that folder,

then it would have been gone already.

But we’re just learning.

This is just an empty repository.

So I have a Git repository here.

here. First thing I want to do is try to figure out what Git thinks about the repository. So I’m

going to use the command git status. Whenever you’re not sure of what’s going on, if you think

you need to commit something or push something or pull something or whatever, it’s probably a good

idea to use git status. I use it all the time. Git status and then git will tell you what to do.

It’s basically telling you that you haven’t done anything at this point. So that’s okay.

a readme file in markdown, my, oops, my project.

You don’t really need to know about markdown to use Git,

although the two kind of go hand in hand on GitHub.

But I’m just going to say, well, here’s my project.

This is my super cool project.

Okay, so pretend this is a program, a complicated program.

So I’m saving it.

We can verify that I actually like put something into that file.

So now I’m going to ask Git, you know,

you know, what do you think about the state of this repository?

So I’m going to say git status.

Git is telling me now that we’re on the master branch

and there are no commits yet.

And I have an untracked file.

This means that the readme file is not considered part of the git repository.

It’s just sitting in the directory tree.

So I want to add that into my repository so I can start tracking changes.

So I’m going to say git add and then the name of the file.

What have I done?

Okay, here we go.

What have I done? Okay, here we go.

That’s not how you spell add.

So now that I’ve done git add, I can say git status one more time to see what

Git thinks about the state of my repository.

Git says, well, you definitely use the add in order to put the changes on a stage.

Git likes to bunch up changes on a stage before you actually commit things to the

database. The reason for that is maybe

maybe you spend an hour doing a bunch of work in a bunch of different areas of your

different areas of your program, but maybe there’s only like a few files over here that

are part of a logical change.

Like this is feature a that I was fixing, but you also changed a bunch of other files

that were related to something else like feature B that I was fixing.

It doesn’t really make sense to take all of those changes and make them one commit because

you want a nice clean commit log that shows exactly what you were working on.

And it makes sense.

you just worked on a bunch of different files,

you can add all the feature A files to the stage first

and then commit that as one change

and then go over to the feature B files

and add those to the stage

and then commit that as a second change.

So it’s kind of a way to get you out of the mess

you’ve put yourself in

if you’ve just been working too long without committing.

You should really do a git commit

every time you make significant progress.

Like, I mean, it depends on where you’re working

where you’re working or who you’re talking to. You definitely don’t want to commit every line

that you change. You definitely don’t want to work for like a month and then do one commit at the end

of the month. The sweet spot is somewhere in between. Your boss will probably tell you what

to do. For me personally, every time I fix something, I’ll make a commit. One thing,

you know, I made significant progress in my program by adding a new feature. One little

feature, I’m going to commit it. Some people like to do commits at least once a day so that if

to do commits at least once a day so that if they’re working on a huge new feature, then

they’ll do like one commit a day. And then they’ll sort of like call those several commits

part of like a new feature. It’s up to you. But at this point, we just have the one file

that we made up on the stage. It’s ready to be committed. We used git status. So git

is just telling us how to commit it. It’s like, oh no, it’s not telling us. It’s just

saying we need to commit it. It’s not saying how. If you want to unstage it, then here’s

commit command is just git commit now it’s going to ask me for a commit message this is what you

will see in the log so don’t just put work don’t put change don’t put something that doesn’t

describe what you did you should describe exactly what you did so so what i’m going to do is for

the commit message i’m going to just sort of say what i did you can imagine writing something like

i created the readme file it should always definitely describe exactly what you did

um but it seems like a lot of people use uh i guess grammar and and and terseness

just to make the commit message sound like they told somebody to do something so create the readme

file instead of i created the readme file create the readme file so i’m just going to make that my

commit message save the buffer and then uh now that i’ve committed the changes i have to ask

you know git status what did i do you know what’s the state of the repository it is now saying that

that the repo is clean, everything looks pretty good.

So that means my changes are recorded in the Git database.

I can now actually use a command called Git log to see what changes have been recorded.

Notice how there’s only one change.

It’s just, you know, my name here, when it was changed and then what I did.

There’s a hash here.

This little hexadecimal string is called a hash.

to show me what happened in any specific commit by saying git show and then I give it a hash

and it’ll tell me exactly what files were created or changed or deleted or whatever

and there it is right there this will get more interesting in a second let’s make a change

I’m going to say edit the readme file and we say this is my super cool project this is my first

So I’m going to say git status to find out what’s going on.

Git says, oh, you made a change there.

It’s not saying that this file is not part of the database.

It’s just saying that we made changes.

I want to see the changes that it’s talking about.

I could say git diff.

And it’s telling me that I added this line.

My dog is growling at me.

about peeing oh my gosh hang on

so i’ll let him back in he’ll try to lie to me and he’ll try to get free treats

okay so uh we can use the command git diff to see what our changes are we can also say

git diff whoops git diff and then name a file and it’ll tell us what’s changed in that one file

second line so great back to get status it’s saying we need to stage that change

so I’m just gonna say get add and then the name of the file get status again

so that we know what’s up it’s saying all right well you just need to commit

the changes on your stage if you’d like to so yeah sure I’m gonna say get commit

and I’m gonna say you know changed the readme or something okay get status

So now if we do git log, there’s two entries.

Imagine that this happens every single time

somebody makes a significant change.

You know, it’s just like it goes in the log.

You can figure out who changed what.

Watch this.

Let’s do cat readme so we can see the readme.

Notice how it’s got the second line at the end.

I could also go back in time

and see what the state of my project was

was after that first commit so i could i’m going to copy paste that first commit and i’m going to

say git checkout and the commit hash it’s now telling me something hey by the way now you’re

looking back in time you should not change anything you’re on a detached head if you’re

ever unsure of where you’re actually at in git you should do git branch all and it’ll just sort

of show you where you’re at i was on the master branch now i’m on a detached head but notice if i

But notice if I spill the contents of the README file.

Hang on, what did I do wrong?

Change the README.

Oh, sorry, it’s in reverse order.

I always forget that.

I copied the wrong hash.

So let me check out the first commit that I made.

So I’m going to say git checkout the first commit hash.

Okay, now I’m going to concatenate the,

or I’m going to spill the contents of the README.

Notice how the readme looks like it did when we first made it.

So we’ve gone back in time.

Think of how useful this could be if this was a huge, big project with a bunch of files

and a lot of lines per file.

So once again, we’ll do git, actually let’s do git status.

Status is reminding me that we’re on its attached head.

and we can also use git branch to see that we’re still in the detached head you want to get back

onto the master branch or whatever branch you’re working with before you continue working so we’ll

status and you can see that we’re on the master branch.

Then we can say get branch all.

And there we go. Maybe we want to bookmark this.

Maybe we want to remember, oh, this is a perfect state of our of our code.

Maybe this is version one point.

We can do get tag version one point.

Oh, and now we have a bookmark forever.

How can we find the bookmarks?

Well, we can say get tag just by itself, and it’ll give us a list of our bookmarks.

When we push this to a remote server, the server will be able to show it like

remote server, their server will be able to show it like GitHub or GitLab or whatever.

And then later we can do something like, you know, get checkout and then just check out the

name of a tag. So it’s kind of the same thing as checking out a commit hash, but it’s like

a bookmark that’s a little bit easier to remember. So let’s look at remotes for a second,

because right now we’re not pushing code anymore. We’re just remembering what we changed in our

Okay, so I’m inside my repository.

And now I’m going to go up a level on this right pane,

and I’m going to make a new directory.

But I’d like to clone the original repository.

Imagine that this repository, it’s a folder to us,

but it could be for all we know, sitting on a remote server

and accessed with a special URL.

So you can go to like GitHub or somebody’s server,

and you can copy their get URL for their repository.

repository. Over here in our local file system, we could clone the original repository.

Usually you would have to copy paste like a big get URL, SSH URL or HTTPS URL or whatever.

But you can even do this locally so I can tell get I would like to clone this local repository

denoted by this folder name. And I would like to call it my clone or something. So I’m gonna say

So I’m going to say get clone repository my clone.

It says cloning and done.

Now we have two folders.

And if we go inside of the my clone repository,

we should have the same state of code that we just cloned.

So that makes sense.

Now think about collaboration.

We can change our code from the clone.

And as long as the clone has permission to push back up to the remote,

back up to the remote then it actually would work.

So let’s edit the README file real fast.

So I’m going to go nano README and I’m going to say this change was made by the clone.

Okay, so I did that.

And actually just to make things interesting, I’m going to change my git identity only inside

of this clone.

You can do that in git.

config and you say something like user.name, you know, you can put your name here, your email,

whatever, for like user.email. There’s this thing that you usually do where you say get config

global. And that means you’re changing configuration that is account wide. So like

your entire account on this machine is going to be changed when you use that global flag.

But if I don’t use the global flag, it’s just changing my configuration for only this one

this one repository so i’m going to make my name clone dude and make my email

clone dude at laptop or whatever at server so now if i say git status over here it’s telling me hey

i have like a change i say git diff and it tells me oh look i you know you changed that last line

so i’m going to add that change to the stage and then i’m going to commit it and i’m going to say

I added something to the readme.

Okay.

Git status.

Notice how git status is saying something a little bit extra this time.

Before, we were just in a local file system only.

And now we’re working inside of a clone.

So this is like, you know, you clone some code from GitHub

or from your friend’s server or whatever.

And when you do a clone,

it actually automatically links your local repository

repository to the remote repository. By the way, in Git, everything is considered a local copy. So

it’s not like you’re working with something different than the server has. You actually

have the entire Git history and all the code and everything that Git has on the remote,

except for maybe some like configurations or something. But when you pull, you’re just making

you’re making a copy later we can push our changes to the server and that just makes

the two repositories talk to each other sort of and reconcile changes and make sure that both sides

have the differences i guess so it’s telling us we need one more step it’s saying git status and

it says you’re on the master branch your branch is ahead of origin master by one commit what’s

origin master you can find out all of your remote connections and get by saying git remote v so when

so when you clone it automatically makes an origin remote it calls it origin and

then it has the URL or in this case just the file path of where the remote is so

it’s telling you that our remote where we’re connected to is the my repository

folder that we were at in the left pane so it’s telling us also if we go back to

just status it’s telling us that we should use git push to publish my local

my local commits to the remote because at this point we’re out of sync if uh if somebody else

cloned the remote repository and then made a bunch of changes and then pushed then i would now be

totally out of sync with that new person who cloned and also the remote server and it would

create something called a merge conflict which is like a little bit more advanced than this video

and we’d have to take steps to resolve it so the smartest thing to do is um well if you’re

Make sure that everybody is designated a certain file or set of files to work on and you all talk to each other.

Hey, I just pushed some code.

You need to pull.

Hey, I’m about to push.

Hold off a second.

Hey, I just pushed.

If you’re working on something, you’ve got to pull my changes before you do a push.

Always push after you commit so that everybody has the latest copy on the remote so you don’t cause conflicts with your teammates or whatever.

and always try to do pulls regularly.

Anyway, so I need to push my code.

I’m going to say git push.

And it’s saying, oh gosh, what is it saying?

Oh, okay, okay, okay, okay.

This is going to be a special setup that I have to do.

Let me just very quickly revert what I’m doing here.

I think I have to…

Oh, I know what to do. I can just make it a little trick.

Usually the thing is they don’t want you to push onto a branch that the remote has currently checked out into the file tree.

But usually remote servers, they don’t have a branch checked out.

So you won’t even see the file system on the remote.

It’ll actually all look like just this.

There’s a flag called bear that you can use to make that happen.

But I don’t really want to go through all the steps right now.

So what I’m going to do is I’m just going to make another dummy branch and then just kind of sit on it for a while.

dummy branch and then just kind of sit on it for a while.

That way I’m allowed to push to the master branch.

So I’m going to say get branch.

This is how you make a new branch.

I’m going to say dummy or something.

Whoops, got to spell branch, right?

Then get checkout dummy and then get branch all and then get status just to make sure

I’m now sitting on the dummy branch.

And then this will cure the problem that we had a moment ago where we’re not

allowed to push to a branch that the remote has checked out.

branch that the remote has checked out so i’m gonna say git oh wait hang on gotta go back in there

my clone git push okay so now it works uh so keep in mind if you’re pushing to you know a remote

that has a branch that’s checked out like it’s another file system like it’s a friend’s computer

you’re gonna have to worry about this sort of thing but if it’s a server like github or just

someone who has set them set the repository up properly uh you won’t have to worry about it so

Forget about that for now.

So I pushed to the remote.

If I do git log over here, there’s a mix.

It shows, you know, Mike created it and then changed it.

And then the clone dude added something too.

Okay.

So if I say git log, we should now see the history for only the dummy branch.

So that’s just two things.

And if I say git checkout master, and then I check out and then I look at the log for

I can see all the changes that the other person made.

Pretty cool.

I could also go back into the dummy branch if I wanted to.

I actually used to do this a long time ago before I realized you should do bear repos.

Let’s see.

Check out dummy.

And then I’ll say git log just to confirm that the changes aren’t in there.

So now we have two branches that are kind of diverging a little bit.

the master branch has one more commit than the dummy branch and if we let this go on for far too

long it might be more of a hassle to make the branches merge again but i’m just going to merge

them right now so i’m going to say git merge verify that you’re sitting on the correct branch

that you want to be the destination branch so i’m sitting on the destination the dummy branch so i’m

going to say git merge and i’m going to give it the name of the branch that i want to merge changes

It’s telling me that something happened.

So if I do get branch again one more time, I’m still on the dummy branch.

But if I do get log, notice how I have that latest log entry.

Pretty cool.

So now I’m going to go back onto the master branch because I want to do some work here.

This is a little clumsy.

If we’re talking about a server client paradigm, just bear with me.

Now I’m going to make another change.

Hi, Mr. Clone.

clone. Can you read this? So I’m going to make a change that I want the clone person to see.

Git status, git add, the readme. You could also do git commit dash a, but I kind of don’t like

to because I’d like to remind myself that the stage is a good idea. Git commit new readme

okay so I’m not I don’t have a remote I am the master so there’s nowhere to push

but now in the clone I can say git status it doesn’t yet know that the that the

remote has changes I could do git pull to actually pull all the changes or I

can do git fetch fetch will sort of talk to the remote and pull the changes into

this repository’s local copy of the remote.

So if we do git branch all, you’ll notice that we have a master branch here.

So the master branch is my master branch.

And all these other branches here are local copies of the remotes branch.

So we’re just making lots and lots of copies.

That’s kind of how git works.

But now that we did a fetch, that talked to the remote, it grabbed changes.

Now Git understands that we’re actually behind the remote by one commit.

And it’s telling us, well, you need to use Git pull to pull all the changes.

Usually you kind of don’t need to do Git fetch.

If you have a remote, you just say Git pull.

You only do Git fetch if you want to kind of see what’s going on with the remote first before you

actually try to pull all the changes into your branch.

It’s a more complicated situation.

So if I say Git pull, now inside of my Git log, I have that last change.

that last change that the master gave us.

So this is like a very, very basic workflow for Git

in terms of making changes to your program,

committing the changes, checking out the log,

checking out what was changed,

pushing to a remote and so forth.

The only difference, by the way,

between using a remote that’s a file system

and using a remote that’s GitHub

is just what URL you put in clone.

in clone like if i put if i said git clone i put a file path here originally but if i just

put a clone url that github gave me or your friend’s server gave you right there then it

would work basically the same way it’s pretty sweet um let’s see so those are the basics of git

always make sure that you push to the remote so that the server has your changes and if you’re

using github or another website uh it’s it’s usually a really good idea to push and then go

to the website to double check that your changes actually made it.

So we talked about tags and branches.

This video is not going to be for advanced branching strategies,

but there are lots of cool resources you can check out.

Actually, you know what? I’m going to pull one up. Let’s see.

I’m going to edit this out if it ends up being like a really bad search result.

Get branching strategy.

big project with a big team let’s see there’s one that I used to love where the heck is it

I think this month no that’s not the link I remember I should have bookmarked it but there

are lots of different strategies for how and why you would want to use um branches let’s see one

of these has a good diagram this is it this is not the same web page but I think this website

diagram that I remember.

So we’ve been on the master branch.

That’s like the right side here.

You know, this little, these little blue dots.

Imagine that every single time you want to create a new feature,

you just create a branch and you name it after the feature that you’re creating.

I think I mentioned that before that allows you to sort of keep working on the

master branch independently of the feature that you’re working on.

And then later when you’re sure you want to merge the feature into the master

branch, then you just use a get command to make the two branches merge.

command to make the two branches merge.

Or if the feature turns out to be a bad idea, you can just delete the branch.

Usually, at minimum, most people will do something like this.

They’ll have a development branch.

So here you can see the yellow dots.

That’s development.

And what they’ll do is they’ll make all of their commits to the development branch.

And then only whenever the program is in a really good state, like it’s sort of presentable,

you can actually release it.

let your friend run the code or whatever, then you’ll merge the dev branch into the master branch

without deleting the dev branch. So you’ll merge the dev into master every time the code is in a

really good state. And then you’ll come back on to dev to continue developing. I think most people

call it develop. Actually, I call it dev for mine. And that way, the master branch usually only ever

is in a state that is good that people could clone from and just compile the program or use the

or use the program or whatever.

And that is in addition to adding tags

whenever you think the master branch is in a state

that you think is like a significant release.

So like version 1.0 or 1.2 or whatever.

So branches for development

where you’re always there most of the time.

Branches for feature when you’re kind of experimenting

and trying to figure out

if you’re going to be able to add something.

Branches for, there’s a branch for the master

where it’s like this is the state

that the public should see,

the state that actually works.

actually works. And then, you know, you might do a temporary branch for a hot fix.

And sometimes people will do a new branch for a future release. Like if you’re going to release

version 2.0, you might make a new branch and call it version 2.0 and then just work on that and

kind of like merge changes from dev in that and just make sure that it’s all good and it’s great.

And as soon as you think that the feature branch is perfect for your release, sorry, not

Sorry, not feature branch.

Release branch is great for your release.

Then all at once, you’ll merge that whole thing into master.

You don’t have to do it that way.

It doesn’t have to be that complicated,

but sometimes it can be that complicated.

For me personally, I usually just do a development branch

and a master branch.

And then sometimes when I’m taking a risk,

I’ll make a feature branch for the new thing that I’m trying.

So I just kind of wanted to show you that for branching.

for branching and

we talked about pulling and pushing and cloning

yeah so just uh i guess one more warning to make sure that you don’t

end up with merge conflicts when you’re collaborating with other people

or even actually this happens to people who work by themselves and they just

switch computers a lot make sure that when you first sit down

and you’re about to start coding you always pull

team of people communicate with them and tell them you’re about to pull tell them you’re about

to start working on something tell them tell them what you’re about to start working on unless you

have like a manager who’s telling you exactly what to work on then it’s their problem um

and then do your get pull and then work and then every time you make significant progress

do a commit and then tell everybody i’m about to push and then push and then make sure that you

So if you go on your lunch break, make sure you push before you go on your lunch break.

And when you come back from your lunch break, make sure you pull right away.

Because if you don’t pull and push enough, you’re either going to get merge conflicts

on your end or you’re going to cause other people to get merge conflicts.

And sometimes it takes a lot of time to resolve the merge conflicts.

So you really don’t want to deal with that.

And then a beginner’s tip, or I guess like maybe like an easy tip.

I do this actually sometimes.

up totally forgetting to push and pull and you do a lot of code and you kind of like wreck everything

and you don’t want to deal with a gigantic merge conflict resolution type of situation sometimes

it’s easier to just copy paste your folder somewhere else rename it remember a git repository

locally it’s just a folder so you can copy paste it or rename it or whatever you want to do

you just kind of copy paste it somewhere and then perform a fresh clone from the remote

then there’s not going to be a merge conflict because the fresh clone is going to be directly

from the remote which is not conflicted on its own then you’ll have your fresh clone and then

you’ll have your little backup copy of what you just screwed up then you can manually inspect the

difference between the fresh clone and then the thing that you just screwed up or you can just

start copy pasting some of your changes and then do like a commit and then do push and then it

Git Basics tutorial. I hope you learned a little bit of stuff and had a little bit of fun.

I will see you in the next video.

Hey everybody. Thanks for watching this video again from the bottom of my heart. I really

appreciate it. I do hope you did learn something and have some fun. If you could do me a please,

a small little favor, could you please subscribe and follow this channel or these videos or

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

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

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

so please do do me a kindness and

And subscribe you know sometimes

I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed it just wakes me up

And I get filled with joy. That’s exactly what happens every single time

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

me if you want to just wake me up in the middle of the night just subscribe and then i’ll just

wake up i promise that’s what will happen also uh if you look at the middle of the screen right now

you should see a qr code which you can scan in order to go to the website which i think is also

named somewhere at the bottom of this video and it’ll take you to my main website where you can

just kind of like see all the videos i published and the services and tutorials and things that i

have a suggestion for uh uh clarifications or errata or just future videos that you want to

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

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

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

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

fade into the darkness which is coming for us all.

Thank you.

The post Git Basics Tutorial: Learn Version Control, Commits & Branches for Beginners appeared first on NeuralLantern.com.

Want to master decimal-to-hexadecimal conversion? Join me in this fun, beginner-friendly tutorial where we break it down with clear examples?like turning 223 into 0xDF! From number systems to handy calculator tricks, I?ll guide you step-by-step, no stress. Bonus: my dog makes a cameo! Perfect for coding newbies or anyone curious about hex. Subscribe for more easy tech tutorials, and let me know what you want to learn next! #DecimalToHex #CodingBasics #LearnToCode

Introduction 00:00:00
Number Systems Overview 00:00:12
Decimal vs. Hexadecimal 00:00:39
Hexadecimal Digits Explained 00:01:06
Conversion Process Introduction 00:01:40
First Conversion Example Start 00:02:10
Handling Remainders 00:02:38
Dog Interruption 00:03:16
Continuing First Conversion 00:03:43
Finalizing First Conversion 00:06:04
Reversing Digits Order 00:06:24
Mapping Numbers to Hex Letters 00:07:34
Verifying First Conversion 00:08:48
Hexadecimal Prefix Importance 00:10:57
Second Conversion Example (223) 00:11:34
Third Conversion Example (2816) 00:13:32
Hex and Binary Relationship 00:14:56
Padding Zeros in Hex 00:16:07
Video Conclusion 00:16:58

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hello there.

Let’s talk about converting decimal to hexadecimal.

Hopefully you’ve watched my other videos by now, but basically we have different number

systems, number bases that we can use.

We have decimal, which is a base 10.

which is base 10 or sorry base 16.

We can basically convert back and forth between all of these systems.

We can represent the exact same number just in different ways.

Just as a quick refresher.

Decimal, we can have characters that are 0 through 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

That’s 10 total characters.

That’s why it’s base 10.

In binary, we have, you know, just characters 0 and 1.

characters 0 and 1 and in hexadecimal it’s meant to compact the representation a little bit it has

more characters or more possible characters per digit than decimal so the number is going to be

a little bit shorter usually unless it’s like very very small than decimal and it’ll be a lot shorter

than the same number in binary so in hexadecimal we start off with 0 1 2 3 4 5 6 7 8 9

three, four, five, six, seven, eight, nine.

And then to get the remaining digits, we just go A, B, C, D, E, F.

So we have this many characters.

It’s 16 total characters.

We can represent a number between 0 and 15.

So that’s a difference between, you know, hexadecimal and decimal.

Now let’s learn how to actually convert.

So I’m going to start off with a number.

I’m just going to type like a random number here.

Hopefully this doesn’t go on for too long, the conversion.

decimal number is just that. How do we convert? If you watch my other videos, it’s basically the

same thing as converting from decimal to binary, except instead of dividing by two, because binary

is base two, we’ll divide by 16 because hex is base 16. So I’m going to start off by saying,

let’s take the original number and we’ll divide it by not two, 16. What does that equal? There’s

no way I’m doing this in my head. So I’m just going to use a calculator for every single step,

going to use a calculator for every single step not even going to try I’m

going to say this number divided by 16 is 5 1 1 7 5 7 with some sort of a

remainder so I’m gonna go 5 1 1 7 5 7 remainder something so in most

calculators you can just punch up the modulo operator which is like the

percent symbol before I do that I just want to point out 0.75 is 3 4ths of

of whatever it is that is one you know that one character can represent we know

we can represent 16 different values what’s 16 divided by 4 that’s 4 so three

of those should be like 12 I hope unless I’m saying something totally wrong so

I’m gonna do modulo so that’s 12 okay remainder 12 my dog is growling at me

He likes to lie about peeing.

He doesn’t actually pee.

He already did a huge pee and then three times after that at 20 minute intervals, he went

out there and lifted his leg and just like three squirts came out and he expected a giant

treat for it.

I’m not doing it.

You’re not getting that treat.

I expect a big pee pee if you want a treat.

You dog?

Dang little dog.

Okay.

So, here we are still dividing.

here we are still dividing. I got the remainder. So then we just need to take, you know, the

quotient result, you know, what is the result of actually dividing, just carry it over to

the next line. I’m going to do some spaces to make it look all even and continue to divide.

So divided by 16 equals something. Don’t forget that if you have the modulo operator over there,

you got to take it out, go back to division. It’s going to be 31984 remainder something.

what’s the remainder i’m just going to get the modulo i don’t want i don’t want to recall what

0.8125 is i’m sure some of you out there can already do that but it is 13 remainder 13.

um so i’m gonna go 319 divided by 16 31984 divided by 16 so it’s going to be 1 999 okay so carry that

over real fast though divided by 16 equals 1 9 9 remainder something there’s no decimal point at the

There’s no decimal point at the end of that so I can just assume the remainder is going to be zero.

If you want to double check to be sure, which is a good idea, use the modulo operator.

If your calculator doesn’t have modulo, find another calculator or jump into Python or something.

So I’m going to carry over 199 to the next line there.

1, 2, 4, remainder, whatever modulo says, 15.

That’s pretty cool.

All right, then I’m gonna carry it over,

just 1, 2, 4, divided by 16 again.

If you were hoping I’d be able to do it in my head by now,

you were wrong.

1, 2, 4, divided by 16, it’s gonna be 7.75,

so just like seven, remainder something.

What did I say last time for the 3 4ths?

Was that 12?

whoops, I can’t remember anymore.

12, yeah, okay, so remainder 12.

And then we’ll carry it over and we’ll say 7 divided by 16.

So we know that, you know, 16 doesn’t really fit into 7 at all.

So it’s going to be 0 remainder, whatever the number is.

Let’s punch it here just to double check.

We’ll say 7 divided by 16.

You can see that it’s 0.

And then the remainder is going to be 7, just, you know, what the original number was.

number was. So now at this point when the actual you know carry down quotient is

going to be zero then we just have zero divided by 16 equals just zero remainder

zero and it’ll just continue like this forever and ever and ever and ever and

ever. So this is how you know you’re done. Another thing that I mentioned in

other videos is how do we actually know where the zeros belong? I mean if you

read this intuitively from the top to the bottom you might think that you know

you know the top number is going to be like the first digit but it’s actually

backwards it goes from the bottom up the reason you can know that is again based

on my other videos if we just type a random decimal number here if I add

zeros to the right side I’m actually changing the value of the number I’m

making it bigger but if I add zeros to the left side I’m not changing the value

at all so that means those zeros here which could go on for infinity based on

how much tenacity you have they should be on the left side because you don’t

side because you don’t want any amount of these zeros to change the value of your number because

they you know it’s an arbitrary number of zeros based on how how fast you get tired of doing zeros

so that means if i go from top to bottom i have to reverse it if i go from bottom to top it’s

already going to be in the right order or sorry if i if i correlate or if i map bottom to top to mean

left to right then it’s fine already if i map top to bottom for left to right then i’ll have to

For left to right, then I’ll have to reverse it when I’m done.

So I’ll do it both ways just to show you.

But there’s one more step we need to do because in hexadecimal,

we have more characters than decimal.

We have to translate what does this 12 and 13 and these other numbers mean.

Luckily, we had some of them in there.

It could have been too easy.

So remember in hex, we have 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

And then we have A, B, C, D, E, right?

So we know that the value of 0 is 0 and 1 is 1 and 2 and 2 and so forth, right?

Like 9 is 9.

But what’s the value of A?

For each increasing digit, the value just goes up by 1.

So that means that A is worth 10.

I’m going to write this vertically just so that you understand that this means the strength

of the A is 10.

And then the strength of the B is going to be 11 because it just increases by 1.

The strength of the C is 12.

The strength of the D is 13.

Oops, I forgot the F.

Oops, I forgot the F. Hit F in the chat if you forgot the F too.

So the strength of the E is 14. The strength of the F is 15.

And then we’re done. And remember, there’s 16 digits total.

So the highest value is 15 because it includes the zero.

So, you know, 16 total possible values you could represent, but the highest value, 15.

So that means every time we see a 12 here,

say that that’s really a C and every time we see actually let me let me put

the other C in there real fast every time we see a 13 that means it’s a D

every time we see a zero zero through nine it just it means the original

number oh wow we only had two digits that are gonna mean the original number

so mark my words you know the 15 is gonna be an F every time you see zero

one two three four five six seven eight nine it maps to the same number so seven

maps to seven it’s totally fine the only time it maps to a letter is of course when you exceed nine

so 10 and above are going to map to letters so now i have these mappings i just need to sort of scan

uh my my work to come up with the correct hexadecimal number so i’ll start from top to

bottom because it’s a little bit harder that way and it’ll be more brain practice i’m going to go

and then you know as many zeros as you decided to calculate and hopefully this

reminds you oh no I’m increasing the value by adding the zeros that means I

have to reverse everything so I’m gonna get rid of these zeros though and I’m

gonna reverse it 7cf0dc okay great now let’s double check because it’s always

a great idea to check your work in different ways with different methods to

decrease the possibility that you’re accidentally wrong so now I’m gonna go

So now I’m going to go from bottom to top and see if it’s the same thing.

7 C F 0 D C. Does it match? Yes.

So now I’m pretty confident that I have the right answer.

Let me punch this up in my personal calculator real fast.

I’m going to do just to double check the work before we cut the camera,

because if I’m wrong, I want to be able to correct myself right away.

Instead of coming back with another video later,

which sometimes I guess I’ll have to do.

f0 dc is the correct answer all right so we now have converted our first number from decimal to

hexadecimal nice and by the way if you didn’t already know this you’re supposed to put a

prefix in front of hexadecimal numbers not necessarily in every program that asks for

hex input some of them are not programmed that way but in general when you expect someone to

read your numbers if it’s hex you want to put ox in front of it because you don’t want them to

confuse, let’s say we have this number and this number and this number. All three of those could

be a different number depending on whether they’re binary or decimal or hex. But if you put the

symbols in front, this is binary, this is hex, then now the reader knows that these are three

different numbers and they can infer what the numbers mean. Okay, so let me, let’s just do like

another number. We’ll make it a little bit smaller so it’s easier. We’ll say decimal and we’ll go two,

and we’ll go 2 2 3.

So it’s faster.

So we start off with 2 2 3,

we divide it by 16,

and that’s going to be something.

So 2 2 3 divided by 16

is going to be 13 remainder something.

I’m going to do the modulo operator.

And by the way,

if you don’t have a modulo operator

and you can’t figure out a better way to do this,

a good trick is to just say,

let’s take 13,

because that was the answer, right?

13 point something.

We’ll take 13 and multiply that by 16 again,

that by 16 again so it goes higher then take the difference between that and the original number

so we can say 223 minus uh the number multiplied back up and it’ll tell us that our remainder is 15.

let’s see was that actually the remainder let me just double check here oh gosh what am i doing

223 modulo 16 15 yeah there it is if you’re lazy like me you could also do something like this i

and I don’t have a modulo.

I’ll do 13 times 16 and it’s 208.

And then I’ll just subtract the original number

and then we get negative 15,

but then I know it’s not negative, I know it’s 15.

So it’s just like, it makes you a little bit faster

in the calculator.

So this number I think was too small

because we just do 13 and then divide that by 16.

Obviously the answer is gonna be zero remainder 13.

And we just have a two digit hexadecimal number.

digit hexadecimal number. Let’s do that real fast. What is 15 going to be? It’s A and no, no,

no, not A. Sorry. That’s F. Subtract two from that. D E F. So it’s going to be D, I think.

So then if we go from bottom to top, it’s going to be O X D F. Let me double check that I’m

telling you the right thing. 223 D F. Okay. So we got it right. Let’s do something just like a

not as difficult as the first one so I’ll try four digits maybe two two two two

how about that four digital four digital digits how about that we’ll do

two eight one six divided by 13 equals something two eight one six divided by

16 that’s 176 remainder something there’s no decimal point so I can just

16 is 176 divided by 16 is 11.

Another zero remainder.

Getting kind of boring though, isn’t it?

Remainder zero.

And then we’ll do 11 divided by 16.

That’s going to be zero remainder 11.

That’s too easy.

Okay.

So what is zero?

Zero is zero.

You’re welcome.

And then what is zero?

It’s also zero.

0, it’s also 0 and then what is 11? That’s B.

So we should have a number now of 0xB00 if we’re going from the bottom to the top.

If you go from the top to the bottom of course it’ll be 00B and then you reverse it B00

but I just wanted to skip that step for now.

Let me punch this up into my personal calculator to make sure I don’t need to make a correction.

B00, there we go.

Also, you know, here’s another thing to keep in mind.

it’s to read you know sets of bytes which typically go in patterns of one byte or two

bytes or four bytes or eight bytes or whatever so the cool thing about hex is one character

can represent a number from zero uh to 15 or 16 combinations and if you think about that in binary

that’s four bits right it’s like one two three four one two four eight multiply eight by two

16 subtract 1 is 15.

So you can go from 0 to 15.

So that means for every character in hex,

you get four characters of binary.

So it’s like a huge savings, right?

But the point is, if you wanted to represent one byte,

that’s not going to be four bits.

That’s going to be, you know,

four bits followed by four bits for a total of eight bits.

Even if there are zeros in the beginning,

in binary, if you’re representing a byte,

But in binary, if you’re representing a byte, you typically want to pad the zeros to the

left so that it looks like it’s aligned to nice blocks of eight or 16 or 32 or 64 in

terms of bits.

So we should do the same thing with hex.

We should always have two hex digits together.

We should try not to have like an odd number of hex digits.

And if you want to get more strict than that and say like, oh, only, you know, two or four

eight you can do that but i just will say pad it with a zero to the left remember when you pad a

number with zeros to the left it doesn’t change the value like if i just put a bunch of zeros in

front of this decimal number it wouldn’t change the value so we can do that with hex and it looks

nicer and neater and people can quickly see okay so there’s like a byte right there it’s ob

they can imagine oh that byte is probably um 11. so there’s like a like an 11 byte it’s like got

a sequence of zeros and ones and then there’s another byte right after it which is smaller

which is smaller, which just has zeros.

So it just helps the reader visualize what’s going on.

Okay, I’m going to cut the video here.

I hope you enjoyed this video.

I hope you learned a little bit of stuff and had a little bit of fun.

I’ll see you in the next video.

Hey, everybody.

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,

please a small little favor could you please subscribe and follow this channel

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

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

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

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

videos in general so please do do me a kindness and and subscribe you know

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

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

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 I’m like this

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

for watching this video and enjoy the cool music as as I fade into the darkness which is coming for

us all

Thank you.

The post How to Convert Decimal to Hexadecimal: Fun & Easy Guide for Beginners appeared first on NeuralLantern.com.