In this video we break down the four main types of graphs used in computer science: undirected unweighted, undirected weighted, directed unweighted, and directed weighted.

We start with the basic idea of graphs – collections of nodes (vertices) and edges – and then explore each type with clear examples. Learn how these graphs represent real-world relationships like computer networks, airport routes, road maps, and game maps.

Perfect for anyone learning data structures, algorithms, or preparing for coding interviews.

00:00 Introduction to Graphs
00:19 Basic Graph Definition
00:48 Nodes and Vertices
01:01 Empty Graph Example
01:17 Graph Implementation Concepts
02:02 Node Data and Templates
03:22 Adding Nodes
04:00 Adding Edges
04:44 What Graphs Represent
05:36 Graph Use Cases
06:56 Real-World Examples
08:35 Four Types of Graphs
08:52 Undirected Unweighted Graph
10:40 Unweighted as Unit Weights
11:40 Undirected Weighted Graph
13:32 Weighted Graph Benefits
15:52 Directed Weighted Graph
19:50 Directed Unweighted Graph
20:32 Summary of Four Graph Types
21:19 Closing and Future Videos

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hello there! Let’s talk about four different types of graphs that you can use and how they relate to computer science.

Okay, so you can see like I’ve got like a blank little graph paper up here.

I’m going to talk about graphs and just the very basic idea of graphs in general

and then show you the four different types of graphs that we have.

about how to implement graphs inside the machine, time complexities, maybe graph algorithms,

and a whole bunch of stuff, terminology, everything. Okay, so the first thing is, I guess I’m going to

assume probably most of you have sort of seen a graph before and you kind of understand a little

bit about it already, but I’ll say that a graph is basically a collection of nodes, also known as

vertices or vertexes, and edges, which are the lines that connect nodes to each other. This screen

See, this is a valid graph.

I’m not talking about the graphing paper.

It’s just an empty graph.

There’s nothing there.

So it’s still valid.

It’s just blank.

Okay, so then what I want to do is start drawing some nodes.

What are the nodes again?

Those are just vertices.

Those are just like little data structure objects you can imagine in the code.

I don’t want to get too far ahead of myself, but imagine that you have a class called graph.

This is just one way to imagine.

We have a class called graph and then a nested class inside of a graph called a node or a vertex

If you want to be more fancy

So the vertex class itself by the way

This is not always going to be the way that you actually do this in your code the other representations that we’ll talk about sooner a little bit easier, but

The vertex class itself needs to basically hold some data

Depending on your implementation it might know about who it’s connected to maybe the graph knows that instead

instead. In my implementations, the graph is going to know everything, but the vertex or the node

itself needs to hold one piece of data. That’s kind of the whole point. So I’m going to say that

the data type that these nodes hold are just integers. So I’m just going to put like a six in

here just to indicate we have one node and the templated data type that it holds is an integer.

And the specific integer for this specific node is just the number six. You can have any template

any template type if you really want to you can people put floats in there you could put a custom

custom class in there whatever you want but i just want to show you that we have a class called

vertex or node and inside of it’s got a template type maybe just to make this a little bit more

clear i’ll say you can imagine inside the vertex class uh there is a template type and we’ll call

it uh i don’t know node node value type or something and we’ll call it data and then up

I’m doing C++ up here.

We have to kind of define the whole graph class as a template class.

Now, of course, you could define the vertex class as the template class,

but if you define the graph class as a template, then it all kind of falls through.

So I’m just going to say class node value type.

And so if you’ve written template classes before in C++,

now you know that the user can instance the graph and at the same time,

specify what is the data type of the stuff that the nodes hold.

the stuff that the nodes hold.

We do the same thing for edges too,

but notice how there are no nodes that are connected to each other.

So we have no edges in this graph.

This is still a valid graph,

but we could just sort of copy a node just for fun and say,

all right, we’ve got two nodes now, two vertices.

They could have the same value if you want.

Graphs are supposed to, you know, support duplicate values in the nodes,

but I’m just going to change the value here.

This is also a valid graph.

You don’t really need edges to have a valid graph.

edges to have a valid graph. This is just something called a something called a graph that is not

connected. We’ll talk about all that terminology and how to detect it in a future video. For now,

I’m just going to say we have like a little graph here, which is kind of boring, but I’m going to

add an edge. An edge is basically just, you know, a little mini data structure that connects two

nodes. Depending on the way you represent this in the machine, which we’ll talk about in future

well, a whole bunch of different ways.

You could imagine this as a full-fledged class,

although that’s not always going to be the way that we represent an actual edge.

So imagine that we have a nested class called edge.

And inside the edge class, we’ve got, you know, some stuff.

We could have a weight, which means the cost of traveling against the edge.

We could have many other properties.

For now, I’ll just try to keep it simple.

is pretty much a collection of vertices and edges and some sort of connection.

What is a graph really for?

Some people at first think that a graph is another way to represent a database.

I’m going to erase this thing over here.

Graphs, you could sort of use them as databases,

but they’re not very good as databases because

it would be really, really slow to search through the graph

to find some piece of data that you’re looking for.

It could be like a linear time database.

better would be to take this graph and add a bunch of rules as you probably have found

in my other videos by now and turn it into a binary search tree.

A binary search tree is lightning fast.

It runs in log time.

Hash tables are faster than binary search trees, but basically a graph is always going

to be way slower than a binary search tree unless the binary search tree is severely

imbalanced.

But that’s something for another video.

Anyway, so we have a graph and it’s not a good database.

What would a graph be good for?

would a graph be good for? Well, graphs are usually pretty good to help you represent

relationships between things. For example, the six and the one, imagine the six is something,

maybe it’s a computer, maybe it’s a city, maybe it’s, I don’t know, like a train station,

and the edges could represent connections. So I’m just going to start changing these values

have some nodes just kind of hanging out off to the side, not really connected to anything.

Maybe not great for your particular use case, but like it’s a valid graph. So I’m just going to,

I’m just going to connect this and try to make this into a better graph.

That’s a little bit more interesting. So we’ve got graphs that do a whole bunch of different

things. Let me change these values real fast. I’ll maybe turn that into a 13 and turn that

So imagine that we have like a little connection here, a little connection here, maybe another

connection here and another one there.

And you know, you are allowed to have connections that sort of look weird, like going from this

six all the way around to this 13.

That’s totally valid also.

So I’ve basically just drawn a random graph, random nodes and random edges.

Imagine that every single node here is a computer in a computer network and imagine every edge

every edge which connects the nodes is just some sort of a connection let’s say a network cable

or a wi-fi signal or something like that so if you imagine it that way then this graph could

represent a network topology a bunch of computers connected together if these were cities and this

is like actually maybe these are airports in cities you could imagine a graph could represent

the relationship between different airports in which planes will fly notice on this graph just

that the uh you know the uh the city number one uh there are no flights connecting it directly to

city 44 but you could probably imagine well if we take a flight to uh from city one to city 10 and

then from city 10 to 44 then we can get from one to 44 we just have to be clever about our connecting

flights um let’s see so we could do like road maps airport maps the worldwide web is basically a graph

at least from a certain perspective electrical circuits that are connected to each other

are connected to each other even game maps what if your character is allowed to stand here in

in space number three on some map and the character is only allowed to travel to space 13 or

space 6 but not directly to space 1 well it could be a map that helps you understand where your

character can go in a game okay so that’s like the basic idea of of what a graph is and uh how it

actual four types of graphs that I’m going to go over in more detail in future videos. Let’s see,

what time is it right now? We got like 10 minutes. Okay, so I can still kind of make this fast.

So the first type of graph that we’re looking at right now is actually something called an

undirected, unweighted graph. Why is it, let’s see, let me write this down first. It’s an undirected,

undirected, unweighted graph. So why is this undirected? Because the edges don’t have direction.

If I was standing in, you know, city six and I wanted to like drive or fly or whatever

from city six to city three, then I should be able to do it because this edge that connects

them doesn’t really say that I have to go in one direction or the other. I could also go to city

three and then just walk right back or fly right back to city six. There’s no direction. So there’s

no direction. So there’s an this that’s that’s why this is an undirected graph. This is an

unweighted graph because we haven’t specified a cost for traveling along an edge. For example,

if you know, if you’re at city three here, and you want to fly to city 13, how much jet fuel

does it cost? How much time does it cost? If three is a computer and 13 is a computer,

and the edges like a network cable, like how much money does it cost to transmit the data?

transmit the data or what is the lag in milliseconds.

You know, you can represent all sorts of things with these edges,

but there’s no value on these edges,

which means there are no weights to these edges.

So that’s why this is an undirected and also unweighted graph.

Uh, the first upgrade that I want to do is just kind of show you what you can

sort of assume about an unweighted graph. This is not always true.

It just depends on who you talk to and what your application implementations are.

So imagine the node that goes from six, sorry, the edge that goes from six to one.

If it’s an unweighted graph, you could just probably imagine that every weight is just a one.

The point being that it always costs the same amount to travel along every edge,

because in an unweighted graph, we don’t differentiate between the different edges

in terms of their costs.

We could just put a bunch of ones on all these edges.

And it would still, you know, basically be considered an unweighted graph.

It depends on who you talk to.

maybe all the weights are zero, maybe all the weights are 10 or whatever.

But, you know, usually I put a one there because I’d like to imagine the cost could just be the number of hops.

So, for example, if I wanted to go from city six to city 10,

I could probably, you know, start at city six and then go to city one and then hop to city 10.

How many actual hops did I do? I did two.

I could also come up with that number by just looking at the sum of all the weights of all the edges.

all the edges. So notice how when I go from six to one, that costs me one weight or one hop. And

then when I go from one to 10, that’s another one. So if you put ones on all the edges in an

unweighted graph, then you’re kind of saying the total cost of some path is really just the number

of hops. So it’s up to you. Anyway, that’s unweighted and undirected. Let’s upgrade this

see we have an undirected and unweighted and i’m just going to duplicate this real fast and change

this to a weighted graph so undirected but also weighted and the thing is as soon as you start

putting numbers on a graph on the edges of a graph well then it’s considered weighted so even even a

graph that has all ones on all the edges you could also call that weighted but now you have the

freedom since it is considered a weighted graph to just assign different values to all the edges

to all the edges. Again, these edges are a class sometimes, or you can think of them that way

inside the graph. And the edge weights themselves are definitely considered a T type, a templated

type, which means, you know, right now I’m clearly typing integers, but you could type some other

data type. You could type floats. You could type some weird data type, like a string.

Whether or not that’s going to be useful depends on your program, you know, what you’re trying to

you know, what you’re trying to do with the graph. But let’s see, I think I’ve added custom numbers

to every single edge. So now this is definitely an undirected, but weighted graph. That’s the

second type of graph that we’re talking about. Okay, what’s what’s cool about a weighted graph?

Well, imagine again, that this is an airport map, where we’re representing relationships between,

you know, cities, like where can we fly and stuff. We’re basically saying at this point,

it’s going to cost you 44 of something.

Maybe this is a graph representing jet fuel or time or frequent flyer points or something like that.

If you consider your edges to be custom classes,

you could even put a whole bunch of different types of values in your graph at the same time

to make it a little bit more flexible.

But for now, we’ll just say there’s one templated type,

which means if we go back up to this code real fast, where was that code at?

Where was that code at?

And we had, you know, our rough idea of, you know, what the, what the graph holds, you

know, it holds like vertices and edges.

We could upgrade this just a little bit to say that there is a, an edge value type.

So I’m going to say class edge value, edge weight type, something like that.

for the edge so that I can save characters. And then here, I’ll change this to a type for the

node. This is why we call it T type. There’s like, we put the keyword template here in C++.

And then sometimes people just use T’s here for these tokens. So I’m just going to say

the type of data that a node can hold is going to be the T node. And then the type of data that

the edge could hold would be the T edge. We’ll call that data. Or we could call that weight,

because usually that data comes into play when you’re traveling along an edge, right? So there’s

traveling along an edge, right? So there’s like two different types here. Anyway, so we got an

undirected and unweighted graph. If we traveled from city six to city one, that costs us 44. But

if you look at the graph a little bit more closely, we could take the longer way around. We could say

go from six to three, and then go from three to 13. And then actually, let me change the color

to orange so that you can see there’s different paths, six to three, and then three to 13,

and then 13 to one, even though we took more hops,

and that might have been considered more expensive

in an unweighted graph,

you can see that the cost of the first path

from six to one, that’s 44.

And the cost of the second path is seven plus three,

that’s 10, and then plus nine, so that’s 19.

So if we take the long way,

it actually costs us less

of whatever we’ve determined this unit is.

You know, less jet fuel, less time, less whatever.

less whatever these graphs in the machine are not necessarily going to be to scale because the

machine in your computer your computer doesn’t really keep track of like the physical positioning

of all these nodes and edges it just can keeps track of the relationship between the nodes and

the edges and the weights and all that stuff so two different paths that we could take to get

from six to one one of the paths is less expensive um or less time costly or just whatever and a graph

data structure can kind of help us figure that out if we’re using an algorithm that understands

weights okay so undirected and unweighted let’s add direction so um i’m going to erase this stuff

right here real quick and in an undirected graph remember you can just kind of go in either

direction along any edge but in a directed graph every single edge needs to have a direction so as

I change one of the edges to have direction, then I must change all of the edges to have direction

as well. So I’m just saying, okay, as soon as I did that, now this is an invalid graph

because some of the edges don’t have direction. So now I need to fix everything. So I just,

I’m going to arbitrarily and randomly choose a direction for every single edge like this.

And then as soon as I’m done, I’m going to deal, I guess, with that giant edge

that giant edge. So I’m going to go like that. So let’s see, all the edges seem to have direction.

Now I’m just going to hand draw an arrow on one side of this giant edge. Okay. So this is directed

and also weighted. What can we do with the directed graph? Well, it just basically tells

you which direction you’re allowed to travel in. What if you have an airport where city six can

only fly to city one, but city one, for some reason, never flies to city six. You got to take

take like the long way you got to go from city one to 13 to three to six that’s something that

a graph could help you represent what if your character in your game can only go in one direction

but not the other direction okay no problem i mean that’s pretty much it you’re only allowed

to travel in the same direction as the edge points but now we have a graph that is a lot less

flexible because for example before we used to be able to go from city uh 10 to city 44 and then

then come back again later if we wanted in the opposite direction. We can no longer do that

because this edge only goes to 10. It doesn’t even go to 44. We can’t even ever actually get to 44.

How do you sort of solve that? Well, just add another edge in the opposite direction.

In graphs, you are allowed to do something called a parallel edge,

which just basically means, you know, two edges between the same pair of nodes that just point

in the same direction. You’re also allowed to do, you know, opposite facing edges. So

edges so i just added a second edge there going from 10 to 44 and now if i was you know hanging

out in city 10 i could just go back and forth between city 10 and 44 as much as i wanted to

oh i forgot to add an edge weight for that new edge which means i wrote down an invalid graph

so i’m just going to say two so uh maybe the wind is blowing in in your favor when you’re going from

city 10 to city 44 maybe it’s blowing against you if you’re talking about city 44 to city 10 you

you know whatever but you just have to have edge uh edge weight on every single edge

okay so uh that’s directed and also weighted um and you can probably imagine previously when we

had an undirected um graph when there was just like you know one edge going between uh two nodes

and there was no direction on it like you know 44 to 10 if we just had like one edge with no

have two edges each going in the opposite direction so we have directed and weighted i think the last

thing that we didn’t do was directed and unweighted right so we have let me just double check real

fast here we have undirected and unweighted and then we had undirected and weighted and then

directed and weighted okay so now let’s do um i’m getting lost already oh my gosh i can’t believe i

I saw undirected and unweighted so we did undirected twice already undirected so we’re

going to do directed and unweighted next okay so the next graph a little bit less useful than

what we’re looking at this this type of graph is a little bit more useful we’re going to do

directed and unweighted oh my god okay directed and unweighted so directed and unweighted you

Directed and unweighted, you can imagine, just means we get rid of all these weights.

And then we keep the direction on all the edges.

So this means we can keep track of where we’re allowed to go, if we’re pathfinding or just whatever.

But we don’t really know what it costs to travel between the different graphs.

So that’s directed and unweighted.

Let’s see here.

I’m going to just duplicate this or just make a new blank slide.

Okay, undirected, oh gosh, I’ve got pink letters.

Let’s see, undirected plus unweighted.

And we’ve got undirected plus weighted.

And then we’ve got directed plus unweighted.

I don’t think I’m writing these down in the same order,

but that’s okay.

And then we’ve got directed plus weighted.

So basically, you know, four types of graphs

that we can talk about.

In future videos, we’re going to go over graphs

in more detail.

We’ll talk about graph terminology,

maybe some pathfinding algorithms.

And yeah, so this is just a basic intro.

How much time do we spend already?

Oh God, we spent so much time.

Spent like 22 minutes.

Dang, man, even the smallest thing takes time.

So I’ll see you in a future video

when we talk more and more and more about graphs

and other data structures concepts.

Thanks for watching this video.

I hope you learned a little bit of stuff

I hope you learned a little bit of stuff and had a little bit of fun.

I’m out of here.

Go.

Hey, everybody.

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

I really appreciate it.

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

If you could do me a please, a small little favor,

could you please subscribe and follow this channel or these videos

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

it would really mean the world to me.

And it’ll help make more videos and grow this community.

So we’ll be able to do more videos, longer videos, better videos,

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

So please do me a kindness and subscribe.

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

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

Also, if you look at the middle of the screen right now

You should see a QR code which you can scan in order to go to the website

which I think is also named somewhere at the bottom of this video and

It’ll take you to my main website where you can just kind of like see all the videos

I published and the services and tutorials and things that I offer and all that good stuff and

and 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

it would really it really mean the world to me I would really appreciate it so

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

Thank you.

I’m going to go ahead and get started.

Thank you.

Hello there.

Let’s talk about the four types of…

Hello there.

The post 4 Graph Types: Undirected vs Directed, Weighted vs Unweighted appeared first on NeuralLantern.com.

Get a clear, hands-on look at Linux’s standard input (STDIN), output (STDOUT), and error (STDERR) pipes! In this video, we explore how programs communicate using these essential streams, with practical examples in Yasm Assembly (no assembly knowledge needed!). Learn to redirect outputs, handle errors, and read inputs like a pro. Whether you’re a beginner or seasoned coder, this fun demo breaks down the basics of Linux pipes. Subscribe for more coding insights and check out the full tutorial on our site!

Introduction to STDIN, STDOUT, STDERR 00:00:00
Overview of Pipes in Linux 00:00:07
Explanation of File Descriptors 00:01:12
Demonstrating Echo Command 00:01:24
Redirecting Standard Output 00:02:02
C++ Example with cout and cerr 00:02:48
Purpose of Separate Error Pipe 00:03:28
Assembly Program Introduction 00:04:55
Creating Data Section in Yasm 00:05:22
Writing Helper Functions 00:07:37
Printing to Standard Output and Error 00:11:29
Testing Output Redirection 00:12:43
Standard Input Explanation 00:14:54
Creating Stack Buffer for Input 00:16:03
Reading from Standard Input 00:17:28
Piping Input to Program 00:20:54
Handling Null Terminators 00:22:02
Conclusion and Call to Subscribe 00:23:53

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hey everybody.

In this video I’m going to talk to you a little bit about standard input, standard output,

and standard error.

Three pipes that every program has in Linux that allow it to just communicate in a very

standard way.

I’m going to show you some example code written in Yasm Assembly, but assembly knowledge is

not necessarily required for this video.

You can just sort of follow along.

Anyway, what is standard input, standard output, and standard error?

Well for starters, every program that gets launched, under the hood, the operating system

will typically attach three pipes to it.

Basically one for standard input, one for standard output, and one for standard error.

the program pretty easily. So let’s see. Oh, I know what to do. There’s an echo command, right?

So here’s the program called echo. When the program launches, it’s going to have three pipes

attached to it, just like I told you before. These pipes also behave as file descriptors,

as if you had opened a file, but their file descriptor numbers are always zero and one and two.

Zero for standard input, one for standard output, and two for standard error. So if I launch the

program it’s going to get those three pipes those three file descriptors and

right away the standard output is going to get attached to the program running

our terminal here well not necessarily the actual terminal but bash under the

hood which is the program that we’re using to interact with the operating

system so basically the program launches and based on this incoming argument that

I give it hello then it’s going to print the string hello right but what it’s

its standard output pipe its standard output file descriptor I can test this

for sure by just sort of doing the command again and then muting its

standard output pipe with this little shell trick I’ll do a arrow or a greater

than angle bracket and I’ll just send the first pipe I’ll do one I’ll send it

to dev null and on Linux dev null is just if you send anything there it just

it’s just totally ignored so if i send uh the pipe labeled number one to just nowhere then notice how

it doesn’t show on the terminal for me right it’s pretty cool let’s go a little bit deeper into this

i just want you to see real fast before i write an example program in assembly what you would

probably end up doing in c plus plus so we usually do something like iostream in germane you know

We’ll say using std cout std c error std and l and so forth.

And then if you actually want to print a message to the user, we’ll say cout this message prints

to std out because that’s what cout does by default.

And then if we do c error, a lot of people haven’t actually seen this and I personally

always forget that it’s even there if you print to see error it prints a message to standard error

why would you want two different pipes that printed messages and one is called output and

one is called error well like i’ve said before in other videos it’s really convenient to be able to

have programs automate other programs for example if you have a program that is launching you know

a second program maybe the second program fails in some way or wants to complain to you in some way

or wants to complain to you in some way, it would usually, if it’s smart,

print the complaint to standard error.

It may not actually use C error because maybe it’s not a C++ program,

but it would print to pipe number two, file descriptor number two, standard error.

And then that way, the program that’s launching it can just sort of ignore messages

that happen on standard output because we can assume all of those messages

are just normal info messages that a human might want to see.

Or maybe you want to record to a log or something somewhere

log or something somewhere and just kind of save it away.

But the error messages are a little bit more important than the regular,

you know, normal messages.

So if you’re automating another program,

then your program probably wants to take standard output and either ignore it or

just kind of send it to a different file.

And then it wants to take standard error and pay more attention to it.

Write it to a log file, save it, maybe check that it’s actually blank.

And if it’s not empty, then maybe alarm bells go off.

Something went wrong.

We have to alert someone or, you know, make a database entry, send an email, whatever.

And yeah, just pipe one and pipe two is how you accomplish that.

So this is what’s happening in C++ when you do that sort of thing.

Okay, so now I would like to write a sample program that just kind of demonstrates this

real fast.

So please bear with me.

I’m going to go really fast for the assembly portion because this is not an assembly video.

to learn more about how to write assembly in the first place than see my other videos.

For now, I’m just going to create a little blank file here.

Let’s see where the heck is my window.

I’m on a multi-window system here.

Okay, so I’m just going to paste a little data section.

This is Yasm assembly.

A little data section.

I’m just going to fill it up with strings.

I’m going to make a string for the introduction.

Hello, the module has started.

A string announcing everything that we’re going to do.

We’re going to begin printing to standard output and standard error,

and then some messages that will go to each.

And then some messages that will go to each and then a standard input string, which we’ll

talk about after the standard output and standard error.

So just a bunch of strings.

I’m going to make a buffer size.

I’m going to make system call codes for reading, writing and exiting.

If you want to know more about system call codes, see my other videos and some file descriptors.

This is exactly what I just talked about.

The file descriptor for standard input is zero for standard output is one for standard

for standard error is two.

And then I’m going to do a system exit code of zero,

which actually doesn’t matter that much,

but I’m going to do it.

So now I’m going to make a, let’s see,

a global,

hmm, make a global.

Oh, did I already make the text section?

Here we go.

So there’s the text section.

So the data section is over now.

So data section is over now.

I’m going to make the tech section.

I’m going to make a global entry point called start.

Again, if you want to know more about assembly programming in general,

see my other videos.

But so this is the entry point of our program.

At the very end, we should probably just program that it exits with success

and test it out real fast.

So basically right now this program does nothing.

Let me just double check.

Clear and make run.

I have a make file under the hood, but this is not a make file video.

If you want to know more about make files, see my other videos.

know more about make files see my other videos but basically it just starts running and then

it just dies right away okay no problem let me actually can i i want to fix that make file

because it’s it’s labeled after like a different project that i was doing let’s do

there’s no need for me to even do this i’m just uh i just can’t help myself okay so there we go

going back to the editor.

We have a program that does nothing.

I’m going to copy paste in a couple of useful functions that I use elsewhere.

Again, this is not an assembly video.

So, so you can look at my code if you want to, if you just kind of want to know how this

works, but not the point of this video.

So I’m not going to spend too much time.

Maybe I’ll just briefly talk about what it does, but not the point of this video.

So the first thing I’m doing is I’m adding a function called print null terminated string

function called print null terminated string just you know it sweeps through a

string or actually it asks another function I made to find out how long the

string is and then it’ll print the string to some file handle that I gave

it like standard output or standard error and you know it calls on this other

function called string length which I just wrote in pure assembly for fun even

though I didn’t need to and it just kind of sweeps through the string until it

finds a zero and then it knows how long the string is and then CRLF just prints

is and then crlf just prints a carriage return new line uh carriage return new line just um

with the same idea with the print null terminated string function and you can see all my strings have

null terminators that’s the dot zero at the very end of it okay so we got those helper functions

uh the next thing that i need to add in here is

do an intro like my growling i used to have a professor who would go

and he would go oh god when something went wrong and i do that all the time even when things are

going right okay so i’m going to paste a little function here called intro and this is not going

to be anything important it’s just going to print a little hello message you know it just uses my

intro string and then just prints it with those other functions i made so that means now my my

I can call intro real fast and then it’ll return when it’s done.

If I just sort of run the program again, you can see after all the build messages,

it’s just printing that the module has started.

Okay, so nothing super important yet.

Now, what I’d like to do is capture some incoming arguments real quick because…

Let’s see standard input.

Well, that’s actually not going to work.

Let’s see what I want to do here.

No, I think that’s part of a different program.

OK, I’m going to call a demo.

I don’t think I need to add that one thing that I was just looking at.

So I’m going to call a function that’s going to be our main demo.

So it’s going to jump down somewhere.

I’ll just create the function down later.

So let’s see.

Where is it?

Standard input.

I’m going to start off by saying this is my standard input function which is this and

is this pop p and then pop r12 and then it returns if you don’t know what a prologue

and epilogue are or why I’m doing pushes and pops just see my other videos but basically

I’m responsible for preserving it.

And I’m going to use the base pointer to help me remember where the stack started.

I’m just going to choose to…

What did I do?

I started the wrong function.

I’m going to do that one later.

Okay, for now, let me go find where that other one is.

Oh, there it is.

Should have double checked.

I’m going way too fast.

I’ll just copy paste this whole thing from my solution.

So I’m going to do standard.

This video is a mess.

Honestly, it’s a mess, but that’s okay.

I’m going to try my best to explain it.

So I have this function standard output standard error and I’m calling it here.

So it should jump right down there as soon as the program starts.

The standard input one is not getting called yet, but we’ll call it at the end of this

video.

print null terminated string function to print a message to standard output.

Remember standard output was just you know pipe one. Standard error is going to

be pipe two. So if I go back here and I say I want to print this matches to that

pipe then it’ll go to standard output just like the echo program was doing

when we looked at it a moment ago. And then next we’re going to print to

Oh, that was just an announcement that we’re going to begin.

So this is the real message that will say this is definitely going to standard output.

And then this other message is going to go to standard error, which is when we when we

looked at C error or pipe number two a moment ago.

So basically, I’m just printing an announcement and then two important messages.

One is going to pipe one and one is going to pipe two for standard output and standard

error.

OK, like really not very complicated at all.

Right.

So if I run this program now, hopefully I didn’t crash it by copy pasting out of order here.

Yeah, there we go.

Clear and make run.

So notice how it says that the messages are going to be printed.

And then notice that both of my messages actually show up on the terminal.

The one that says this message will print to standard output, number one, pipe one.

This message will print to standard error, pipe two.

They both get printed to the terminal because by default, the terminal will just take both of those pipes.

both of those pipes it’ll take one and two standard output and error but I can

use those little redirection tricks to mute one or more of those pipes so I’m

gonna say pipe one which is standard output I’m just gonna redirect that to

dev null to say I don’t want to see standard output if I run it again

notice how the only thing you can see on the string or on the screen is standard

error pipe to file descriptor 2 on the other hand if I redirect file descriptor

descriptor to pipe two to nothing then I should see all the normal messages and not see the error

message notice right here it’s it prints all the regular you know make file stuff and then the

welcome message and then here’s our message that says this is going to be printed to standard output

so notice how the error message is missing so cool if I mute both of those I can do that I can

then nothing gets printed at all because that’s all we really have is standard output and standard

error all right not too bad right that’s the basic idea between redirecting and things you

could also do things like this if I okay this is not part of my plan but suppose I wanted to take

any error message and redirect it to instead of dev null I wanted to redirect it to some kind of

standard error.txt.

Notice how nothing seems to have shown up on the screen, but if I list the directory,

now there’s a text file called standard error that contains the error message.

So you can redirect pipes, you can reattach them if you’re like an elite hacker.

You can do lots of things with them, but that’s as far as I’m going to take it right now.

I’m going to remove that.

Now let’s look at standard input.

How do you send input to the program?

Remember when programs call other programs, they can send each other standard input too.

It’s just that when I launch something on the terminal, I’m just, you know, I’m the

human and so whatever I type or, you know, what command I type is going to go into standard

input if I do it the right way.

So let’s go back to the program here.

Okay, so let’s finish up standard input.

And let’s see the pre-made code that I had here.

I had the prolog and the epilog, right?

Move the base pointer

RBP and R12. Oh, I got to put the

Base pointer back into the stack pointer. Let’s see move

Again, this is not an assembly video. So just try to hang on here. So what I’m gonna do in this video

I thought I was cute when I was making this plan. I know I’m not like that clever, but um, I

Thought hey wouldn’t it be fun instead of having a global

or the BSS section. What if I just made the stack a buffer? This is kind of what you do when you make

a local array in C++. You’re making a buffer on the stack. So this is not a stack pointer video.

So long story short, I’m just going to keep track of where the stack pointer started with this base

pointer. That’s why I have to preserve it there. And then I’m just going to subtract my buffer size

from the stack pointer. And what is the buffer size? I’ve chosen to do a buffer size of about

So that means the user or me, I could send about eight kilobytes, maybe eight kilobytes

or less into standard input and be sure that it’s all actually going to be received by

the program.

And then I’m just going to use R12 to remember where the start of the buffer is, which is

just wherever the stack pointer started.

Because if we subtract and then the data that increases is actually increasing in memory,

but making room on the stack decreased, it’s just the way it works.

There’s going to be another stack video out there.

stack video out there anyway for now I just create a buffer on the stack and

then I’m gonna print a little hello message so I’m gonna print this so just

my message saying hey we’re about to do something from standard input and then

I’m gonna send that to a standard output so the message is gonna go to standard

output but I’m announcing that we’re about to read from standard input

assuming I actually cleaned up correctly let me double check this this should

It should just simply say that it’s going to without crashing.

Okay, looks good.

So then now I’m ready to actually read from standard input.

We’re going to use a system call from this.

If you want more information on system calls, see my other videos.

But basically you just go to the system call codes table,

look up appendix area of whatever textbook you’re using.

And you say, what’s the code to read?

I want the system to read.

what you know i want the system to read so i define that as system read and if you look up

here in my program it’s just call code zero so sys call code zero is to read from somewhere

and then uh where do i want to read from that’s the second argument for the standard

or for the system call i want to read from standard input that’s going to be the number zero

if you recall and then here is a pointer to the first character of wherever i want it to

read into. So it’s going to read from that pipe, but it has to, it has to write the data that it

read somewhere so that I can save it and access it. So R12 is basically going to be a bunch of

free bytes that I created on the stack. So I like, you know, I’m, I like made the stack bigger,

but it’s mostly empty or with junk data. And R12 is just pointing to the first byte that I have

reserved. So, you know, you could imagine maybe you make a global variable in the BSS section up

up at the top, you know, like an eight kilobyte array of bytes, and then just sort of point

it to that. But in my case, I’m just using the stack because I think it’s cooler. So

I tell it, Hey, that’s the first bite on the stack that you want that I want you to start

reading from. And then I give it the buffer size, which we just looked at. And then I

do a system call and then the system now should do all the hard work for me. It’ll look at

the pipe for standard input. It’ll grab all of it. And then it will only grab, you know,

it’ll stop if the input ends before that and then when I’m done I should be able

to actually read from the buffer which is sitting at R12 and print it to the

screen so the next thing I’m gonna copy paste in there is I’m gonna print what

I just read from standard input so this is another call to my function my little

doggy wants to go pee even though he’s completely lying he just went pee so at

wants to go outside and lift his leg and do nothing and then come back in and demand a treat.

I’ll let him do it in a few minutes just in case but trust me he’s lying he’s laid like five times

today. Anyway I sometimes I regret teaching him to growl at me. It’s so cute but like it’s not

cute right now. I don’t know maybe it is. Let me know in the comments. So basically I’m going to

take that R12 buffer that I just wrote to and I’m going to print that directly to standard output

output and this is not really the important part of the video.

So I’m going to do that and then I’m going to kind of clean up here at the end of the

function.

And then maybe I’ll say goodbye.

I think I just added a string for that.

So maybe I’ll say goodbye.

I’ll say goodbye before we end the function and then I’ll actually return.

So let me go here and run the program.

Let’s see, begin.

printed because we didn’t send anything and we also didn’t call that let me call

standard input call stdin and so now it’s actually gonna print basically

nothing oh I didn’t send it anything so it’s just kind of hanging you probably

want to check this sort of situation but that’s that’s not the point of this

video let me show you how to pipe some some stuff into standard input real fast

hello and then just put a little or bar in the shell this will take the output

of echo and instead of printing it to the terminal it’ll attach its standard

output into the standard input of make run pretty cool shell trick so now we

should see the word hello the word hello printed and that’s what it does we have

detected the following stdin and it says like here’s begin that’s just a string

that I had that I print every time and then here’s the string that it actually

And then it ends.

Pretty nice.

I think maybe we could probably do the empty thing if I just started typing here.

And then maybe I hit control D to detach the buffer.

And yeah, that’s what it does.

It sort of prints here and then it ends there.

Didn’t do a new line.

I think it probably doubled it for some reason because I…

Let’s see.

I didn’t plan for this.

Let me see.

plan for this let me see it printed oh because I did I did not null terminate the string so

actually what it did is it uh let’s see if we can do that real fast one more time I’m going to go

one two three four five then I’m going to just disconnect the standard input buffer because the

printing function needs a null terminator to know when to stop there’s not going to be a null

terminator because I just typed and disconnected the uh the input so it’s actually going to just

until it randomly finds a zero and then it’ll stop so if I disconnect it it

that explanation was bunk let me try that one more time I’m gonna go a bunch

of H’s I guess there is a null terminator I disconnect it no no see how

yeah these little symbols there so it does kind of print until it finds a

null terminator but I guess I was confused because it seemed like it

like it printed it twice what’s actually happening is when i type then it’s getting sent to the

terminal which and that’s not part of the program that we just wrote then when i disconnect standard

input then the program finally prints everything that i actually typed until it hits a null

terminator in this case it looks like it seems to have worked but uh if i just do like a couple

sevens and then disconnect probably have to do this a bunch of times before we’ll see those weird

What did I do? Hit enter. That seems to have worked. My dog is stressing me out

but I love him. Alright anyway just trust me on this sometimes it’s hitting the

null terminator in time sometimes it’s not. But I hope by now you understand the

difference between standard input standard output and standard error. Thank

you so much for watching this video that I’m recording and I hope you learned a

little bit of stuff and had a little bit of fun. I’m gonna let my dog lie to me

I’m gonna let my dog lie to me for a second 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.

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

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

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

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

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

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

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

wake up I promise that’s what will happen also if you look at the middle of

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

to the website which I think is also named somewhere at the bottom of this

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

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

offer and all that good stuff and if you have a suggestion for clarifications or

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

say hey what’s up what’s going on you know just send me a comment whatever i also wake up for

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

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

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

Thank you.

The post Mastering Standard Input, Output, and Error (STDIN, STDOUT, STDERR) in Linux with Yasm Assembly Examples appeared first on NeuralLantern.com.

Ready to master x86-64 assembly? This video breaks down system services, showing you how to use syscalls to print messages, handle file descriptors, and exit programs cleanly. We’ll walk through a real assembly program, explain key concepts like standard output and file handles, and share tips from a top book on the subject. Whether you’re new to assembly or sharpening your skills, this tutorial is packed with clear examples and practical advice. Subscribe for more coding deep dives, and check out our upcoming file I/O video! #AssemblyProgramming #SystemCalls #x86_64 #CodingTutorials

Introduction to System Services 00:00:00
System Services in x86-64 Assembly 00:00:04
Recommended Book on Assembly 00:00:35
What is a System Service? 00:01:01
Example Assembly Program 00:01:21
Syscall Instruction Explanation 00:02:52
Standard Output and File Descriptors 00:04:01
Printing a String with Syscall 00:05:16
Exiting a Program with Syscall 00:07:21
Exit Codes and Program Success 00:08:02
Book Reference for System Services 00:09:51
Detailed System Write Service 00:11:01
Checking System Call Return Values 00:12:08
File Operations with System Calls 00:14:35
Closing Files and Best Practices 00:15:50
Other System Call Codes 00:16:43
File Permissions and Modes 00:17:20
Handling System Call Results 00:19:03
Future Video Plans and Wrap-Up 00:20:40
Call to Subscribe and Outro 00:21:28

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hey everybody in this video we’re going to talk a little bit about system services

in an x86-64 machine while programming in assembly

this video is going to focus on yasm assembly but this should also work for any other assembly

language that you program as long as you have the right kind of cpu x86-64 is also known as

that in mind okay so for starters let’s see here’s a wonderful book i love pushing this book i did

not write it the person who wrote it is a genius it’s called x86 64 assembly language programming

with the boot to it’s a free and open source book so anybody can go get it find his website

and here’s the version i’m using and honestly a really old version of this book is still really

good he just keeps you know making little improvements but it was it was good even a

even a long time ago. Anyway, so what is a system service? For starters, before I go into this book

a little bit more, what is the system service? Suppose for the sake of argument that I’ve

already written an assembly program, a pure assembly program, not a hybrid module program

or anything. If you want to learn assembly, see my other videos, but for now I’m just going to

assume you kind of already know how, so I’m just going to open up a pre-made program here.

I’m going to do nano so I can edit the assembly file just so you can see what’s inside of here.

just so you can see what’s inside of here.

Okay, so I hope the red is not too hard to see.

Oh, the tabs got ruined on Nano.

Hang on, let me see if I can just open this up in Genie.

Should have done that to begin with, okay.

Yeah, okay, I wrote it in Genie

and I guess I don’t have the tabs set up in Nano very well.

Okay, so here’s like my assembly program.

You know, I just have a little string here

string length and CRLF for like a line feed and some file descriptors and stuff

that I talk about in other videos here’s the entry point of the program just like

a little start entry point because it’s pure assembly and all I’m gonna do is

I’m gonna print a message right I’m just gonna print a little hello message and

then call on CRLF all CRLF does is just it just prints a new line so the program

if i run it right now you’ll just see what happens if i say let’s see clear and make run

then you can see there’s some stuff happening up here in the make file which i forgot to update

the title ignore that basically the real action is this line right here hello i’m printing using

a system service if you already know assembly then you have probably already seen this before

and it seems a little boring that’s good but i just want you to know that we’re using a system

system service to actually do the printing.

Kind of take it for granted here.

This little instruction called syscall.

What is a syscall?

Well, it’s just basically you set up some variables, some,

some codes, some data, whatever in, in some special registers.

One of the registers lets the system know what you want it to do.

One of the registers is like, or I guess all the following registers

if they’re needed, are just input to the system call that you’re trying to do.

do so in this case rax is letting the system know i want you to do this this code i want you to do

this certain thing i have a defined set up here called system right but if you look up in my

little defines area it’s just a number one so that means if i set the number one in rax i’m letting

the system know that i want it to write to some pipe to some file then you know depending on what

code you’re using rdi rsi rdx and other things may be needed or maybe not be needed at all

in this case when i’m writing somewhere it wants three arguments so i have to use rdi rsi and rdx

because those are the three arguments the first argument that it wants is where to print

see my other videos for a more in-depth explanation of file descriptors and pipes but just long story

pipes standard input standard output and standard error standard out is a pipe

number one let’s see where’s that yeah it’s just assigned a number one so

every program has its own number one pipe which is just standard output and I

guess I should say that it gets piped to file descriptor one it’s kind of like an

ambiguous term sort of but the system right call will write data to a file

file and if i give it a file handle of just one that lets the system know oh actually i want to

write to this standard output for the one particular process that we’re inside of but

you could open any file that you want and get like a file handle to it and the operating system will

realize oh you know i i associate that file handle i gave you with this certain open file that you

created or opened for reading or whatever um and so when you give the handle back it knows where

knows where to write. So in this case,

it’s treating the standard output just like a file,

just a file with a special handle of just one.

I’ll talk about that more in another video.

Then the next two arguments it wants is just the,

a pointer to the first character of the message that you want to print.

And then just an integer representing the length of the message that you want

to print. And if we just look up here again at my little hello,

my hello symbol points to an array of bytes, just characters.

bytes just characters there is no null terminator on there it’s just bytes only

and so when I give it you know message hello by itself what I’m really giving

it is a pointer to that H letter just a pointer to the memory look you know I’m

pointing to the memory location of the very first character in that string and

then for the length I’m just using a special token little shortcut thing

where you just put a dollar sign minus and then the name of another string and

and then the name of another string,

and then the assembler will compute the length of that string.

So this right here is the same thing as me

just typing the exact length of the string.

I don’t even know what it is.

I don’t feel like counting it.

You can at home if you want.

One, two, three, four, I’m not gonna do it.

Anyway, so we basically just say,

you know, I would like to write somewhere.

I would like to write to the standard output file,

file handle, I would like to, you know, to that pipe.

I would like to write, you know, this string,

you know this string and then i would like to tell you that this is how long that string is

and then after you set all that stuff up you just say system call and the system will go ahead and

do all of the hard work for you it’ll go figure out how to actually write data to the file and

you know figure out how to do everything that it’s supposed to do and all you have to do is

a little system call here right after this you can see that i have a call crlf that’s just a function

call i talked about functions in other videos but basically you know i’m just calling a function here

you know i’m just calling a function here and it does the same thing it makes a system call but

instead of printing the hello string it’s printing my crlf string and if you just kind of look at what

my crlf is it’s just these two characters 13 and 10 so like you know slash r slash n for carriage

return line feed that’s why i call it crlf so all this program does just print a message and then a

new line and then at the very end it does another system call to properly exit the program if this

hybrid program and I had like the entry point of main, you know, that the GCC libraries give you,

then I would probably just want to return at the end of this function. But since this is pure

assembly, I can actually just exit the program and be fine. So exit with success is a different

system call code. Notice how I have the symbol system exit loaded into RAX. And if you look up

here, system exit is just the code 60. So if I send a code of one into RAX, that means I want to write

a code of 60 somewhere that means i want to exit the program the only argument that takes is rdi

which is just what is the exit code that you want to return to the operating system so um

if you recall from some of my other videos let’s see if we do echo hello echo always succeeds at

least as far as i know there’s like it’s like really hard to make it fail if i echo hello then

the program echo launches and it will succeed by just printing the word hello like see how it just

like see how it just does that so that means after that command i could echo the special

variable dollar sign question mark just to see what the echo command exited with right it should

be a zero because it succeeded so you can see now a zero under the hello on the other hand

if i concatenate um let’s say a file that exists i should also get you know an error code that is a

So it’s a zero at the very end.

But if I try to concatenate a file that doesn’t actually exist,

I’ll put a OS release two because that doesn’t exist.

Notice how the cat command fails because it couldn’t find the file and the exit

code is a one.

So all you’re doing when setting RDI here is just controlling what exit code you

want your program to exit with.

This isn’t very convenient for a human running a program.

Maybe if you want to look at the exit code for some reason, but this is really,

really convenient for programs that want to automate other programs.

programs just keep in mind if you have a program that is executing another

program and it wants to see if that program succeeded the exit code is one

of the easiest ways to find out if the program succeeded so this is the whole

idea of this entire program we’re just using two system calls to print

something and then to exit the program hopefully this makes sense and now I

want to go show you this wonderful wonderful book if I didn’t already say

If I didn’t already say this before, sorry if I already did.

This book is written by a genius.

It’s called this.

Here’s the guy who wrote the book.

And here’s the version that I’m using, but old versions are good.

You can get this book for free on his website if you go find it.

So I’m just going to go to this assembly book, which deals with a lot of Yasm assembly tips

and tricks and tutorials and explanations and things.

And I’m going to go to the section labeled after system services.

So for me, this is a chapter 13 system services, just to give you a little explanation of what

this is.

You know, this is basically what I said.

It gives you, you know, a chance for your application to ask the operating system to

do something for you that you don’t want to program from scratch in assembly or that you

can’t program.

But here’s the real juicy details here.

If we go to, yeah, yeah.

Okay.

C, which is section 23.0 system services.

There’s a whole bunch of system services in here that you can, uh, that you can read about.

So for starters, if we go down a little bit, notice how it says basic system services.

If we go down a little bit, you can see right here, the system write service that we’ve

been using in the sample assembly program.

You know, when we’re just printing, we say code one is to write something.

And so this is what the table says.

you place inside of RAX before syscall.

Call code 1 is going to be to write characters and then it tells you what arguments it needs.

So like RDI is the file descriptor where do you want to write to.

Just like I said before you could give it a file handle that you already received from

opening a file or creating a file.

Or you could give it 0 or 1 or 2 if you want to try to write to one of the pipes although

actually file descriptor 0 is standard input I don’t think that would actually work.

zero to reading if you wanted to read the user’s input or or you know any input that that program

was given through its standard input rsi is just the address of the characters to write like we

talked about before and then rdx is the count of the characters to write notice how there are no

more arguments and that’s why i only gave it three arguments besides rex notice how it says here if

unsuccessful it returns a negative value if successful it returns the count of characters

count of characters actually written this is a really really good idea if you think about it

um a lot of new programmers they don’t really look at return codes when they call system services

or built-in c functions or built-in c++ functions they just kind of call it and hope for the best

but imagine if you uh if you try to write a huge long string in uh using system write call code one

and maybe some of the characters did write but the system decided to only write i don’t know half for

reason maybe it ran out of buffer maybe you know it interrupted you know your right or something

like that so it could happen what that would mean is that the return value it would be greater than

zero indicating that some characters were written but it’ll tell you exactly how many characters

were written so you’ll know that you got to keep calling the sys call until all the characters were

successfully written why would you do this i don’t know maybe you have a gigantic string like maybe

like a several gigabyte file and you wanted to copy it to another file so you’ll be calling

system write over and over again and system write it’s only going to write so many bytes at the same

time so you use the return value to figure out how far forward in the read buffer you need to advance

or you know whatever so that you can well write the entire complete file or the entire complete

string or whatever it is without any gaps without it being truncated and so forth and then of course

And then of course, if it returns a negative value, then it totally failed.

Like you tried to write to a bad file handle, like standard input or a file handle that

was closed or a file handle that was open for reading only, something like that.

And then you can use some if else, you know, branching logic.

I mean, not if else in assembly, it’s just going to be comparison and conditional jumping

or branching.

But you can have more control over your program, right?

Because you want your program to be able to respond to errors.

Let me just quickly cruise through all of the other options and let you know that

and let you know that in another video I’m gonna do a full tutorial for how to

copy one file to another by opening one file for reading and then like using

system calls to read from it and then open another file for writing and then

you know use system calls to write to it and I’m gonna do that looping buffer

stuff that I talked about before anyway so but for now I’m just gonna go through

the rest of these system call codes let’s see so first off we got open well

Well, if you want to open a file, then you just give it call code 2 and you pass in the

address here, you know, RDI, you say, here’s the address of a null terminated file name.

So that means somewhere in memory, you have to have the file name that you want to open

with a null terminator, like a zero at the end of the string, either the full path or

relative path to wherever the program is currently running.

And then RSI is going to be file status flags.

And what does that mean?

And what does that mean? We can actually just search for that.

I’m going to say control C to copy,

and then I’m going to do control F to search for that.

And let’s see what page of mine right now, 340.

If I go down to the search results for that,

it just explains what the file modes are. So if you put value zero,

that means read only you’re opening the file and read only mode value one.

That means a write only a value to allows reading and writing to the file.

So if you don’t know what that means, well, there it was.

What was I just on before?

40?

Oh, gosh.

Completely lost my…

Oh, yeah, 40.

Okay, so opening pretty easy, right?

Like if you didn’t know this before, you didn’t necessarily read me.

You could just look at this table and go, what do I want to do?

I want to open.

So here’s the code.

Here’s the address that it needs.

When you’re done opening a file, when you’re done working with a file,

you want to close that file unless the whole program is going to terminate.

unless the whole program is going to terminate at that point you i mean maybe you have a function

that gets called somewhat often and you kind of always have to open a file and sort of look at

something or write something and maybe you want to close it when the function is over right you

don’t want to have a file handle just open forever that’s a waste of memory and it might introduce

bad behavior to your program if you just have a bunch of file handles floating around that you

forgot about so it’s proper to close a file when you’re finished with it that’s just going to be

and it only wants one argument.

It just wants the file descriptor of the file that you wanted to close.

So if you open a file for a reading or to create it,

you get a file descriptor back.

You should probably hang on to it somewhere on the stack

or like in a global variable or like, you know, in a register or whatever.

Then when you’re done doing something to that file

and you’re sure that it’s time to close it,

just give that handle right back when you call code three to close it.

Then you can sort of like seek, you know,

forward and backwards to the file if you want to.

You can fork the current process.

You can fork the current process that’s kind of advanced for this video.

You can exit.

Remember before we exited from that program with code 60.

So that’s it. Call code 60.

If you didn’t watch this video, you could have gone through this table and just said,

Oh, you know, I want to terminate the executing process.

I do a system call with code 60 and I’ll give the exit status to RDI,

which is typically zero for success.

Bunch of other stuffs create, get the time of day,

and then the file modes that we talked about before.

we talked about before and then file permissions. Let’s see, where’s the permission. I think it’s

when you want to create a file. Yeah, right here. If we wanted to create a file, that’s code 85.

RDI is the name of the file, you know, like a pointer to the string. RSI is the file mode flags.

And then you’re thinking like, what are the file mode flags? Just go down here and then here you

go. All the file modes that you could ever want. You just look at it and go, well, I guess I can

I guess I can just copy paste this number right here and it’ll end up being, you know,

whatever is described on the left and the right.

Like the group has read, write and execute permissions and so forth.

I mean, really, if you look at this long enough, you’ll kind of realize that this is a quad

word because it has a Q on the end of it.

And the rest is just an octal file permissions notation where this first number here, notice

how the first two are zeros, but this first actual number here is something that applies

to the user and then the next one applies to the group the next one applies to others who are not

part of the user or group and this video is not about file permissions I’ll probably make one

later if I think people will actually watch it but yeah you can just kind of like look it up here if

you want to and just copy paste that into a define somewhere let’s see what else I just want to show

you a little code snip just to illustrate a little bit more what I was talking about before

for. People usually make this mistake, they’ll do see this is what people will usually do like new

programmers. Suppose this is a function pretend we’re in C or C++. For the time being, you call

some sort of a system function or an API of some other library. And you just you just hope that it

works, you just call it and then your program continues underneath, right? It’s a bad idea,

because maybe that failed, maybe there’s some action you need to take. So instead, it’s a really

really good idea to check the return result or i should say an even better idea is check the

documentation usually these types of you know c system calls or function calls or api calls or

whatever they’ll return something indicating success or failure sometimes the documentation

will tell you oh you’ve got to put like a pointer to some other data structure in the arguments

and then the result comes there of course just read the documentation but usually it’s just

So you want to grab the result and then check the result.

In this case I’m assuming this is sort of a standard function that will return zero

or greater on success like the system write call or the system read call and return less

than zero if it fails.

So here I’m just responding, you know, if it’s like if the result was greater than zero

then it’s like, yay we can proceed.

Maybe I’ll continue with my program in some way and if it’s not then I’ll print a complaint

then I’ll print a complaint to the user and then I’ll take some sort of an action

like I’ll write to a log file, send an email somewhere, you know,

do something to try and recover from the error and alert admins to the error.

And in this case, I’m just throwing an exception.

This video is not about exceptions, but so I just want you to know,

this is a good design pattern to not just discard the result of a call to

something. You should check the result and see what you’re supposed to do.

Let’s see, what else did I want to tip?

system services, file handles.

Yeah, okay, I think that’s everything that I wanted to tell you.

In future videos, I’m going to talk about, you know, some of this stuff much more in-depth,

like with my file.io video that I’m going to publish pretty soon, which is, you know,

it lets you read and write to files, and it uses a loop to read a little bit at a time.

Okay, thank you so much for watching this video.

I hope you learned a little bit of stuff and had a little bit of fun.

I’m outie.

Or something.

Goodbye.

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

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

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

also if you look at the middle of the screen right now you should see a QR

code which you can scan in order to go to the website which I think is also

named somewhere at the bottom of this video and it’ll take you to my main

website where you can just kind of like see all the videos I published and the

services and tutorials and things that I offer and all that good stuff and if

if you have a suggestion for uh uh clarifications or errata or just future videos that you want to

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

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

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

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

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

Thank you.

The post Mastering System Services in x86-64 Assembly Programming appeared first on NeuralLantern.com.

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

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

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hey there, I’d like to talk to you about debugging your program’s output with xxd.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

This is not a make file video.

See my other videos.

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

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

Hello, I feel awesome.

It looks good in the terminal.

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

What if I corrupted the message on purpose?

This can happen in assembly all the time.

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

That either reads from the wrong spot

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

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

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

0 L O and what that should do is

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

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

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

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

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

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

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

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

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

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

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

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

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

standard pipe which is just a number one file descriptor if you don’t understand

If you don’t understand that, I have other videos, but I’m going to run the program again,

but then I’m going to redirect the output to a file and I’m going to call it stdout.txt.

It’s probably a good idea to eliminate spaces.

I think I’ve made mistakes in other videos where I didn’t put a space before or after

this little redirector symbol and I ended up creating a file just called the number

two or the number one.

But pipe number one is standard output.

So I’m going to say anything that comes to pipe one, which is standard output, I’m just

output I’m just going to redirect it to a text file. So when I hit enter notice

how nothing prints to the screen but the standard output text file that I

specified is now created. If I spill the contents of std out it still looks

normal so don’t let that trick you but watch what happens if I use xxd.

xxd std out basically xxd is going to read it as a binary file and tell me

every single character in there while I oh I forgot to change the title of that

that’s not this video but notice right here where it says H E L L O and then

right before that there’s like a little dot if you look at the dot let’s see

what is the dot it’s one two three four five six it’s the sixth thing one two

one two three four five six seven eight nine ten twelve thirteen fourteen fifteen oh there’s

fifteen characters but there’s not that many i think probably they’re packing them by two here

let me see if that makes more sense now one two three four five six one two three four five six

yeah that makes a lot more sense so the sixth uh byte not the sixth uh word uh is basically

to this dot right here and if you recall oa is a decimal 10 which is uh the beginning of a new line

you know like a carriage return line feed um 13 comma 10 so that’s what it is right there

and then so now we know that there’s xxd is figuring out here or helping us understand

that there’s a new line between slash main and then the message which if you recall that’s

exactly what happened and then when we look into our hello string there’s a dot in the middle here

string there’s a dot in the middle here what is that dot well we just have to figure out what

number that corresponds to so the oa was that dot right there so we just got to go a couple more

bytes forward one two three four bytes forward one two three four bytes forward it’s this zero right

so xxd even though the terminal didn’t help us originally xxd has helped us realize that we’re

that we’re actually printing a zero under the hood and we can’t see it in the terminal.

So we have now debugged our output. You know, depending on where you print this,

you might see nothing like in the terminal. It didn’t really show anything. But if you’re on a

webpage somewhere or some other type of thing that’s going to print the data for you, you might

see a weird symbol. I mean, it really depends. This is not something you’ll see everywhere, but

you might see a weird symbol that kind of looks like a black diamond with a question mark inside

mark inside of it or some other weird symbol.

If you start seeing weird symbols all over the place or just in a place where you know

there’s not supposed to be a weird symbol, that might be an indication to you that you

have weird values sitting inside of your string.

And then you should probably try to debug with XXD.

So that’s it.

That’s the basics for debugging with XXD.

Just, you know, file output anyway, for your information.

If you wanted to debug the standard error pipe, you could also do this.

you know because the error pipe is just a two um and that’s basically it i’m not going to

debug right now because that’s that’s too easy but i hope you enjoyed this video thank you for

watching i hope you learned a little bit and had a little bit of fun i’ll see you in the next video

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

appreciate it i do hope you did learn something and have some fun uh if you could do me a please

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

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

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

So please do me a kindness and subscribe.

the middle of the night and i just wake up because i know somebody subscribed or followed

it just wakes me up and i get filled with joy that’s exactly what happens every single time

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

me up in the middle of the night just subscribe and then i’ll i’ll just wake up i promise that’s

what will happen also uh if you look at the middle of the screen right now you should see a qr code

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

you to my main website where you can just kind of like see all the videos I published and the

services and tutorials and things that I offer and all that good stuff and uh if you have a

suggestion for uh uh clarifications or errata or just future videos that you want to see please

leave a comment or if you just want to say hey what’s up what’s going on you know just send me

a comment whatever I also wake up for those in the middle of the night I get I wake up in a cold

it would really mean the world to me. I would really appreciate it. So again,

thank you so much for watching this video and enjoy the cool music as I fade

into the darkness, which is coming for us all.

Thank you.

The post Master Debugging with xxd: Inspect Program Output at a Byte Level for Automation & Clean Code! appeared first on NeuralLantern.com.

Hey everybody! Ready to crush those pesky bugs in your C++ and assembly programs? In this video, we’re diving deep into the GNU Debugger (GDB) – the ultimate tool for tracking down crashes, inspecting variables, and mastering your code. From setting up debug symbols to navigating call stacks, setting breakpoints, and even debugging assembly registers, this fun and relatable guide has you covered. Whether you’re a beginner coder or a seasoned dev, you’ll learn practical tips to level up your debugging game. We’ll also tackle null pointers, create GDB scripts, and explore why your program might be misbehaving. Stick around for a few laughs and some serious skills! Don’t forget to subscribe, hit that like button, and check out my website for more coding tutorials. Let’s debug like pros together!

Introduction to GNU Debugger 00:00:00
What is a Debugger 00:00:20
Debug Symbols Explanation 00:02:08
Compiling with Debug Symbols 00:03:13
File Size Comparison 00:05:30
Installing and Launching GDB 00:06:21
GDB Console Basics 00:06:55
Attaching GDB to Program 00:08:12
Running Program in GDB 00:09:09
Handling Program Crash 00:13:02
Understanding Call Stack 00:14:05
Navigating Call Stack 00:18:13
Inspecting Variables 00:19:08
Null Pointer Issues 00:21:25
Using GDB Script 00:25:10
Setting Breakpoints 00:27:04
Managing Breakpoints 00:28:37
Continuing Execution 00:30:41
Debugging Assembly 00:33:24
Global Variables in Assembly 00:35:43
Advanced GDB Commands 00:38:31
Conclusion and Call to Action 00:40:22

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hey everybody! In this video I’m going to show you how to use the GNU Debugger to

debug your C++ and assembly programs.

You can also use it for C and some other stuff but we’re just going to focus on

C++ and assembly. What is the GNU Debugger and what is a debugger in the

first place? So for starters the GNU Debugger it’s like it’s called GDB and

the db you can imagine that stands for debugger something like that and the g stands for gnu i

personally don’t know how to uh pronounce gnu so i just say gnu because it it feels more fun to do

it that way it’s more interesting i think probably some people just say new but i don’t like that

because the gdb debugger is really old and robust and powerful it’s not a new tool it’s it’s an old

new debugger someone’s always going to ask what was the old debugger and then I say this is the

old debugger the new debugger is the old debugger anyway so we’re going to use the GNU debugger

if you haven’t yet watched my video on caveman debugging you probably want to watch that first

just for like some basics of you know why you might want to look at information in your program

but for now we’ll just assume that you already know what’s going on with just like why you would

know how to make make files see my other videos but here i just have a basic make file all it’s

really going to do is just sort of compile a very simple program and add debug symbols into it so

let’s double check that i’m actually doing that here yeah there we go okay so the first thing

that i should probably show you is uh we are compiling a c plus plus source module so i’ve

actually using c but i i have that left over in there anyway and then we’re assembling something

in yasm we’re linking with g plus plus because we want to have a hybrid program and we’ve got

all these flags here those are just variables and so uh so now before i can debug with gdb

i’ve got to talk about something called debug symbols what are debug symbols imagine just a

bunch of extra information explaining all of the design and variables and everything inside of your

about your code stuffed directly into the executable.

So imagine, you know, when we compile a C++ source module

into an object file, usually that’s just, you know,

assembly at that point.

But when we add debug symbols, we’ll have a bunch of information

that can help the debugger figure out where we are in the program,

what the variables look like, you know,

a bunch of extra information to help the debugger pretty much.

The assembler will put debug symbols into the object code

symbols into the object code that you generate the compilers will do that the linker will do that

and so it’s important to understand if you don’t generate debug symbols when you’re compiling and

linking your code then your debugger won’t actually be able to do anything it won’t understand what’s

going on you can debug it but like you’re not going to see anything that’s very uh that’s useful

so let me show you real fast i’m going to do make clean and then i’m going to say make build

that I do not have debug symbols.

All right, okay, if you don’t know how to compile and link from the command line, see

my other videos, but for now it looks like we’re not generating debug symbols.

So if I list the contents of my directory here, just note the size is real fast.

I have an assembly module here that I’m calling ASI.asm, ASI for assembly, and then we’re

assembling it down to an object file.

Notice how it’s just 656 bytes, very small.

plus plus module that I’m creating here is compiling to an object file that is

about four and a half kilobytes so you know not too big the final executable is

called main and it’s about 17 kilobytes so this is without debug symbols when

you’re compiling something on your own you need to add extra switches to enable

debug symbols so you can see here in this make file that I’ve made and again if

you don’t know how to make a make file or compile or link or anything see my

But for now, I’m just going to assume you kind of know your way around to makefile,

or at least you can kind of infer what’s going on.

So I’ve commented out a different version of this variable for the flags of my C++ compiler.

If I uncomment this and then comment out the other one,

you’ll notice the only real difference is this part right here, dash G dwarf 2.

Usually in C++ compilation, it’ll just be dash G to generate debug symbols,

and then the symbol format will default to a format called dwarf2 so I don’t know for these

tutorials I like to just specify the full format but you can just say dash g in your c++ compiler

and linker we do the same thing for the linker down here so I’m going to uncomment this

and comment that and the only difference is just g dwarf2 so I’m just telling my linker that I also

want debug symbols in there too then we do the same thing for the assembler so I’m going to

So I’m going to uncomment that and comment this other one.

And the only difference is that in the assembler,

we kind of have to specify it a little bit differently.

Instead of G dwarf dash two,

it’s just G dwarf two as just one string.

And I think with Yasm, you have to specify the debug symbol format.

So just keep that in mind.

So now I’ve turned on all the debug symbols.

I’m going to do real fast, make clean and make build one more time.

And then if I list everything,

list everything let me just double check that it’s building the symbols now right okay good

notice that the files are bigger so this asio um file is now 1.8 kilobytes instead of you know

half a kilobyte the main.o object file is now 36 kilobytes instead of only 4.5 and the executable

main is 36 kilobytes instead of just 17. so you can feel it already right like there’s a bunch

extra information sitting inside the object files and the binary which allows us to debug our program

okay so now that we’ve generated debug symbols in our program we can actually think about starting

to use gdb so gdb is a program just gdb by the command line if you don’t have it in your system

already you can go sudo apt install gdb or depending on what system you’re on maybe a or

or whatever your package management program is,

but we just need to install GDB.

On Ubuntu and Debian, I think,

there is a meta package called build essential,

which will give you a bunch of compilation tools

and make file stuff and whatever.

So I’m just going to assume at this point

you already have GDB on your system.

To launch GDB and go into its console,

just type GDB by itself.

So now we’re inside of the GDB console or terminal.

console or terminal. We’re no longer inside of a bash terminal. We can’t type normal commands.

Let me show you real fast. Here’s the first command you want to learn on GDB. It’s called

quit. Never quit. Never surrender. So, you know, normally if you’re at the command line,

you can do something like cat, etc. OS release just to see what operating system you’re using.

So you can see for this virtual machine that I’m using right now, I’ve got like Ubuntu 22 on there.

If we go inside of GDB, we can’t use regular bash commands anymore or regular operating

system commands.

We can’t say cat, et cetera, OS release because we can now only use GDB commands.

We’re inside of GDB already.

Notice how it says undefined catch command.

I don’t know what you’re talking about, dude.

Okay.

So remember we do a Q or quit to get out.

You can actually just type Q.

A lot of commands that I’m going to be talking about.

going to be talking about you can abbreviate them with one or two or three letters and it totally

works just for speed so now that we know how to enter gdb and now that we also know that we have

already compiled our program with debug symbols we can attach gdb to our program i mean what’s the

whole point of a debugger we most of the time we will just have our debugger attached to our program

and launch it or i guess launch it while it’s attached you can also attach to a running program

but we’re going to launch a program and stay attached to it.

And then we can sort of catch crashes and see what’s going on.

Or we could also tell the debugger to stop the program at certain points in time,

like when we hit a certain line number or when a variable changes or something like that.

And then we can look around.

We can look at all the variables, look at the state of the program,

even change things if we wanted to.

We can look at all the registers if you’re coding in assembly.

So it’s pretty useful.

Anyway, I’m going to go gdb and the next command we’re going to learn is file, which just tells

gdb to attach to a program so that we can run it.

So, you know, the name of our program here that we compiled is just called main.

And so if I type file main, then gdb should load up that file and try to parse its debug

symbols so it can begin debugging for you.

Notice how it says reading symbols from main.

you know if we did a typo or we had something with no debug symbols it will give us some sort

of an error message so for now i’m just going to quit and then go back in just to make sure that

it’s all clean and we’re going to do file main now it attaches once it’s attached that’s not i guess

it’s not technically attached because the program’s not running but once it has loaded the debug

symbols for that program we can run the program with the run command in gdb also kind of interesting

If you have debug symbols that are generated separately from your executable,

you could tell GDB to load the symbols file and then run your program.

That happens a lot in Linux where people release the non-debug friendly version of a program

and then they’ll release the debug symbols separately if you’re interested.

Anyway, so I’m going to type run and it’ll run the program.

Notice how GDB kind of tells us that it’s starting up now.

here’s like a thread debugger that’s being enabled and it says we’re using this library to do it and

then it says hello you know here’s the hello message so the program is actually running that’s

not my name i wish it was and then it prints the final result and then gdb says your program exited

normally on newer versions of gdb there’s a setting i think by default where it’ll ask you

if you want to start a debug daemon a debug info daemon or something yes or no you can usually just

without actually having to type n.

It’s a little bit faster.

So the whole program ran and finished.

If I type run again, it does the same thing.

In GDB, if you hit enter without typing anything,

it ends up repeating the previous command.

So I’m not going to type run.

If I just hit enter, are you serious?

GDB made me into a liar.

Well, most of the commands will repeat if you hit enter.

I guess not the run command.

So I’ll type run again.

And okay, I mean, the program is pretty good, right?

So if you watched my…

It’s not pretty good.

watched my it’s not pretty good it’s a nonsense program I mean it it doesn’t crash is what I’m

saying if you watched my previous video which you should on caveman debugging I had this uh you know

nonsense portion of code that just sort of updated a variable and we pretended that we were confused

and we didn’t understand what was happening and uh we used gdb to debug it so what I’m going to do

either let’s say we’ll start off with throwing an exception and then we’ll try to use a no pointer

and then we’ll see a crash and then after that I’m going to start using breakpoints where we can stop

automatically inside of our program to print the state of the program print the variables

and then I’m going to do that first in C++ and then hopefully I’ll remember to do that in

assembly right after it’s basically the same thing only with assembly you don’t really have

you know a bunch of variables everywhere you just kind of have registers and maybe some globals

globals but it’s going to be the same deal okay so let’s pretend that uh we are gonna have a crash

okay so this program just kind of runs later on we’ll figure out why the result is wrong we’ll

just pretend that it’s wrong but for now we’ll just say how about we uncomment this line right

here and what will happen is when we’re running the main loop at some point in the loop we get

When F gets called, the input will be looked at here.

And if the input is more than one,

which is definitely gonna happen like right away,

then we’ll call on the G function.

Then the G function will just throw an exception.

We’ll just pretend that something really bad happened.

You crashed or you actually did throw

and you didn’t catch your throw,

or maybe the system threw something at you

or another library threw something at you

and you didn’t catch it.

So just basically a program crash.

Let me run this real fast.

So make run just to show you that the program crashes.

Make run at this point is the same thing as just kind of executing the program.

But you can see that it says terminate called after throwing an instance of runtime error.

And then there’s the message, oh my gosh, and then aborted core dumped.

That’s not good.

So now let’s try to understand why.

Why did that crash?

Pretend you don’t know that it happened in G. You know, you’re trying to investigate.

So we could type GDB and then we could type a file to load the debug symbols, but it’s a little bit faster just to type GDB main and just sort of name the file that you want to load right away.

So if I do that, notice how it automatically tries to load the debug symbols from main.

Then I can just type run and then the program tries to run and notice how it actually catches the crash.

If you look down here, terminate called after throwing an instance of runtime error.

throwing an instance of runtime error so that’s what the program thinks is going on but then the

program is trying to terminate but then down here gdb is like wait wait wait i just caught you know

a termination uh getting invoked here and you can see this is sort of system code like we did not

create this source file p thread kill we didn’t write that that’s the standard library and there’s

a function here called p thread kill implementation with those you know fun c underscore prefixes

prefixes everywhere and so this is like some sort of a c source file and we don’t have that file on

the system so we can’t really debug that file lucky for you most of these standard libraries

work all the time so you don’t really need to debug them you need to debug your code instead

of the standard library code so the question really is how did i get here how did i get to

this crash so the next command we’ll learn in gdb is just the where command the where command will

I’m going to release a video in the future that kind of explains call stacks, but basically

imagine a abstract data type, a data structure called a stack. And every time you want to add

data to the stack, it just sort of stacks up on top of the last piece of data. So like if I add

something, let’s say I want to add the number five, then I would just add the number five on top of

the stack, right? If I wanted to add the number 11, then I would just add the number 11 onto the

off of the stack and the stack is a really good data structure to uh sort of give you a trail of

breadcrumbs to know where you got where did you come from so we call this the call stack because

what’s happening is every single time you call a function then the new scope and then you know the

new function that you’re invoking um it has something called a call frame full of information

current address is and all that stuff.

And we’ll just call that chunk of data that belongs to one instance of a function call.

We’ll just call that a call frame.

And so if you’re stacking call frames one on top of the other,

then we call that whole entire thing the call stack.

And this is what allows us to use recursion and all these complicated call graphs and everything.

It’s really simple, but it’s really powerful.

So you’re looking at the call stack.

Each one of these lines is the call frame or is a call frame.

And so for example, if you just look at number zero here, you’re looking at call frame zero,

which is the closest frame to wherever the crash occurred, which is if you look at it,

that’s exactly what we were looking at when we saw that original message, right? Call frame zero.

So that’s not really useful. You want to go down to higher numbered call frames or I guess

physically lowered number call frames and just kind of scan it until you find some code that

raise no abort no none of this stuff is ours live standard c plus plus no the first frame that

contains code that is ours is call frame number nine or i guess like nine away from our current

position so i guess find the physically highest call frame that is your code or the lowest numbered

call frame that is your code and it’s telling us right here all right we uh we actually seem to

So if I go to 65, right there, it tells you exactly where the crash happened.

If you’re still trying to figure out, well, how did I get to that crash?

I don’t know how that actually happened.

Just keep looking down further in the call frames.

The next one, call frame 10, says, well, we were inside of function f with input equals

three at main.cpb line 46.

So if I just go to 46, I can get another clue.

I can go, all right, so for some reason we called g.

Imagine again, this program is much more complicated.

And then if we’re still confused, we just look down at another one and it’s like, well, this all this whole mess started at CPP main dot CPP line 28.

So if we look at line 28, it’s like, well, we were inside of this loop and we we called the F function and then the F function called the G function.

And then G just kind of did a throw. So that gives us a lot of information.

All right. Next thing we can do is we can sort of move up and down the call stack, because right now we’re sitting at call frame zero, which is just the system code.

which is just the system code, but maybe we don’t understand why the throw actually happened at,

let’s say, line 65, right? So we can use up to go up in the call stack to a different call frame.

So if I hit up, notice how it mentions that we’re now in frame number one instead of zero.

And if I do up again, we’re now in frame two, which is a little bit closer. We can use the

trick finally where we hit the enter key instead of repeating the command. So I’m just going to

and hit enter a couple times until we eventually get to our code,

which I think was supposed to be at frame nine.

So I’m just going to hit it a bunch of times until we get to frame nine.

Now we’re looking sort of back in time at that point

because all these other frames actually did get invoked,

but we don’t really care about what was going on inside of them

because they probably did their job correctly.

We’re looking at our code, so we’re going back in time

right when we were doing this throw.

Oh no, we threw. Why did we throw?

well there’s another command in gdb called info locals

okay the info locals uh there’s there’s really not much to this maybe maybe let me do this again

a equals five and uh then i’ll just say a plus plus just so that we have a local variable

i forgot that gdb doesn’t consider the incoming arguments as locals so there was nothing there

real fast uh gdp oh let’s do make build and then gdp main and then run and then we have a throw

and then i say where and then i go up up up up to a frame you can also use the keyword down if you

go too far if you want to go you know back down in the call stack but i’m just going to use up

okay so now we have it here now finally i think i can do info locals just to see the local variables

notice how the a variable is there now because I just added a local variable a a moment ago

you can also print things directly you can say print the input incoming variable if you’re in

assembly you can also print registers you can say info registers like that and you’ll get a nice

print out of all the registers you could print individual registers you can say let’s print

register r12 you can print register r12 as binary by saying I think it’s p slash t

or print slash t yeah we can probably just do print slash t also

t stands for two because they’re it’s a base two number system

does that mean there’s a p slash h or a p slash f for 15 or 16 s for 16 i don’t know i haven’t

tried that is it going to work hang on p slash s bar 12 it’s not going to work nope didn’t work

i think it thinks it’s a character point or something but anyway so we can print a lot of

So we can print a lot of stuff.

And like I said before, we can go up and down the call stack.

So I can go down a couple times and then go back up again.

And now we can assume that we’ve kind of debugged, you know, where the source of the error was.

So I’m going to comment that call out to G and run the program again one more time with a different error.

So I’ve commented this code out from before, but just imagine now that we’re going to use some pointers.

We’re going to start off with a pointer called P.

a pointer called p we’re going to set it to null at the beginning and then we’re going to just

kind of allocate it and then we’re going to set you know a value and then we’re going to dereference

it and dereferencing a pointer just kind of sets the first value in an array you can do that and

then we’re going to deallocate the pointer and then how about right after that we do something

really really naughty we say p at some index is equal to a five this should be this should be a

a program crash because we deallocated p already at that point we would be dealing with junk data

if we tried to dereference p but to make it even more clear that it’s naughty we’ll set it to a no

pointer and then we’ll try to actually use it so let me let me just restart the program real fast

i’m gonna do quit yes and then we’ll do make a debug just so you know my make debug is just a

Let’s see, where’s that? Where’s that? Where’s that? Do I not have a debug shortcut yet?

Oh dear. I need to add that before this video is over. You know what? I’ll add it right now.

We’ll do this run and we’ll say debug, make debug, and it needs to build first. And then I’ll say

debugging the program. And then we will do the GDB binary and give it an argument of

the executable and then later we can we can upgrade this to take a little script of commands

because the commands are going to start getting out of control so now if i do make debug if i

didn’t screw it up now it at least goes in there and i’ll do run and then we have a seg fault and

notice how it tells us right away hey you have a seg fault right here you’re accessing invalid

memory let’s do info locals just to see what’s up oh the p is actually a zero that’s a null pointer

explicitly oh whoops you know oh what have I done but it’s a really good idea to set your

pointers to null after you deallocate because if you don’t you might end up with undefined

behavior where sometimes the program doesn’t crash while you’re overriding junk data or reading junk

data but sometimes it does and you’re not really sure like why does it work sometimes and why does

it not work sometimes so let me comment this out and see if it’ll crash uh let’s just let’s just

make debug and then i’ll do run and then if we do info locals oh yeah okay so this is uh

it did seg fault so that’s good uh if we were unlucky then the program wouldn’t have crashed

it would have just started behaving strangely and um when we print out the value of p notice how it

looks like a pointer still like if we were to debug the program and print the pointer value

then it doesn’t really it looks the same it looks the same after we deallocated it right so that

this is called a dangling pointer meaning you deallocated the pointer but you forgot to set

it to null afterwards so then later when you’re trying to debug the program it’s a little confusing

because you’re like that looks like a regular pointer what did i do wrong so um it’s really

good practice to set your pointers to null right after you deallocate them that way when you’re

debugging later because something crashed instead of seeing a memory location on p you’ll see

On P, you’ll see something that looks definitely like a null pointer and print P.

Then it’s way easier to realize, oh, whoops, I was trying to use a dead pointer, a pointer that I deallocated.

Hopefully that makes sense so far.

Next thing I want to do is a small upgrade.

I can’t remember if it’s dash X or dash EX.

I think it’s dash X.

But you can write a little script.

I have a little script here called Good Doggo.

called good doggo you can just make any file name it anything you want i’m so i’m just naming it

good doggo.txt because my dog’s taking a little nap behind me as usual um but you could name this

gdb.txt or whatever it is you want so you can put inside of this script file any command that you

want gdb to execute when it launches so let’s just comment this stuff out real fast and i’ll do

I’ll just do run maybe for starters.

Because whenever I’ve been launching for debug,

I launch with GDB and then I type run manually, right?

So I want to save a little time.

So good doggo is the name of the script.

So when I invoke GDB, I am going to,

where is it right there?

Okay, it’s GDB.

And then I’m going to go dot, I think it’s X.

And then I’m going to say good doggo.txt.

If it’s not dash x, then it’s dash ex.

One of those executes the command that comes after,

and one of those executes the command script that comes after.

Let me just double check that this actually is going to work.

So make debug.

All right, okay, so it was dash x.

Dash x specifies a script that will be run.

Dash ex just specifies a command that you can put right in there.

Like I could have said dash ex run, and it would have ran right away.

But the script is more convenient, right?

Because we can save typing.

So notice how it ran right away and then there’s a seg fault.

Okay, so now let’s go a little bit deeper.

Let’s change this to false again now that we understand like null pointers and all that

stuff.

So we can just basically deal a little bit more with only what the main loop is doing.

Suppose we just still don’t really understand what the loop is doing, why our answer is

you know, good or bad.

So maybe I want to do a breakpoint at the top of that for loop.

loop gets to the top of its iteration, I want the program to pause so I can look around.

So I’m going to set up a breakpoint on line 22. And here’s how you set up breakpoints

in GDB. I’m going to go ahead and maybe do the terminal for now. And then I’ll stick that into

the script next. I will not remember that it’s line 22. That’s okay. I’m going to do quit.

And I’m going to do make build. Then I’m going to go GDB main just to jump in there.

and then i’m going to say break or just the letter b just to make a break point you type the name of

the source code file that you want to break in and then a colon and then the line number where

you want it to break so i think i think it actually was line 22 oh i can see it and then

maybe i want to have it break at line i don’t know maybe right here line 25 right before it increases

And then so I’m going to do an up arrow to just repeat the command so I can edit it real fast.

And then I’ll break again at line 28 and then maybe 30 and then 32.

So I’m going to go 28, 30 and 32.

30 and I’m just making up break points.

I just want to inspect the program and then maybe I’ll break at line 36 so I can see what the final answer is.

So I just have a bunch of break points set up.

Remember when the program is running now under GDB, every time it hits one of those lines,

every time it hits one of those lines the program will pause and i’ll have a chance to look around

at the variables and things so i’m not sure if i’ve set up the breakpoints correctly i can say

info breakpoints and it’ll show me all of my breakpoints notice how you can enable them and

disable them so let’s say for the sake of argument i want to disable the breakpoint at line 30 because

maybe i don’t really need that right now but i kind of want to keep it in the system for later

disable four because it’s number four.

It’s breakpoint number four.

So I can say disable four.

Then if I do info breakpoints again,

notice how there’s a little N on there,

meaning breakpoint four is disabled.

So I could re-enable it with a four

and then go info breakpoints again.

So now they’re all enabled.

I am going to maybe copy this into the script file real fast

so I don’t have to keep typing this over and over and over again.

Imagine if every single time you changed your program and recompiled it you had to type all of the breakpoints from scratch

That’s why I want you to use this little breakpoint script

So we’re going to do B to break at main.cpp line 22 and 25 and

28 and

30 and 32. I should have copy pasted the three dang it 36

And after we’re done setting up all the breakpoints

show me the breakpoints just so I can have a visual reminder. Keep in mind if you change too

much of your source code then you’re probably going to have to update these lines and that’s

okay but it’s a good idea to just at least you know kind of look at them a little bit so that’s

why I’m saying info breakpoints. And so then remember again the makefile all it’s doing when

I type make debug is it’s just launching this command right here it’s just saying gdb with the

with my gdb script so let me quit to get out of this and then i’m going to say clear and make

debug and notice how it did all that stuff for me it added the breakpoints it showed me the break

points and then it ran the program like i told it to and then it already broke on a breakpoint it

already break it break breakened it’s broken i don’t know i don’t think it’s broken uh so we’re

So we’re on breakpoint number one on line 22.

And here’s the for loop.

I can type all of my inspection stuff.

I can say info locals.

I can say print I, I can say print A, I can print whatever I want.

And then when I’m done kind of looking around and inspecting things,

I want to continue the program.

I don’t want to just stop it here.

So I’m just going to use the command continue.

And it goes right to the next breakpoint.

If I want to, you know, continue again, I can hit C.

continue again i can hit c or i can just hit enter you know to just sort of keep continuing as i

inspect and print things let’s see when can i get to break point number one is that what’s going on

here hang on a second what is break point number one oh i know what to do info break points

break point number one is that main.cpp line 22 is that actually going to get hit oh it’s

having issues here with my GUI. Okay. Line 22. Okay. So it’s not really hitting that anymore.

I guess it’s not going to think that it hits the top of the forelip. Okay. So I guess breakpoint

two is where we’re always going to be hitting. So let’s just suppose that I’m continuing until

I hit breakpoint number two. Suppose that the next 10 times I see breakpoint two, I don’t

actually want to stop and break on it. I just want to skip the next 10 iterations for some reason.

some reason you can say continue 10 and it’ll skip the next 10 times that it hits the number two

notice how if i hit continue a bunch of times we’re not really seeing the break point number

two anymore we’re seeing other break points and then eventually if i hit it enough times

we’ll probably see two again oh my god oh my god are we seeing it yet no

Okay, wait, are we seeing I’m freaking myself out.

Okay, so let’s continue 10 times on breakpoint three, then we’ll only see

breakpoint four, I guess.

So we can do continue 10 times on breakpoint four.

What is going on here?

Did I write this program in a weird way?

Hmm.

Well, trust me on this.

Let’s continue 100 on breakpoint three and then continue 100 on breakpoint four.

breakpoint 4. Okay, so now we’re just done with the whole entire program. I guess there must have

been a 2 there that I missed. So now we’re finally on breakpoint 6, which is when everything is

finished. Let me show you real fast that we can add more breakpoints in assembly just to prove

that we can debug assembly real fast. So if I want to debug assembly, I just have to type the name of

that source code file. If it was nested in a folder, like if you had like a complicated hierarchy of

of source code files you would just need to type the relative path but for now I’m just going to

be able to type the name of the file so assy.asm and let’s suppose that I want to break at line

16 just so I can see the registers that I set up so I’m going to do 16 and then I’m going to break

at assy.asm line 16 and then I’m going to run and that actually never gets called does it no no it

called does it no no it gets called I think I have a call up here somewhere

nope I don’t have a call okay let’s make a call this is gonna throw off all of my

C++ breakpoints so I’ll just comment them all out right now comment them all

out so I don’t have to redo them and this is a hybrid program so I’m gonna go

extern what is it extern C make a block where I name the function the reason we

name mangling so the AC symbol is going to show up as just its regular function

name rather than a bunch of extra stuff indicating the prototype so that we can

do overloading so we’re just going to disable that and then at the very top of

the program I’m just going to call it this should hopefully work let me just

do a regular make run just to make sure the whole program compiles okay now

debug script we’re gonna break on line 16 which is going to be letting us see

the registers okay so I’m gonna go make debug notice how it hit the breakpoint

in the assembly just the same as the C++ and we can print whatever we want now so

I’m just gonna say info registers and if we look carefully we can kind of see

that we modified racks REX is 15 so that’s expected RDI is 20 which is

R12 should be a giant number. Where’s R12? Right there. So you can see the state of your program at any point in time just by breaking on it.

I’m breaking on a certain line. So this is tremendously useful for debugging not just for higher level languages but also assembly.

What else can I do? Oh let’s put a global in the data section. So I’m gonna do, I don’t know, my thing or something like that and we’ll call it a byte array and I’ll just go hello.

I’ll say we have a thing one and a thing two.

Something like that.

And maybe thing two is a null terminated string,

whereas thing one is a regular thing.

We should be able to print those symbols.

If that’s not true, I’ll come back at a later time

and show you how to do it.

Anyway, so we’ll do make debug

to just kind of assemble everything again.

And we know how to do info registers.

We can print, you know, one register in particular,

print R12 if we wanted to.

History has not reached.

History has not reached 12.

Oh, I got to put R12.

Yeah, then we can get the, wait a minute, wait a minute.

Oh, I threw off the line numbers because I added the variables up here.

So now we’re going to break at 21.

Let me just fix that.

21.

We’ll do a quit.

Make debug again.

And now we’re at 21.

If I say info registers, we can see R12 is that big value.

you, but we can also print R12 directly. And we should be able to print my thing one, hopefully,

has an unknown type, oh, we have to cast it. So we can do like basic casting in GDB. So I’m going

to say this is a character pointer. Remember, all of the assembly symbols are basically pointers,

unless it’s an EQU, EQU variable. In that case, it’s more of a define. So I’m going to print

and then it says error cannot access the memory add address

what the heck did i do wrong how about that cannot access that all right i’ll come back in

another video because this wasn’t something that i prepared for just to print strings in globals

i’ll come back at some later date in the future like five years from now and i’ll just show you

how to print globals but i hope if you’re in assembly you probably don’t need to worry about

You just have globals, but the real problem for you is going to be what’s inside of your registers and so forth.

You can also deref, I think.

Let me see.

Okay, I’m going to move on from that.

So anyway, we got a script and we got a lot of basic GDB commands.

Is there anything else that I wanted to show you?

Let me just look at my notes real fast here to make sure I’m not forgetting to say anything.

make sure I’m not forgetting to say anything.

So we’re going to do debug symbols, console, quit, attach to binary,

launching the program, uncaught exception, breakpoints, info, delete,

enable, disable, run, continue, end times, info registers, printing.

Oh, we can print a register in binary.

Forgot to show that.

So we are at a breakpoint, I think.

And if we printed R12 with the regular print, we can also do P slash T to just

p slash t to just sort of print it in binary if you want to i think i might have said that already

either that or i said that like a couple days ago to some and then we can do info locals and

then print a variable and then we get the script file and then we can quit okay so i think this is

pretty much everything that i wanted to show you you now have a basic idea of what we can do inside

of gdb but keep in mind there is so much more you can do in gdb than i can fit in one video

can type help and you can see a list of other major you know areas that gdb can handle um you

can do uh let’s see i think it’s help and then like we’ve got information on aliases breakpoints

data you know whatever we can do i think help breakpoints to see more information on breakpoint

commands yeah so all of the things you can do with breakpoints is like all of these commands here

one page we have to enter to see one more page or see to see all of the results without using

paging anymore so i’m just hit c and so there’s like you know we can save trace points we can

try to catch exceptions we can enable disable break points there’s like unwinders which i’ve

never even used we can bookmark things we can you know start tracing memory we can rethrow

variables so just keep in mind gdp is incredibly powerful this video barely scratches the surface

but for a programmer who is new to debugging i think this will be very useful to you i hope it is

anyway thanks for watching this video i hope you learned a little bit of stuff and had a

little bit of fun um i will see you in the next video rest yourself and take a nap and have fun

and hug your your loved ones okay I’m out see you later hey everybody thanks

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

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

please a small little favor could you please subscribe and follow this channel

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

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

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

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

videos in general so please do do me a kindness and and subscribe you know

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

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

That’s exactly what happens every single time.

So you could do it as a nice favor to me,

or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe, and then I’ll just wake up.

I promise that’s what will happen.

Also, if you look at the middle of the screen right now,

you should see a QR code, which you can scan in order to go to the website,

which I think is also named somewhere at the bottom of this video.

And it’ll take you to my main website,

where you can just kind of like see all the videos I published,

and the services and tutorials and things that I offer,

and all that good stuff.

things that I offer and all that good stuff. And, uh, if you have a suggestion for, uh, uh,

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

Or if you just want to say, Hey, what’s up, what’s going on? You know, just send me a comment,

whatever. I also wake up for those in the middle of the night. I get, I wake up in a cold sweat

and I’m like, it would really, it really mean the world to me. I would really appreciate it. So

watching this video and enjoy the cool music as I fade into the darkness which is coming for us all.

Thank you.

The post Master GNU Debugger: Debug C++ & Assembly Programs with GDB Like a Pro appeared first on NeuralLantern.com.

Hey everyone, let’s talk linkers! In this video, we unpack the general idea of linking in programming—taking your source code, turning it into object files, and stitching them into an executable. We dive into virtual memory, how programs use offsets, and why jump instructions matter across modules. Using simple assembly and C++ examples, we’ll show how linkers lay out modules, handle labels, and make function calls work. Whether you’re a beginner or a coder curious about what happens under the hood, this is for you! Hit subscribe, scan the QR code for more tutorials, and drop a comment with your thoughts or video ideas. Let’s keep learning and have some fun with code! #Programming #Linker #VirtualMemory #CodingExplained

Introduction to Linking 00:00:00
Compilation and Object Files 00:00:05
Linker Overview 00:00:32
Virtual Memory Explanation 00:00:42
Program Memory Offsets 00:01:18
Jump Instructions in Modules 00:02:54
Module Address Space 00:03:38
Assembler and Label Jumps 00:04:02
Linker’s Role in Module Layout 00:07:15
Function Calls Across Modules 00:08:04
Marking Labels as Global 00:09:31
External Function Calls 00:10:23
Data in Executables 00:11:12
Conclusion and Call to Subscribe 00:12:08

Thanks for watching!

Find us on other social media here:

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

Please help support us!

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

Hey there, I want to talk to you very quickly about the general idea of linking your programs.

In previous videos I’ve described exactly how to perform the linking stage when you’re compiling

a program. So you write some source code, you compile the source code into object files,

you know each file becomes one individual object file, and then when we’re done we take all the

object files and we link them up into an executable program. So I’ve talked about that

I just wanted to talk to you about the general idea of the linking stage in general.

Like what is the linker? What is its job? What is it actually doing?

So try to keep in mind for starters, each program uses virtual memory.

It uses a virtual memory space.

So obviously on your computer you have real memory,

but there’s lots of layers of abstraction between the physical hardware

the physical hardware and the program that’s running for starters the operating system uses

a paging system the memory stick the memory circuitry might be doing something else for

error checking or just you know transport or whatever so so try and bear in mind that each

program thinks that it’s it thinks that itself is kind of the beginning of memory you could imagine

it as each program thinks that its first memory location that it has assigned to it is memory

location zero but that wouldn’t necessarily be the case on the computer

your operating system probably would have come up with an offset let’s say

for example you know your computer decides to launch your program it

creates a process it finds a chunk of memory that’s available across you know

one or more pages of free memory and let’s say for the sake of argument that

the starting offset for the for the quote-unquote real forgetting the other

layers layers of abstraction the real memory location of your program is going

of your program is going to be let’s just say like a thousand I know that’s

real unrealistically too low but let’s just say a thousand and then let’s say

that your program then thinks that it starts at memory location zero that

means if your program wants to access memory location 100 then under the hood

at the last moment right before you actually hit the RAM stick or hit the

page file system a translation has to be performed so if your program is trying

what actually happens is you know the general offset for the entire program

gets added to memory location 100 and then that tells the computer or the

operating system that what you’re actually trying to do in your program is

access memory location 1100 so keep in mind all of this memory is virtual

and the modules themselves also need to know where to jump when I say where to

Well, suppose for the sake of argument, you have a program that has some jump instructions

or go to instructions or like some conditional branching instructions, anything where execution

is not just going to go to the very next statement.

Execution is going to go somewhere else.

Like maybe you have an if else block.

It’s got to maybe jump sometimes down to the else part instead of the top if part.

And then when it’s done executing, it’s going to jump until after the whole block, you know,

There will be lots of times in all of your programs where execution kind of has to jump

around somewhere if the program is even a little bit complicated.

So that could be a jump instruction, go to in a higher level language, not assembly necessarily,

jump if not equal and so forth.

So if you imagine writing one module, you could also imagine that the module has its

own virtual memory address space.

Just imagine it for now.

And maybe it starts at zero.

at zero that’s that’s not what we’re going to say but just like imagine the module only really knows

about itself and so sometimes when you’re jumping for example if we’re going to jump uh when

something is not equal to something else we’ll jump to some label and in order to jump to that

label the assembler needs to know you know where is that label inside of your source code so pretend

just for a moment this is not like a real assembly program but just pretend for a moment that we have

and maybe this is like I don’t know the main label that gets jumped into from GCC and

so then we have like a label down here outside and we’ll do stuff and then jump back to the

original point so we probably have to do a label here main finish this is this is bad form but I’m

So if we jump, let’s compare, I don’t know, one with two or something.

Let’s compare RAX to RDX and we’ll just move RAX the value one and move RDX the value two

so they’re not actually equal.

And then we compare them and then we say, all right, jump if they’re not equal to this label.

So definitely now we know, oh, we are going to jump down to that label.

So execution is going to go directly down to here.

we’ll do something and then eventually maybe we want to jump back so we’ll say uh

maybe let’s do it again let’s do let’s do like a whole set of statements again we’ll say jump

if it is equal and we’ll just like load those two registers so one and one and then compare

them and then say jump if it is equal to main finish this is not a video about conditional

branching or jumping i’m trying to make this as simple as i can but i hope you understand the

but i hope you understand the point is just basically we’re jumping around within the same

module right so it’s easy for the program to understand where to jump if it’s in the same

module or i guess the the object file when we’re assembling it it’s easy to understand where to jump

because if we’re at line 8 here when we start to jump and then the actual label here has its first

instruction at line 17 well then it you know the amount of instructions to move is just the

the difference you know so it’s easy to say all right if our virtual address is you know this

when we jump and we’re going to jump this much of a difference based on where the label is then now

we can just compute the new virtual address to jump or the absolute address or whatever you want

to whatever you want to do on that particular run but how does it know where to jump in another

module because when we assemble this module as an object file the assembler is only running one pass

one pass on just this object file it doesn’t really know the addresses in the other modules

it doesn’t know their offsets of its labels even if it’s a c plus plus or a c module it doesn’t

really know the offsets it doesn’t know where the functions start and end doesn’t know anything

because right now if we assemble this one source code it’s only going to know about this one source

code right and the same goes for the other modules if we compile a c plus plus program to an object

a function or you know do a go to statement or something into one of these labels from this

module the c plus plus program won’t really know where it is it won’t know what address it’s at it

won’t know the offset right so that’s the job of the linker the linker looks at all of these labels

and all of these uh conditional branching statements and jump statements and everything

and it just decides for starters it decides where each module is going to start in memory so maybe

I don’t know if your C++ module starts up here somewhere and then it’ll say this assembly module

starts right after it and then another module right after that and it’ll just kind of decide

where every module will start in the final executable that we’re actually linking together.

Once it decides the layout then it knows the offset of all the different modules and therefore

it can compute the additional offset that it would take to get to all the labels. So then at that

Your C++ module will make a function call inside of, you know, some assembly module like the one we’re looking at, assuming it was written a little bit differently.

Main finish return.

I guess the way it’s written down here, it’s returning to main if we just kind of execute it as we’re looking at it.

But another module could could call main finish as a function and still get a return statement.

That would actually work, even though it’s probably bad design.

that your assembly sorry your C++ program wants to call a function called

main finish inside of this module the linker having already laid out the

modules and and being aware of all their offsets it knows okay so you know this

assembly module it was underneath the C++ module so it’ll just take that offset

and add it to the offset of the label itself within the module and then also

add that to the the virtual address or I guess the operating system will do the

address. But you know, the point is the linker coordinates all the jumps and the conditional

branches where the functions start, lays out all the modules, gets all the offsets,

and then starts replacing all of the conditional branches and jumps and things with the real

offsets that make it actually doable. Like let’s jump to exactly this memory location

in code exactly in quotes, because we’re still using virtual addressing.

idea of the linker it knows how to jump between modules um wants to link or discuss okay that’s

all i really wanted to say don’t forget if you want a label to be available to jump into or to

call as a function from outside the module you got to mark it as global so if i actually wanted

somebody to be able to call main finish as a function i just have to mark it as global same

thing for some label if i say global some label then now at this point another module could call

call this as a function or jump into it probably bad form to not put a return a return statement

at this point which means when i’m calling it up here instead of jump not equal to i probably have

to add more complicated logic so i can use a function call that gets jumped around if it is

equal but so i’m not going to go that far right now kind of complicated just for this video

and then also of course if you intend to jump somewhere else remember that you have to mark

So let’s say there’s a function in your other module, your C++ module or your C module or your assembly module.

You just have to mark it as extern in the text section, in the text segment, like some other function somewhere else, something like that.

And then once I do that, now I could actually call it, I could say, call, you know, this.

Actually, that’ll never get reached because the jump equal thing is at the bottom.

equal thing is at the bottom but I could do this I could say call it if it was actually a function

or I could say jump if it was just a jump point or I could say you know jump not equal to

the other function instead of some label something like that so lots of stuff you can do and now you

kind of understand the idea of linking is taking all the modules stuffing them inside of the final

executable and also putting data inside of the final executable you know like if you’re creating

So, you know, like if you’re creating a string variable in your globals area of your assembly

program or hard coding, any kind of string anywhere in your C++, then it’s got to be

inside of the executable.

Otherwise, it wouldn’t be anywhere when we ran the program.

So, yeah, it sticks the data in there.

It sticks the segments in there.

It, you know, calculates the jumps and all that stuff.

I just want to point out you could put strings in a configuration file.

of a vanilla C++ or assembly program you probably are making strings directly in the program.

Anyway, so I think that’s the gist of everything that I really wanted to say about what is the

general idea of the linker. Thanks for watching this video I hope you learned a little bit and

had some fun. I will see you in the next video. Hey everybody thanks for watching this video again

it i do hope you did learn something and have some fun if you could do me a please a small little

favor could you please subscribe and follow this channel or these videos or whatever it is you do

on the current social media website that you’re looking at right now it would really mean the

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

videos longer videos better videos or just i’ll be able to keep making videos in general so please

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

because I know somebody subscribed or followed. It just wakes me up and I get filled with joy.

That’s exactly what happens every single time. So you could do it as a nice favor to me or you

could troll me if you want to just wake me up in the middle of the night, just subscribe

and then I’ll just wake up. I promise that’s what will happen. Also, if you look at the middle of

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

is also named somewhere at the bottom of this video and it’ll take you to my main website where

you can just kind of like see all the videos I published and the services and tutorials and

things that I offer and all that good stuff and uh if you have a suggestion for uh uh clarifications

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

say hey what’s up what’s going on you know just send me a comment whatever I also wake up for

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

I would really appreciate it.

So again, thank you so much for watching this video and enjoy the cool music as I fade into

the darkness, which is coming for us all.

Thank you.

The post How Linkers Work: Linking Code, Virtual Memory, and Module Jumps Explained appeared first on NeuralLantern.com.

Hey there! Ready to crack the code on IEEE 754 floating-point numbers? In this video, I break down how to convert decimals to binary and back for 32-bit and 64-bit floats with clear, easy-to-follow steps. From scientific notation to biasing exponents, I’ve got you covered with examples (like 45.84375!). Perfect for computer science students, programmers, or anyone curious about how computers store fractions. Pause, rewind, and learn at your pace! Subscribe for more, check my other videos, and drop a comment with your thoughts!

Introduction to IEEE 754 00:00:00
Prerequisites for Understanding 00:01:03
Steps to Convert Decimal to IEEE 754 00:02:31
Bias and Exponent Explanation 00:03:17
32-bit Float Layout 00:04:09
Sign Bit and Fraction Bits 00:05:44
Example: Decimal to 32-bit Float 00:07:56
Converting 45.84375 to Binary 00:08:34
Scientific Notation for Binary 00:09:05
Biasing the Exponent 00:10:26
Placing Bits in Layout 00:11:17
Final 32-bit Float Representation 00:13:32
Example: IEEE 754 to Decimal 00:14:28
Extracting Sign, Exponent, Fraction 00:15:36
Unbiasing Exponent and Reconstructing 00:16:23
Converting Binary to Decimal 00:18:53
Introduction to 64-bit Floats 00:19:47
64-bit Float Layout and Bias 00:20:05
Example: 64-bit Float to Decimal 00:21:09
Processing 64-bit Float Bits 00:22:05
Reconstructing 64-bit Scientific Notation 00:23:26
Final Decimal Conversion for 64-bit 00:25:00
Conclusion and Recap 00:25:54
Call to Subscribe and Outro 00:26:36

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 IEEE 754 floating point numbers stored inside of your machine.

What the heck am I even talking about? Well, uh, there’s a standard called IEEE 754 which governs

how floating point numbers are stored inside of your computer on x8664 machines. So, you know,

of watching this video you probably already know how to convert binary back and forth you know

between binary and decimal and hopefully you understand how to do binary with fractions

if you don’t i have other videos i’ll talk about that in a second and you also understand

that in the machine there is like a slightly different format that’s my doggy slightly

different format for storing signed integers in the machine okay so floating point numbers have

an even different uh format that we have to follow and the hardware is designed that way

hardware is designed that way so before we can really benefit you’re all gonna

see how bad I spell okay before we can benefit from this video your prerequisite

knowledge should be that for starters you should be able to convert back and

forth between binary and decimal including numbers with fractions so if

if you don’t know how to do that yet this video is is not for you just yet you

should go check out my other videos I explain in other videos exactly how to

do that go to the other videos come back and then check this one out after you

know how to convert back and forth between binary and decimal with

fractions the second thing you should know how to do before watching this

video is convert binary numbers with fractions to scientific notation and

and back again. Meaning you should understand scientific notation and you should also understand

how to take a binary number with a fraction and convert it to scientific notation and then

convert it or deconvert it back to like regular form. Again, I have another video for this,

so if you don’t know how to do that yet, you should probably pause this video and then go

Let’s see. For converting from a regular number to IEEE floating point number in the machine using just binary alone is the following.

So I’m going to say basic steps. Step one, convert the decimal number to binary if needed.

And I say if needed because I don’t know, maybe you started with a binary number so you don’t actually need to convert it.

it but I’m just going to assume that you have a decimal number so you’re going to convert it to

binary first then convert the binary number to scientific notation I don’t know if convert is

the right word here because we’re not actually changing the value of the number we’re just

changing the representation so convert it to a scientific notation form maybe would be better

step three we’ll add a bias to the exponents of the scientific notation form what do I mean by

notation form. What do I mean by that? You know, if you have like a binary number and it’s in

scientific notation format, it’s going to look like this. I liked when I’m doing IEEE 754,

I like to keep the right side of the number in decimal. I’m sorry if this confuses you, but

it’s not really necessary to convert this to binary when we’re just trying to convert back

and forth between IEEE. So I always say two to the something power rather than one zero to the

something power because I want to stay in decimal. So I’ll say, you know, two to the seventh power,

right? What this means is that seven is the exponent and I have to bias the exponent before

I put it into the machine. So maybe it’s worth understanding or maybe copy pasting right now

that the bias for 32-bit floating point numbers, I should probably, I’ll paste the whole thing here.

Okay. So here’s like the format for a 32-bit floating point number. We’re good about this

number. We’re good about this just for a second. The bias for 32-bit floating

point number in IEEE 754 is 127. So that means I pretty much have to just take

the number 7 and bias it by adding 127 to it. After I’ve done that I can convert

the biased exponent to unsigned binary whole number. To an unsigned binary whole

number. So step four here is just regular decimal to binary conversion. So I would take, you know,

seven plus 127. The result of that, which I think is like 134, maybe we’ll just be converted into

binary and unsigned binary integer, not two’s compliment or anything like that. Then step five

is respect the layout. So I just, I just copy pasted the layout up above and the layout is this.

you can see that here let me see if I just maybe paste this down at the bottom

you can see that we actually have 32 bits here if I count them for you real

fast we’ve got one for the sign and then we’ve got I can never remember this I

think it’s eight for the exponent one two three four five six seven eight got

eight bits for the exponent that means I’ve already used nine of 32 bits so

that means I should have like 23 bits here so one two three four five six seven

11, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 23, just to double check.

So we know what the sine bit is.

Actually, we don’t yet know in this video.

So in this video, the sine bit, it’s always going to be a zero if the number is positive

and a one if the number is negative.

So that’s the sine bit.

The biased exponent bits go there.

And then these Fs, those are just the fractional bits.

just the, you know, like the mantissa or the mantissa part of the fraction. So imagine if we

have a number like this, all I’m saying is we would copy paste those numbers right here.

Notice how I’m ignoring that first one dot something, because when you put binary in

scientific notation, the first number is always going to be a one. So it can be assumed. There’s

no point in storing it inside the machine. And then if you don’t have enough digits to

you will literally just pad with zeros on the right side because padding with zeros on the right side of a fraction

doesn’t actually change the value. One, two, three, four.

If I put the zeros on the left side of the fraction, it would make the fractional part smaller and smaller.

So that would be bad. I don’t want to change the value.

And this is the opposite of how you pad a whole number.

If I put numbers on the left side of a whole number part, I’m not changing the value.

But if I put numbers on the right side of a whole number part,

which in this case would be the biased exponent, then I would be changing the value.

So we wouldn’t want to do that.

changing the value so we wouldn’t want to do that. Anyway I’m going to remove this and just stick

with step five so let’s see 5a is place the sine bits step 5b is and I’m going to do an example

for you don’t worry place the exponent bits and then 5c is place the fraction bits everything

the first one dot from scientific notation form.

Again, because the first one is implied, it will never be a zero if you’ve done it correctly.

If you end up with a binary number that looks like this in scientific notation, then you’ve

done something wrong because the first number is supposed to be a one.

Okay, so we have those basic steps.

And now let’s do an example.

1, 2, 3 example. Let’s convert decimal to IEEE 754 32-bit float format.

AKA single precision floating point number. Double precision floating point number is 64-bit.

We’ll do an example for that at the very end of this, but I’m just going to stick with 32 and do

number 45.84375, just double checking, and then we’ll convert to binary. Again, this knowledge

is contained in a different video. So if you don’t know how to do this yet, you’ll need to go see my

other video. And so you can see it’s, you know, 45.84375 in binary is just going to be this.

I’ve padded it with two zeros to the left just because, I don’t know, I have a habit of wanting

wanting everything to look like it’s inside of 8-bit chunks.

You can see there’s 8 bits here.

But really, I can just remove those first two numbers.

It doesn’t matter.

Convert the number to binary.

Then, I have to convert the binary number to scientific notation.

I’m going to put maybe pseudo-scientific notation

because I’m not going to convert the right part

where it’s the exponent into binary.

I’m going to keep it in decimal.

Just to clarify again,

convert a binary number to scientific notation and you were actually going to publish it somewhere

or give it to someone, then you should convert the right side. It’s just that I’m not going to

because I don’t really need to convert the right side. I’m not interested in having the whole

number in scientific notation in binary. I’m just interested in what the fractional bits are and

then what the exponent is going to do. Like how many positions to the left or right is it actually

going to move the decimal point? And that’s just going to be the number five, five times to the

five you know five times to the left or to the right so I’m gonna go pseudo

scientific notation you pretty much you know as I covered in the different video

all we’re gonna be doing is just moving the decimal point over one two three

four five until there’s a one in the leading spot and then account for it by

saying times two to the fifth power to say the number is a lot bigger than it

looks so that’s that and let’s see if there are any trailing zeros that’s

Let’s see if there are any trailing zeros, that’s okay on the right side of the fraction.

They don’t actually matter.

You can also just delete them if you want.

Then we need to bias the exponents.

So how do we bias the exponent?

The exponent is just the number five.

That’s see, I was telling you like I don’t really care to convert it to binary because

I’m just going to bias it first and then after that I’ll buy it or I’ll convert it to binary.

So biasing it is just basically adding the bias.

just to make sure that it’s on this page and it’s easy to see.

So I’ll do that.

So in the 32-bit float layout, the bias is 127.

So I’m going to add 127 to 5.

The final number is going to be 132.

So that’s the biased exponent now.

Then I convert the biased exponent to binary.

And that’s going to be this.

10000100.

Then set up the layout so you don’t get confused.

This step is crucial.

Everyone always gets confused by the layout because like we’re human beings.

I can’t count 32 zeros that are all like in the same area and like, you know, and not

get confused every single time.

I mean, I guess I won’t get confused half the time, but that’s not good enough.

So step one is place the layout for yourself so it’s easier for you to place the bits.

place the bits and I wrote this at the top 8 bits and 23 bits just as a reminder double check

yourself 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 1 2 3 that’s 23 bits 1 2 3 4 1 2 3 4 that’s

8 bits we don’t need to remember that the sign bit is one bit for now it’s not too hard so now

let’s place it so the first thing to note is that this number was actually positive positive is

the negative sign there, but if it makes you feel better, we’ll just put a positive sign there just to clarify and be specific.

So because the number is positive, the sign bit is going to be zero. If it were negative, it would be one.

Then we will put the biased exponent bits. So we already converted up there. So I’m just going to copy paste it here.

We’re pretty lucky that the bits are just as big as the number of biased exponent bits that are available.

But suppose for the sake of argument that we had,

the sake of argument that we had just like you know this small number here for the biased exponent

what would you do with the remaining spaces you would just pad with zeros to the left

because remember in whole numbers in binary and decimal you pad to the left you’re not actually

changing the value you definitely would not want to pad to the right but you got to put

a bit in every position it’s got to be something so i’m just going to pad with zeros

then we take the fractional part from the scientifically notated form so that’s just

form so that’s just this right here notice how I’m copy pasting every bit

except for the one that starts the number I’m not going to do the one dot

part because that’s always assumed so we don’t need to store it it wouldn’t make

sense I’ll copy paste the fractional part and I’ll just stick it down there

and now we have a bunch of leftover bits that we need to fill out with the

fractional part you pad to the right not to the left so I’m just going to put

zeros to the right because that won’t change the value of the fractional part

Now we’ve got it. I’m just going to double check my work here.

Oh gosh, it’s too hard to read and then a bunch of zeros. Okay.

Then remove these spaces because now that you’ve done your layout,

you actually want to bear in mind that the machine doesn’t have spaces.

The machine is just, you know, a bunch of ones and zeros everywhere.

So I’m just going to carefully remove the two spaces.

And this is it.

for floating point representation of the number of the decimal number positive 45.84375

seems like a lot but it’s not too bad once you kind of get used to the format

and the bias and you already know the other steps of you know converting decimal to binary and back

again so let’s do another number let’s do it backwards so i’m going to open up a new tab here

example, IEEE 754 32-bit float 2 decimal.

Okay, so suppose we started with the following number.

Start with this number.

Oh my gosh, right?

Remember the layout.

So in the layout we have, use the layout.

Maybe I should copy paste the layout again one more time just to make sure that it’s

easy to see.

it’s easy to see. So I’m going to paste it up at the top and well, no, maybe I want this because

this is like a little bit better. I want that version. Okay. So 32 bits, a bias of 127. So

we’re going to use the layout. I’m just going to copy paste the original number and then add

spaces because I know, well, I guess I can copy paste the layout itself right above that number.

I know I need a space right there that’s the sine bit and then I need a space

after that and notice how the numbers all line up so there’s nothing missing

just to double-check yourself okay so I have the layout I know right away that

the number is going to be positive because the sine bit is zero sign is

positive okay so then I need to pull the biased exponent will be biased

the exponent bits only so I’m just going to copy paste those bits and then I’ll

pull out the fractional part first pull out the fractional part I’m going to

copy paste all those bits and maybe I’ll just say zero point those bits because

that’s what I originally grabbed and I can delete all the zeros on the right

side because again that won’t change the value of the fractional part so I’m

going to delete make sure you’re only deleting zeros though delete that now I

I need to unbias the biased exponents.

First, actually, I should, well, let’s convert the biased exponent to decimal.

A little easier.

I guess you don’t have to do that, but it’s a little easier for me.

Pull the biased exponent.

So this number is going to be 132, which I think is what we had last night.

Let me just double check that.

132.

Yeah.

132, yeah so the biased exponent that we pulled out is 132 then we unbiased the

biased exponent so just subtract the bias again in 32-bit format here the bias

is 127 so I’m going to subtract 127 instead of adding 127 so now I know the

real bias or sorry I know the real exponent is 5 then I can recreate the

I’ll put sudo here just because it’s not, you know, I’m not, I’m not converting binary for,

for the entire thing. So that means I can take the fractional part here and I can say it’s going to be

one dot the fractional part. Maybe I should remove that zero here to make it less.

I don’t know. Cause if I put a one there, it kind of feels like I’m saying the number is

that it’s one dot something.

I don’t like that I’m putting a zero there.

I’m just gonna erase it

because it’s really gonna end up being a one.

And if I say pull the fractional part

and I put a one there,

then it doesn’t it kind of sound like

I’m pulling the one from somewhere?

No, the one is implied.

Anyway, so now I can recreate the number

in pseudo scientific notation.

I can say times two to the something power.

We know that the exponent is five.

Again, it’s pseudo scientific notation

because if five we’re gonna do the complete,

complete, you know, true scientific notation. The right side should also be in binary, but I’m not

going to do it. I’m a little bit lazy because we don’t need that IEEE. So it’s going to be two to

the fifth power. Then if I undo the scientific notation, I’m really just going to take this

scientifically notated version and I’m going to say, well, I’m going to move the decimal point to

the right five times because that’s what the part on the right says. So I’m going to go one, two,

1, 2, 3, 4, 5, stick it there, remove the original decimal point, and then I can remove

the exponent part. So then let me just double check my work. 1, 0, 1, 1, 0, 1, 1, 1, 0, 1. Okay.

So we’ve got that now. Then all we have to do is convert this number from binary to decimal.

The final number here is just, you know, it’s going to be the same number that we worked with

number that we worked with previously so I’m just going to copy paste it there is

you know of course this video is not about converting back and forth from

binary to decimal with fractions check out my other video if you want to learn

how to do that but once we do that you know this number becomes that number

and and now we know how to convert back and forth between a decimal number and

for 32-bit floats in the machine.

No problem.

A lot of steps, but no problem once you understand them.

Okay, now let’s do an example

with 64-bit floating point numbers.

Honestly, this is not gonna be more difficult.

In 64-bit floats, the idea and the format and the steps,

it’s all gonna be the exact same thing.

It’s just that we have more bits

for the biased exponent and the fraction,

and then the bias itself will be a little bit higher.

So let me copy paste the format for you to see.

at for you to see. So in IEEE 64-bit floats, IEEE 64-bit float, well IEEE 754, 64-bit float,

you know we refer to these floats as doubles right double precision floating point numbers.

Notice how instead of 8 bits for the biased exponent we have 11 so we can represent a much

notice how for the uh the fraction part instead of having 23 bits we have 52 bits so we can also

represent much more precisely that’s really the only difference let’s uh oh sorry the other

difference is also that the bias is now equal to 1023 instead of 127 so what is that like

10 times larger of a number that we can represent or something like that so mostly we get more

If you don’t like it, sorry, it’s the way it is.

It’s in the hardware.

So let’s do an example for a 64-bit float for a double.

64-bit example.

Let’s say we started with the following number.

Inside of the machine.

Like we looked inside of the machine and we grabbed these bits.

And I’ll get rid of the spaces.

So we have like a giant, big, huge number.

We have like a giant big huge number.

We’re trying to figure out, you know, what is this number in decimal.

So I’m going to add spaces to respect the layout.

I’m going to just copy paste the layout right here.

I’m going to say respect the layout.

I’m going to paste it and then that helps me line everything up.

So I’m going to say the sine bit is the first bit and then I’ll put a space there so I know.

All right, the sine bit is a one.

That means it’s going to be a negative number.

The biased exponent bits are there.

The fractional bits are there.

bits are there so well first thing I can just do is say that the sine is going to be negative

because the sine bit is a one

and then I’ll pull the biased exponent bits which is going to be this number right here

should pull the fraction bits next. Fraction bits are just here I’m gonna

copy paste those here and then I can remove the zeros. Be very careful you’re

not removing any ones. So there was a lot of wasted bits there. That’s okay. I’ll

convert the biased exponent to decimal. So that’s going to be…

I think and I did not do that in my head.

I have an answer sheet.

Don’t worry.

I’m not that cool.

Then we’ll unbiased or de-bias unbiased the biased exponents by just subtracting the bias.

Remember in this 64 bit format, the bias is 1023.

So that means I got to take 1031 minus 1023 and that will be equal to 8.

Okay.

Okay, now we kind of have everything we need to sort of reconstruct the scientific notation part, right?

We have the fraction bits, that’s the most important part.

Oh, and then also the sine bits.

So I can say negative something.

It’s obviously going to be one dot something because even though the number is negative,

it will still always start with a one.

That rule doesn’t change.

Negative one dot something and I’ll just paste the, whoops, paste the fraction bits.

I think I did paste the right thing.

right thing so we paste the fraction bits and then we have to use the regular exponent the

unbiased exponent the non-biased exponent two times times two to the oops times two to the eighth power

now this is our number in scientific notation um

convert to scientific notation i’ll put p for pseudo scientific notation

and then now we have to convert to just regular format okay so I’m going to

copy paste this right here and if it’s 2 to the eighth power that means the real

number is going to be bigger than it looks in scientific notation even though

if you are very familiar with scientific notation you kind of already know that

it looks big but you know if we just if we’re only talking about the bits on the

1, 2, 3, 4, 5, 6, 7, 8.

Put the decimal point there.

Remove the original decimal point.

Now we no longer need 2 to the 8th power.

And again, just as a reminder, if it was 2 to the negative 8th power,

you would be moving the decimal point in the other direction.

So now we’ve got this number 111, 010101, 0101, 0101, 0101.

Then a 0.01.

Okay, so then convert to decimal.

doesn’t talk about how to convert back and forth from binary to decimal find my other videos but

basically uh it’s going to end up being six uh negative four six nine point two five

okay we now have done a quick practice starting with a giant number of bits and slowly converting

them to the real uh floating point number in decimal that uh that they represent i’m not going

going to do another number in the reverse direction because we already did that for 32 bits

and again with 64 bits the only real difference is just you have more exponent and fraction bits

and the bias is a higher number and that’s it so like all the other steps are just the same

I just wanted to show you one time with a 64-bit number in one direction but

I think at this point we’re good thank you so much for watching this video I hope you learned

had a little bit of fun. I’ll see you in the next video.

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

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

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

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

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

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

just wake up I promise that’s what will happen also if you look at the middle of

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

to the website which I think is also named somewhere at the bottom of this

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

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

offer and all that good stuff and if you have a suggestion for clarifications or

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

say hey what’s up what’s going on you know just send me a comment whatever I also wake up for

those in the middle of the night I get I wake up in a cold sweat and I’m like it would really it

really mean the world to me I would really appreciate it so again thank you so much for

watching this video and um enjoy the cool music as as I fade into the darkness which is coming for us

Thank you.

The post Master IEEE 754 Floats: Binary to Decimal Guide appeared first on NeuralLantern.com.

Ready to conquer binary scientific notation? Let’s make it fun and simple! In this video, I walk you through how to represent binary numbers with fractions in scientific notation—a must-know skill for computer science, programming, and understanding IEEE 754 floating-point representation. We start with the basics of scientific notation in decimal (think 8.54 × 10⁵), then dive into binary with clear, step-by-step examples. You’ll learn how to handle large and small binary numbers, move decimal points, and use base-2 like a champ. Whether you’re a student, coder, or just curious about how computers process numbers, this video has you covered!

I’ll show you practical examples, like converting huge binary numbers and tiny fractions, plus tips to avoid common mistakes (like mixing decimal and binary notation). By the end, you’ll be ready to tackle binary in IEEE 754 or impress your friends with your number-crunching skills. Subscribe for more tech tutorials, and hit that bell to stay updated! Visit my website (link below) for more resources, and leave a comment with your questions or video suggestions—I read every one! Let’s keep learning and having fun with tech together!

Introduction to Binary Scientific Notation 00:00:00
Purpose of Binary Representation 00:00:12
Overview of Scientific Notation 00:00:41
Rules for Scientific Notation 00:01:12
Decimal Scientific Notation Example 00:02:26
Practice with Large Decimal Number 00:04:12
Practice with Small Decimal Number 00:05:21
Binary Scientific Notation Concept 00:06:32
Binary Number Representation Rules 00:07:28
Large Binary Number Example 00:08:24
Small Binary Number Example 00:09:31
Mixing Binary and Decimal Notation 00:12:54
Pure Binary Scientific Notation 00:13:04
Connection to IEEE 754 00:13:48
Conclusion and Call to Action 00:14:21
Engagement and Website Promotion 00:15:32

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 representing binary numbers with fractions in scientific notation.

Why would you need to do this? Probably the best use that I can think of off the top of my head

is being able to represent binary numbers with fractions inside your machine in a format known

It’s just a crucial step before you can represent numbers inside your machine using IEEE 754.

Okay, so first off, let me just show you a little bit here about scientific notation.

So you probably have seen something like this before where it’s like 8.3873,

and then you’ll see like a multiplier times 10 to the fifth power, right?

I can’t really type this out very well, so maybe I could just draw it for a second, you know.

well so maybe I could just draw it for a second you know 8.54 times 10 to the fifth power right

that’s what I’m trying to convey but anyway so about scientific notation itself it’s standardized

so that it’s easier to use and that is you know it’s just like faster for everyone to understand

and there’s less confusion part of the standard is that you always want to have a number on the

that is between 1 and 9 inclusive. You don’t ever actually want to have a 0 there that would be bad.

You don’t want to have a 10 or anything greater that would also be bad. You just want to have

1, 2, 3, 4, 5, 6, 7, 8, 9 on the left side. And then on the fractional side,

you want to have a number that just kind of like helps you represent the entire

original number without losing precision. And then on the right side, you want a number,

a number, let’s say like x to the y power, where x is the base of the number system you’re working

in. So this is decimal. The base for decimal is 10. So we’re going to say 10 to the something

power. What is the power? The power here helps you understand how big or small the number on

the left really is. That’s kind of one of the benefits of scientific notation. It seems to

help you understand a little bit more of how big or how small a number is rather than exactly

than exactly down to you know the last digit what what is the number precisely so we could say for

now it focuses more on largeness or smallness than preciseness what number are we actually

representing with this in scientific notation well times 10 to the fifth power just means move the

decimal point over a certain number of times so uh you know that’s why we have 10 to the something

go left or right in a base 10 number you’re looking at a different number that has a factor

of 10 for its strength in either direction like multiply by 10 multiply by 10 multiply by 10

or divide by 10 divide by 10 divide by 10 in the other direction so this means we want to move the

decimal point five times to the right to increase the strength of the number times five so one two

three four five if we put the decimal number there then this is the number we were going to represent

number we were going to represent originally so if somebody says hey give me this number 838730

and put it in scientific notation then you your first instinct is to say all right let’s uh type

that number out and we’ll put like a dot zero there and it will just we’ll move the decimal

point over until there’s only one digit um and it’s a you know somewhere between a one and a nine

three four five times over in order to get the decimal point there so that

means it’s going to be this times 10 to the fifth power because we moved it over

five times and you can see that’s the original number that I showed you these

zeros at the very end they don’t actually mean anything so we can omit

them probably a smarter idea to omit them and that’s why we see numbers that

way okay so keep that in mind there’s only one digit let’s maybe do like

practice number here I have a couple practice numbers written down already

let’s see so we’ll start with this number a huge gigantic number just to

practice if we copy paste this down to the next line and then we decide all

right how many times do we need to move the decimal point to get the decimal

point right there so that the two is the first number remember one to nine

inclusive so I’ll just I’ll use two decimal points so I can count more

9, 10, 11, 12, 13.

So that means I did 13 moves.

I’ll put 13 right here so I don’t forget.

Times 10 to the 13th power.

And the 13 is positive because when we’re looking at the scientifically notated format

of the same number, you know, 2 point something is way smaller than the original number.

So we want the scientifically notated format or form to get bigger in order to reach this

number.

in order to reach this number so that means 10 times sorry times 10 to a positive number positive

means it’ll be bigger in its original form okay so now let’s do another practice number

let’s do a number that’s really really really small like you’re inside of inner space or

something so we start up with this number and we still want to have a number between

rewrite it here I really want to have eight point something because that’s the first number that’s

bigger than zero that I can see so again I’m using two decimal points so that it’s easy for me to

count I’m going to go one two three four five six seven I had to move it seven times so it’s going

to be negative seven is going to be the exponent so you know raised something raised to the negative

seven it’s still going to be 10 to the negative seven that I multiply it by so then I’ll say get

And now this is the same number represented in scientific notation.

It should have all the same digits.

The decimal point basically should just be moved.

Of course, you know, when you represent in scientific notation,

depending on what standard you’re working with,

you might actually omit some of the numbers at the very end of the fraction here.

But that’s why we say this is kind of more to impress upon you the smallness or largeness of a number

rather than represent the number exactly precisely.

okay so we got that two practices in there how can we do this same exact concept in binary

well keep in mind in binary binary is a base two number this video is not about binary conversion

as a whole number or binary with fraction let’s just pretend that we already know how to do that

and we have a binary number to start off with so let me grab my example number here

have some kind of a binary number with a fraction, which you can do if you don’t understand how to do

this part yet from decimal with a fraction to binary with a fraction or back and forth.

See my other videos. For now, we’ll assume you can do this. So how can we get this in scientific

notation? So the first thing we have to understand is that it’s going to be, you know, some number

right because that was the format we used before the number should only start with a one it should

never even start with a zero remember in binary we can only use ones and zeros before i said here

let me just show you this real fast again before i said the starting number has to be one through

nine inclusive that was because in decimal we have zero one two three four five six seven eight nine

be only use you know one two three five six seven eight nine so but in binary um i’ll put like

a character set like the available characters we can use to represent the numbers in decimal

so in binary the care set that we can use is just you know a zero and a one only but the same rule

the one so that means the first number always has to be one it has to be always one dot something

for our purposes to represent the same number in scientific notation so it’s going to be

this and obviously that one has to be it it cannot ever be a zero so i’m going to put the

decimal point there uh and then i’m just going to count like how much did i actually move the

seven eight nine ten eleven twelve thirteen fourteen fifteen six just fifteen just fifteen not

sixteen so i’m going to put times something to the fifteen power and remove that other decimal

point and then the base is two so it’s going to be two to the fifteenth power

so now maybe i should move that up a little bit

gigantic number uh in scientific notation it’s going to look a little smaller but then the times

base to the 15th power is going to help us understand how big it is oh it’s like pretty big

let’s do the same thing backwards let’s say that we wanted to start off with a very very small

number so it’s like you know a zero point something in binary so you can imagine if this is like one

256 that’s probably going to be a number that’s no bigger than or just like slightly bigger than

256 so it’s going to be like kind of a small number right well we’ll do the same thing just

copy to another line and then make sure that the decimal point sits in a place where there’s always

a one at the start

and then just count the number of times you moved

number of times you moved the number oh I guess before we would have possibly

deleted numbers on the right if we were gonna reduce precision in this case

after we count the numbers we’re gonna remove everything to the left of the one

so that the one is in the first position and I’ll just go ahead and do it okay so

how many times do we move it one two three four five six seven eight that’s

eight times so I’m gonna put an eight there just to remind myself that there

will be an eight I’ll remove all the stuff at the beginning that doesn’t

all the stuff at the beginning that doesn’t matter anymore and it’s going to be times two because

that’s our base to the eighth power but the original number is a lot smaller than the

scientifically notated number looks so that means we have to put a negative eight because remember

when you say times let me just show you this on a calculator when we say let’s let’s go back to

fifth power then you know that we’re just basically adding four zeros right so

like we have five total zeros so we’re adding four zeros to the ten but if we

did to the negative five power we’re gonna be like dividing it by ten a bunch

of times so instead of multiplying it by ten for a total of five times we’re

gonna divide by ten so then the number gets really really really small so that

means when we say two to the negative eight power we’re gonna be dividing it

We’re going to be dividing it by two that many times.

And so we end up with a really, really, really small number.

Isn’t that what I kind of said?

Let’s see.

I mean, like, not exactly, but, you know, it’s like 0.003 and then some numbers after that.

Didn’t I say one divided by 256?

It’s 0.003 and then some numbers.

So this number is just a little bit bigger than 0.003.

Nine.

Let’s see how much bigger it is.

bigger it is point three six two five what

oh because i’m not i’m not including the the part on the left that we will multiply it by so if i

you know if i did some like binary up here and i was in binary mode then it would probably make

more sense it ended up being exactly the same exact number that’s why i was confused because

if we just type that part on the right side then it really is going to be one over 256.

Anyway, long story short, we have this number here, the fractional part, and then we’re

going to multiply it by two to the something power.

Notice something in particular that I’m doing, which is probably my mistake, but I kind of

like doing it this way.

Notice how the left part is in binary and the right part is in decimal.

There’s no number two in binary or no number eight in binary.

numbers like this to scientific notation so that you can convert a binary number to i triple e

floating point number this is as far as you really need to go but if you truly want to represent a

binary number in scientific notation then you should also convert all of the relevant parts

so how do we represent uh the number two in binary it’s going to be one zero how do we represent the

number eight in binary it’s going to be one two four eight it’s going to be that so uh you know

big number times 10 in binary is still the number two to the something power the negative 1000 in

binary power is going to be you know eight the negative eight power so this is great if you just

want to write an entire number in scientific notation but uh you know in probably my next

video when we talk about ieee 754 notation this is as far as you really need to go

eight number into a a whole number in binary and then putting that somewhere but so just

forget about this for now keep in mind this is how far you have to go if you want to go to ieee

if you only want to be in pure binary then this is what it would look like

okay that’s it uh i think that’s all the example i have for you today in this video thank you so

much for watching i hope you learned a little bit and had a little bit of fun 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.

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

do do me a kindness and and subscribe you know sometimes I’m sleeping in the

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

followed it just wakes me up and I get filled with joy that’s exactly what

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

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

subscribe and then I’ll just wake up I promise that’s what will happen also if

If you look at the middle of the screen right now, you should see a QR code, which you can scan in order to go to the website, which I think is also named somewhere at the bottom of this video.

And it’ll take you to my main website where you can just kind of like see all the videos I published and the services and tutorials and things that I offer and all that good stuff.

And if you have a suggestion for clarifications or errata or just future videos that you want to see, please leave a comment.

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

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

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

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

Thank you.

The post How to Master Binary Scientific Notation (with Fun Examples!) appeared first on NeuralLantern.com.