11 ms·
Assembly Language for Beginners [pdf]
- tawayway 8y agoThis seems to the same text as the author's Reverse Engineering for Beginners (https://beginners.re/ https://beginners.re/) https://news.ycombinator.com/from?site=beginners.re https://news.ycombinator.com/from?site=beginners.re
- vmateixeira 8y agoFun fact: both books have precisely 1082 pages.
- e12e 8y agoYeah, I'm a little confused about this "build" of the pdf. It clearly states: "The latest version (and Russian edition) of this text is accessible at beginners.re." - which points to: https://github.com/DennisYurichev/RE-for-beginners https://github.com/DennisYurichev/RE-for-beginners But as far as I can tell there's no branch with a different name - maybe this was just a working title for the English version at some point? Anyway, this new submission with a new title made take a look, so I'm happy :) Now, I just hope someone takes a crack at forcing an epub build for better reflow/resize on small screens... There's a (dormant?) issue: https://github.com/DennisYurichev/RE-for-beginners/issues/371 https://github.com/DennisYurichev/RE-for-beginners/issues/37...
- cylinder714 8y agoThe title pages are different. The Reverse Engineering book's title text is hex digits, and is dated July 9, 2018. The Assembly Language book's title page is English text, and is dated today, July 17, 2018. And there is no mention of the Assembly Language book on his home page, yurichev.com.
- dennis714 8y agoYes. Explanation: https://yurichev.com/blog/UAL/ https://yurichev.com/blog/UAL/
- appslure 8y agoAppslure is a Brilliant mobile Application Development Company in Delhi, Noida, Gurgaon and Mumbai. Our app developers team are expert in iOS, android, iPhone and iPad app development. For more visit on- http://www.appslure.com/ http://www.appslure.com/
- JadeNB 8y agoThis is spam.
- lprd 8y agoThis looks great! Thank you for sharing :)
- simias 8y agoThe fact that the document targets multiple architectures is great, most ASM tutorials online target solely x86 and as such give a very partial view of how assembly is written and how CPUs work, and on top of that x86 ASM is really quite a mess. I've skimmed the document and it seems rather thorough and doesn't shy away from all the nasty details (which is a good thing for an ASM tutorial), the only criticism I have so far is that the assembly listings are a bit hard to read, additional whitespace and basic syntax highlighting (at least to isolate the comments) would make it a bit easier on the eyes I think, for instance: https://svkt.org/~simias/up/20180717-151848_asm-listing.png https://svkt.org/~simias/up/20180717-151848_asm-listing.png
- snarfy 8y agoYep, I was very happy to see the ARM and MIPS output. Syntax highlighting is a great idea. It didn't even bother me but this is coming from a guy that had a hard copy print out of the 386 programmers reference.
- mbowcutt 8y agoWould have been over-the-top cool if RISC-V had been included as well.
- kulu2002 8y agoNice share! Thanks
- merolish 8y agoOld school, but I've always enjoyed this gentle introduction: https://chortle.ccsu.edu/AssemblyTutorial/index.html https://chortle.ccsu.edu/AssemblyTutorial/index.html
- nickpsecurity 8y agoThat looks nice. People learning hardware, too, might follow-it up with a study of Plasma MIPS: https://opencores.org/project/plasma https://opencores.org/project/plasma Then, they'll understand at least one architecture inside and out. Plus be able to customize it to their liking. :)
- moistoreos 8y agoGodbolt is my favorite goto for "What would this look like in assembly" answer websites.
- danellis 8y agoThat will only tell you what a compiler will generate, though, which sometimes isn't enough.
- andreygrehov 8y agoMy god, 1000+ pages. What a great submission though. I wonder what kind of things keep such people motivated to write one fuckin' thousand and eighty two pages about assembly!? This is nuts.
- ianai 8y agoI don’t think it’s nuts to share such depth of knowledge. I greatly welcome the knowledge, too. I legitimately am wondering what sort of project I could take up that would be “small enough”, only do-able in asm/c, and interesting.
- K2h 8y agowow - impressive. In the intro of the book, yes, its a book - there is a call for proof read (English and Russian) and translators, will accept work no matter how small and credit. now that's cool. when I get a few minutes between meetings i'm going to see if I can find anything to contribute and submit. I absolutely love the tone of the book! what a cool guy.
- jimbokun 8y agoThink "nuts" was used as an endearing compliment there. Like "insane" in the sense of "insanely good".
- jimbokun 8y ago"Chapter 1" is over 400 pages. :)
- vram22 8y agoA couple of points come to mind: 1. Assembly language needs more lines of code to achieve the same task than higher level languages, by its very nature. 2. What I call Pascal's Amendment :) - very loosely like claiming the Fifth Amendment (to the US Constitution): https://en.wikipedia.org/wiki/Fifth_Amendment_to_the_United_States_Constitution https://en.wikipedia.org/wiki/Fifth_Amendment_to_the_United_... https://www.brainyquote.com/quotes/blaise_pascal_386732 https://www.brainyquote.com/quotes/blaise_pascal_386732 "I have made this letter longer than usual, only because I have not had the time to make it shorter." - Blaise Pascal As a writer, I can corroborate that. In fact, if he "had the time to make it shorter", it implies that he spent even more time to write those 1000+ pages than it would seem on first glance. Plus even more than for the same 1000+ pages if in a higher level language, since assembly is a lot more error-prone.
- bigmit37 8y agoGreat share. I have been curious about assembly languages for a while. Hopefully it’s not to technical for someone without a CS background.
- mikestew 8y ago13 year old kids figure it out. I was one of them, and I'm an idiot more days than I care to admit. Granted, it was 6502 assembly, but later I'd be able to sift my through x86, before it went completely nuts.
- scarface74 8y agoI think my motivation for learning 65C02 assembly back in the day was necessity. To take advantage of the Apple //e at any reasonable speed I had to. Besides 65C02 was simple, as was 16 bit x86. Things got a lot more complicated and the necessity went down.
- eleitl 8y agoNow do that for the GPU.
- cjhanks 8y agoTo be fair to NVIDIA, they have done a pretty good job here. https://docs.nvidia.com/cuda/parallel-thread-execution/index.htmlbg https://docs.nvidia.com/cuda/parallel-thread-execution/index...
- monocasa 8y agoI thought that PTX is an intermediate format, kind of like a Nvidia specific LLVM bitcode for GPUs.
- kolbe 8y agoI've never had a desire to learn about Assembly, but I thought the first few pages of this book were kinda interesting, and I might end up learning more than I had ever cared to.
- mikehodgson 8y agoGreat resource! It brings me back to the early days of the web, poring over "Fravia's Pages of Reverse Engineering".
- znpy 8y agoMaybe too much content? 1000+ pages, many architectures... Probably too much content for a beginner book? Btw, a great book imho is "Assembly Language Step By Step - Programming with Linux - 3rd ed" (https://musho.tk/l/d2d56a34 https://musho.tk/l/d2d56a34). The great things is that it is an easy read and really starts from the basic and explains how the i386 architecture works, and then explains how to program it using assembly. The sad thing is that afaik the author is quite old and probably is not going to release a 4th edition, meaning that the book will stay on intel i386.
- vasili111 8y ago>Assembly Language Step By Step - Programming with Linux - 3rd ed +1. I have read 2-nd edition. Great book!
- jlarocco 8y agoI have the first or second edition of "Assembly Language Step By Step", and it's the best intro I know of. It must be difficult to write a good assembly book. On one hand there's a lot of basics to cover, like memory addressing, segmentation registers, etc. But on the other hand, the main use case for it today is hand optimized functions for when the compiler can't optimize enough, which is inherently an advanced topic.
- johannes1234321 8y agoThere is another use: Understanding compiler behavior and reverse engineering. Those mostly need reading skills.
- deleted 8y ago[deleted]
- fouc 8y agoI read the 2nd edition of Jeff Duntemann's book (DOS & Linux) in little more than a couple of sittings. Incredibly readable! Best introduction on the background of how CPUs work and what machine language is about.
- GnarfGnarf 8y agoI actually got paid a salary for learning & programming in IBM mainframe assembler (BAL or Basic Assembly Language) in 1970, for an insurance company. The CPU memory was so small (32K, yes 32,768 bytes) that the only way we could squeeze enough functionality was to write in assembler, with overlays (no virtual memory). Debugging consisted of manually toggling hex data and instructions at the control panel. What a blast! It was a lot of fun, but terribly inefficient programmer productivity. I would not want to go back :o) Dereferencing registers prepared me for C pointers later.
- molteanu 8y agoThanks for sharing
- amorousf00p 8y agoShithead.
- xigency 8y agoWow, 32K! I'm working on an Arduino Uno project where I need to squeeze some complicated logic into 2K RAM and 32K FLASH :). I haven't resorted to assembly, yet.
- amorousf00p 8y agoWhenever I see some shit like 'thanks for sharing' or 'noted' I want to kill someone. These are cautionary tales: ignore at your leisure.
- paidleaf 8y agoThis isn't for beginners. What beginner's assembly text covers multiple architectures and assembly flavors? My recommendation for beginner's assembly on linux is to write toy code in C and then view the disassembly in gdb or objdump. You have options to switch to Intel syntax from GAS/AT&T if you want. I'm generally against using windows for anything, but Visual Studio has decent disassembly debug options where you can step through the native assembly code. You could also look at IL code ( which is very similar to native assembly ) and learn assembly concepts that way. ildasm and ilasm are great tools for that. Assembly is so low level and can be intimidating to write from scratch in the beginning. It's better for beginners to write code in a higher level language like C and then read the compiler generated assembly code. Once they are comfortable with a disassembly of a "hello world" program, then write more complicated code and understand the disassembly. Then try to edit and compile the disassembled code. Once you are comfortable, then write your own assembly code from scratch. Edit: Also, if you have time and the will, watch the nand2tetris lectures and try their projects. It'll give you a hands-on general overview of hardware to assembly to VM to OO. How native assembly works with hardware. How VM interacts with native assembly. How you go from OO to VM? It's a very limited but educational overview of code flow from object oriented code all the way to circuitry ( software circuitry ).
- mikehodgson 8y agoThe book literally follows this process starting on page 5.
- xfer 8y agoI got interested in assembly fairly early on my programming career by playing wargames(io.smashthestack.org anyone?). Writing exploit payloads was very fun. After that in my career i have only written assembly to vectorize some code using neon. I think the best reason to learn assembly is not to write rather be able to read compiler output.
- pq0ak2nnd 8y agoThis is a great resource. I don't think it is for beginners, it is a bit overwhelming. But as a programmer who has to dive into asm every few months (on a variety of architectures!), this will be a very helpful reference to help me reset my frame of mind for the particular architecture.
- peter_retief 8y agoNice basic intro to assembler, as a person from some electronics background it fits with knowledge of simpler architectures
- max_ 8y agoNice!
- neuromantik8086 8y agoI feel like 6502 assembly is probably better for beginners, but that might be because that's what I'm trying to teach myself...
- pro_zac 8y agoWhat resources are you using to learn?
- neuromantik8086 8y agoA little bit of Easy 6502 [0] but mostly Richard Haskell's Apple II-6502 Assembly Language Tutor [1][2] along with Virtual][ [3] . Basically I'm trying to use assorted manuals I could find in my childhood home's basement, most of which seem to be out of print (although there are some books floating around on archive.org). [0] https://skilldrick.github.io/easy6502/ https://skilldrick.github.io/easy6502/ [1] https://www.amazon.com/Apple-II-6502-assembly-language-tutor/dp/0130392308 https://www.amazon.com/Apple-II-6502-assembly-language-tutor... [2] https://archive.org/details/Apple_II_6502_Assembly_Language_Tutor_Richard_Haskell_1983 https://archive.org/details/Apple_II_6502_Assembly_Language_... [3] http://www.virtualii.com/ http://www.virtualii.com/
- lucb1e 8y agoThis sentiment is one of the reasons why I didn't bother in the past: it's apparently so complex that I have to learn something completely different and useless these days, before I can start learning something useful. I'd much rather just deep dive into x86_64 or ARM or something. These days I know that older versions are still (partly?) included in x86_64 and that they're often mostly the same, but that was not clear to me when I saw tutorials for ancient architectures of which I didn't see the point. But then, I've never taken well to the school system where you get taught something stupid first only to see practical applications later. It's why I dropped out of high school and went to do something of which I did see the use (a sysadmin 'study', because I knew I enjoyed working with computers, and that was indeed a good fit for me).
- 8y ago
- richfnelson 8y agoThanks for the recommendation.
- simonebrunozzi 8y agoAmazing. One of my fondest memories is when, at age 10-11, I "played" Core War [0] with an older friend of mine (he was 20-21 back then, and a CS student at one of the best CS universities in Italy, Pisa). I loved to learn how to program in a game-like environment. I still remember several things, ~30 years later. [0]: https://en.wikipedia.org/wiki/Core_War https://en.wikipedia.org/wiki/Core_War
- g-b-r 8y agoDiffPDF 2.1.3 finds only two tiny (if weird) differences in the appearance of the two versions of the books (https://yurichev.com/writings/AL4B-EN.pdf https://yurichev.com/writings/AL4B-EN.pdf and https://beginners.re/RE4B-EN.pdf https://beginners.re/RE4B-EN.pdf) besides the title, author and build date: two page references at pages 1075 and 1078. Since both sites appear to be owned by the book's author this is most likely just a change that has not yet been pushed to github (or mentioned in the author's sites), but it would be better if the author clarified it (would that be you, dennis714?)
- dennis714 8y agoYes. Explanation: https://yurichev.com/blog/UAL/ https://yurichev.com/blog/UAL/
- sandov 8y agoThank you. This is a godsend.
- nineteen999 8y agoAt one point when I was considerably younger I started learning 32-bit x86 assembly as my very naive career goal was to become the next Linux Torvalds. I managed to construct a multiboot-compliant 32-bit kernel that could load tasks from a ext2 ramdisk image passed to the bootloader and multitask up to around 64 processes. I figured out how to use the CR3 register and craft page tables, enter into kernel syscalls using software interrupts, handle CPU faults, page faults, double faults etc. It was quite the learning experience until it eventually crumbled under my lack of skill and foresight. In short, I got more or less about as far as most amateur, self-taught, lone OS developers get before losing interest and giving up. Fast forward a couple of decades, and I found myself reverse engineering CP/M for the Z80 processor in order to create a virtual Z80-based system that ran inside Unreal Engine. I started with Udo Munk's wonderful Z80pack system, adapted a public domain Z80 CPU emulator which was written in C to C++, and did minimal reimplementation of the Z80pack terminal and disk I/O devices. Since the systems were implemented as "actors" in UE4 it's possible to spawn and run quite a few concurrently as long as you limit the CPU speed of each instance somewhat. The resulting virtual system in UE4 is able to run original CP/M ports of Rogue and Zork (https://i.imgur.com/gnOCp3e.png https://i.imgur.com/gnOCp3e.png), various Z80 instruction exercisers (https://i.imgur.com/kwNuq5X.png https://i.imgur.com/kwNuq5X.png), a Z80 C compiler and and even Wordstar 4 (https://i.imgur.com/Q6307w3.jpg https://i.imgur.com/Q6307w3.jpg) and Microsoft BASIC. Learning assembly can be a lot of fun - it can really teach you quite a bit about systems architecture that you otherwise might not get if you're always programming in high-level languages only.
- mcdevilkiller 8y agoHave you published a plugin or the source? Sounds very interesting for using in computers inside the game (as in Fallout and the like).
- nineteen999 8y agoI'd like to but it would still take quite a bit of work to make it production quality code, and I don't really have the time right now. One day I hope.