"My whole life is a lie..."

@Metros

The only reason I knew it was an interrupt, was because I was playing along with a tutorial writing a simple debugger. Interrupt vector/value 3 is then used

@Metros *cries in python*

Same here lol

Xd

Still better than developing android apps

@@molamola5260 ikr dude

*TL;DR:* It may be easier to learn this by going _forward_ into the abstraction, instead of unraveling our current abstractions _backwards._ *Longer:* Nudge: Not _hard_ but _more specific_ ; assembly is easy when taken as an abstraction of the more tedious. Before assembly (of programs, containing opcodes), programmers flipped a bank of 8 physical toggle switches followed by a [SAVE] switch...per instruction. Desirable switch combos were given "op[eration]code" names so we didn't have to remember all the binary on/off states...then we punched holes in cards (tinier switches fell through these "saved" programs...then light did)...then we saved our physical switch architecture into logical (not card/switch-based) programs...etc. But inside, deep down, it's all still switches: e.g., MOV is 10111000 ... and (my point is coming) did you know: 1 and 0 don't actually mean "on" and "off" -- they represent voltage levels! .......... Oh, not excited by that? Good! This should feel like the naturally appropriate hardware/physical layer to venture _forward_ into assembly's abstractions, not backwards into the specific physics of electrical engineering. (hope this helps)

As for me, when i was using MASM, it was a little bit harder to write "Hello World!"

i thought exactly the same thing, cool though

a man of many talents

may be trying to write song in a diff lang

I'm in love with the shape of C We push and pull in a assembly Although my system is falling too I'm in love with your CPU

@@user-vm1hi7bo5s wow thats hilarious xD

Lmfao

The voice and even the laugh of Seth Rogen too.

oh god now I’m gonna see him like that

true lmao

I CANT UNSEE THIS

That''s the most fitting description for this language.

@@fabiorodrigo3638 no that’s a better description for the brainfuck programming language, at-least assembly *can* make sense.

@@a8552bc brainfuck isn't even low-level. it was just meant to bring pain.

@@computer_dude nothing but *p a i n*

Assembly can be really neat if you get it to work, improve a compiler or Interpreter and know you made the entire world a little bit better than befor.

Assembly knowledge is the foundation of all modern programming in my mind, you need to learn it at some point

assembly- is...... like java- a waste of your soul i tried a week iof programming in it and i couldnt understand the basics of fucking hello world in that god forsaken language XD

@@re43p3raod3 I mean It's not like you are going to make apps with it tho. it's also useful for debugging.

@@AhmedMahmoud-tv9vw its now been two weaks since i have been programming this language and well, later to find out its good for hardware thats it you cant apps but i will admit its good for that at least debguing and hardware information

@@re43p3raod3 Java's Hello World is just as simple as every other language y'know that right

why you want to learn it?

@@faridrzayev5093I think it will make me a better person....just kidding. I am a programmer but never had the chance to get in to it in professionally, I think learning assembly will give me a totally different perspective on programming

@@conejohh i installed virtual enviroment with win7 32x and spent 3-4 monts intensively learning assembly and give it up,,just dont want others to make same mistake, spend your time to learn valuable things to become real professional

@@faridrzayev5093 Why did you quit?

I guess the knowledge is really rare I guess...?

...btw

Why? It's very user friendly and very common.

@@najtofnin2009 :D

BTW. Did you know? I use arch too.

Arch sucks

You saw through is clever weight loss and name change! -Seth- John, if you need a better placement, please reach out to us. You know who we are.

i thought he was ed sheeran

​@@Max-db6hq Every KZfaq comment thread has the following: 1) Funny comment 2) Funny follow-up comments 3) A rude comment that doesn't get the joke or pretends not to

@@TFDUDE123 3) Chicken little with Seth Rogan voice, weird

I scrolled to the comments looking for this! Mr. Hammond doesn't only look like Rogen, but sounds like him too!

@Steven Tsakiris Thanks for your kind words!

@Steven Tsakiris In C, is like having two members of a structure one after the other and substracting the offsetof each one of them. Gives you the length. en.cppreference.com/w/cpp/types/offsetof

thanks for the explanation. Never a fan of "this is some weird syntax, deal with it without explanation"

@@Frazzer951 but... But... The entire universe exists just so I don't have to google something X'D

@@Frazzer951 to be fair, google isnt great for weird syntax search

Binary: *Y E E T*

@@dizzlemaker9504 My time has come... *_Y E E T_*

Glad I'm not the only one making the "why does this look exactly like python" observation.

"How high are you"? Me: 1

@Divyansh Singh they literally don't even compare.

It is 7 instructions and 10 more for the data so more than 17 instructions can you do this in higher level than assembly . You cannot with out a library

I used to do that in Z80 assembly language!

hold my python

@@lauriekimani your python just bit me :(

@@lauriekimani lmao Python is now transcending High-level it's slower than most high-level languages but has simpler syntax

You're absolutely correct, except a compiler is (usually) used for translation of higher-level languages to ASM or machine code. So since ASM obviously doesn't need to be translated back to itself, it just goes through an assembler (which is essentially a compiler specifically designed for ASM) to machine code and the rest of your list. :)

TLDR: Assembler

@@user-bo5vr1ib6i it is still a compiler. a very simple one, maybe even one-pass, mnemonic 1:1 instruction language

@@bernardcrnkovic3769 As far as I have been able to find, there are different opinions on this. I've usually heard the definition that an assembler is a translator for assembly to machine code, and a compiler is a translator for high-level languages to machine code or any intermediate and that these definitions cannot be mixed. But I've also heard a definition that matches yours, where an assembler is just defined as a compiler for assembly. I think we can both agree on your definition :)

Modern compilers don't typically transform to assembler. They create a syntax tree which they then generate machine code from. Compilers are much more advanced than assemblers. I could write an assembler in an afternoon practically, while a fully featured compiler would take several weeks or months to complete. You don't have to worry about stacks, variables, scopes, or any of the other stuff that high level languages abstract to. It's one line equals one instruction (usually). The same can't be said for a higher level language. A single line of C code: printf("Hello World!"); generates about what we just saw.

Lots of old Games were coded in assembly. Assembly is super light weight and was necessary for the time.

​@@crashniels Except RT and RT2 were published in 1999 and 2002. Quake, which was written in C (mostly), was published in 1996. Chris Sawyer is absolute madlad to write a game in assembly in those times! Then again, the game ran as smooth as butter!

@@crashniels Have you seen Roller Coaster Tycoon 2? Its a feat of near super human levels.

Think of this: Lotus 123 (for those of a sufficient age)was entirely in assembly.

@@KnightPlaylist the game holds up strongly even today literally a masterpiece

Thanks for the kind words! I'll try and keep some more of these coming!

yeah like at the end I'm just thinking "who the fuck would EVER want to use that?" like freaking 10 lines of code to print hello world translates to literally one in python

In assembly language programming, however, you are working directly with the processor's instruction set and other high level language are child can't do anything directly for controlling pc or any things you want than assembly language it is between machine language and high level language I hope come the day and learned it 💪

@@grahamhart4972 you use assembly when you need very refined control over the hardware or when you need to make very specific optimizations to make your code run faster/use less space. I don't know how it is nowadays, but some years ago in the game industry programmers had to optimize their codes with assembly to make them run smoothly. The game Crash Bandicoot for PS ONE is a nice example: kzfaq.info/get/bejne/n-Coi6qmu7KWYaM.html

the more skills, the more powers

I actually liked asm even more after this video

Awesome! Happy to hear that! Thanks so much for watching!

Ssd: |kl

huge respect to you programmers of old who did the hardwork for computers, us newer gen are so used to abstracted languages that we forget to apprecite all the work you did for us when you had to program using a switch.

Good old 6502. I started there as well (two years ago!)

@@williamdrum9899 heh, not hard to tell that I was on the 6502

Kids have it so easy these days, with their multiple registers, VIMs, and NASMs. haha :-D

It's been 1 year since your comment and I'm sure you're even better at explaining things but that was a fantastic explanation!

Thank you

That makes a lot of sense!

Some assemblers use *

Correct, that's why it's very important to calculate length right after declaring the string

@@69k_gold I was wondering why is it necessary to know the actual length of string...... In this video, John didn't displayed the string length so, I was wondering why he had the need to know the length of the string?

@@godslayer1685 you specify the length so the sys call knows how many characters to write to stdout

Go sleep

@@duppy404You’re right Why am I watching this video at 2am?

@@ZaHandle same here

Write directly in Assembly is the best for a tremendous performance in less resources because an compiler is good in optimization but when you know exactly what you want you can make games in Kb of size.

Youre making sense since they are borh buildinf blocks but i also have to go sleep

Imagine being able to print an entire string at once, and not a single character at a time! This reply was mad by the Apple II Gang.

also try sending string to multiple ip, and display it in easy GUI, no no no - not in console or dos box - we're not in 1960-ties. Think it would be impossible to John Hammond, and Hello world is junk 3 operands piece of not even code - instructions.

#!/usr/bin/bash echo "Hello! It's me. Redbum."

Thank you so much for all the kind words! I really appreciate it! Thanks for watching!

You didn't mention peek() and poke()

@@jameshofmann5996 To be honest that's what got me into assembly in the first place. My uncle was an English Lit teacher at LBSU, and him and a computer science graduate created a program to help non English speakers learn the language easier. He let me see the code one night when he was visiting, and BASIC is pretty intuitive, so I grasped it right away without ever touching a computer. He let me play around on his TRS-80 Model 100 (one of the first portable computers) and I couldn't be pulled away the entire weekend he was visiting. I asked him about the peek and poke instructions, and he explained to me that is how you put things and take things out of memory. That led me to find out more about those kinds of things, and I was introduced to assembly. So you can say that peek and poke are what really started it all for me :D

That is the advantage a scripting language offers

Yo, Code Geass is an INCREDIBLE show

33 minutes ago?

You forgotten the "!"

Now all you have to do is install python... ;) Also you should add the crunchbang to tell your shell where to go find the interpreter..

Yeah I don't like looking at it so I add the extra zero. For whatever reason I almost never use decimal numbers either in assembly, mostly hex (and binary for bitmasks)

@@williamdrum9899 I use whichever is appropriate, depending on context.

Not really, the code above is not optimized

@@hamidcrazy9027 How could it be optimized?

@@alister_ what I'm 100% sure of : a faster way to mov 0 into a resgiter is to xor it with it self, so if you "xor ebx,ebx" instead of mov in the second syscall, you'll have a faster zeroing, plus the code will be smaller by 2 bytes (smaller instructions effects the caching and the fetching positively which improves the speed what I'm not 100% sure of : you can brake some instructions into smaller ones (remember the small instruction effect I just talked about ?), i,e "move eax, 4" can be replaced with "xor eax, eax" and "add al, 4" but be sure to put them as far from each others as you can so you don't cause a stall (basically making the code slower) e.g the xor should be the first instruction in the code while the add should be right before the syscall this could save a couple nano seconds, which shouldn't matter that much, but the first xor tip shows that you know your assembly

@hamid crazy Ah yes. Teach me master.

@@tacitozetticci9308 I ain't no master but I can probably suggest some books if you wanna learn assembly

Put your tictok down and pay attention, because I guarantee the instructor is teaching, or he wouldn't be teaching.

I too cut my teeth on Assembly Programming fifty years ago on a PDP-8. Good assembler programmers are scarce these days.

Oh crap, okay! That is super good to know, thank you!

Btw, this guy Kabbone uses Arch.

Better yet do pacman -Syu

The reason why I hate Arch rolling release. Other distros doesn't force you to update all other packages before installing new package.

@@robotduck77 Ehm, it doesn't, you just don't update the index before, simple pacman -S without the y for updating the index

"I use arch, btw"

You are damn right. Every instruction written in assembly is equal to a series of 1s and 0s. Depending from the kernel those are represented in different ways.

This isn't really true. There is still quite a lot of relatively high level stuff going on in the average assembler (which is a type of compiler, btw). For instance, all of the labels? Theres no correlation in machine code. If you are generating object code, it might get used to construct a symbol table, but the machine knows nothing about any of that; thats the operating system/loader that interprets that information. How the assembler uses it though it to give you a relatively high level and convenient way to talk about things written at locations in memory that correlate to data and code that you have specified somewhere else in your source code. Instructions taking operands of different sizes, like rax vs eax? There's quite a lot that the assembler has to do to make this distinction, especially in x86_64. Some assemblers aren't even machine specific, and all of the instructions are actually specified in a macro language embedded in the assembler (fasmg for instance). You should try comparing the input to an assembler that someone has written by hand with the output from a dissasembler that is trying to 'guess' at the input. It can (sometimes) figure out what was instructions, and what was data, and how it relates to other blocks of code and data, but even in translating from assembly to machine code (or object code) quite a lot of information is lost.

@@homelessrobot "For instance, all of the labels? Theres no correlation in machine code." --> I don't mean to be disrespectful, but this one, single, bizarre, incorrect statement that you made displays a flashing "Warning!!" banner above your head, burning so bright you can see it from the Moon. I have to conclude that your experience of programming is...rather limited. In Assembly (as in many other languages) you are free to declare labels (they're merely used as destination pointers). The Assembler's extremely simple job is to set all branch/jump instructions to the label's address, or, if the label is a data pointer, then set all relevant data addresses to here...all as applicable. There are other uses for labels, though these cover their most frequent use.

@ Really? Tell me, what address does it assign to the labels?

@@IlKaiserChannel It does not equal a series of 1s and 0s in any way other than the completely trivial (i.e. all code is 1s and 0s). The kernel has nothing to do with the representation of instructions.

Oh sweet! Good tip! Thank you for letting me know! I'll have to do that in the future for things that I know won't change. Thanks again!

Bom dia Fabiano, voce é brasileiro, tem alguma dica pra quem esta começando a ser programador?

@@electricimpulsetoprogramming a dica é vc desenvolver a sua lógica de programação, e isso pode ser feito em QQ ambiente, com QQ linguagem, inclusive usando um Arduino.

The Pentester Academy: x86 Assembly Language and Linux Shellcoding is reportedly VERY good. That's where I get started to get material for this video. www.pentesteracademy.com/course?id=3

that's x86 system call on Linux for you. eax stores the system call value, simply calls write(int fd, pointer to buffer, size_t buffer_size). Those parameters go into ebx (fd), ecx (pointer to buffer), edx(buffer length) respectively. Every time you make a system call in Linux on x86 eax will store the system call number, ebx - the first argument, ecx - the second one, edx - the third one and then (if you happen to make a system call that requires more than 3 arguments) the rest of the arguments needed to be pushed onto the stack. When you do that, you need to be mindful of the order you do that, because the system will pop the argument from the top of the stack, so your last pushed data (in this case the argument) is read first that gets read (popped) and somewhere down the line the first data you pushed onto the stack is read as the last piece of data (that would be your last argument).

@@tibielias Thank-you

Oooooh, that's totally a better way for it to be described. Good call, thanks!

I think it's gruvbox

Hahahah that's for sure -- thank you so much!

In Visual Studio you may compile C++ code to assembly and then to machine code. Maybe you may do this with C. You will see how your C programs looks in Assembly :-)

Godbolt is an incredibly useful tool for mapping C/C++ code to assembly output, showing both in color-coded blocks