Begins with the most fundamental, plain-English concepts and everyday analogies progressing to very sophisticated assembly principles and practices. Examples are based on the 8086/8088 chips but all code is usable with the entire Intel 80X86 family of microprocessors. Covers both TASM and MASM. Gives readers the foundation necessary to create their own executable assembly language programs.
A long time ago, in a basement far far away, I was sitting in front of a long-suffering television set, banging away on a Commodore 64, trying to dive beyond BASIC programming to where the cool kids played, down below the user interface, down in the guts of the machine itself. Stripped of the training wheels, you could write programs on that ancient machine that would fly. The cool kids wrote programs in assembly language. I tried. But I never got there. By the time I hit college, they didn't teach it anymore, and gradually, I moved past it to other programming, and ultimately to more satisfying careers doing other things.
But I never forgot.
Given that background, I didn't have high hopes for Assembly Language Step by Step. I know Jeff. I've read and enjoyed his science fiction, and he's blurbed mine, and to disclaim a moment, I know him well enough that he wouldn't let me pay for my copy of this new, near total rewrite of his classic text on the matter. I knew if anyone could explain assembly to me, it would be him, but I still expected to hit the point where my eyes glazed over and I didn't care anymore.
Instead, by five chapters into the book, I had refreshed my knowledge of binary and hexadecimal math. I'd looked into computer architecture to a depth I never reached before, and begun to understand, really understand the true center of assembly programming, the addressing of memory. And it's not like it was in the days when I tried to learn assembly before. Modern operating systems treat memory differently, and it's this new, more complex memory mapping that I understand now. Even after 30 years in and around the computing industry, this book taught me things I didn't know about what computing is, when all the familiar abstractions are stripped away and the bare code is exposed.
I can't wait to go further.
Thirty years later, that geeky kid in the basement who didn't get it, finally gets it.
If you want to get it, if you want to program where the cool kids program, if you want to understand how that machine on your desk really works, you want, you need, you must have this book. Buy this book. You won't regret it.
This is a great book for people who want to understand what is going on behind the curtain deep inside the computer. After reading this one would be able to write articulate complex assembly programs for the 32 bit processor.
It is really a step by step guide taking you form binary math and computer architecture and instructions and data structures, explaining every little detail along the way.
The reading is not very easy but remember assembly language is considered not a very accessible one.
One of the most excellent, beginner friendly, pure assembly book around. Most of the books will resort to C library functions after a short while but Jeff stuck to pure assembly throughout. However, he does show how to use C library and interact with it and GCC in the end.
Amazingly readable given how technical the subject matter is. Even coming from a position of ignorance, I was able to follow through the first half explaining the fundamentals of computing. After that it becomes increasingly focused on practical applications, and it seems like a good tutorial for those who want to program in assembly language, but I read it for the theory.
This has always been a good book, but for me, Assembly was always pretty rough. I've known people who took to it immediately, but most I've know are more like me and find it tough to master. I have tried playing around with it on my RPi3, but not very seriously. Still, a good foundational and reference book, so recommended.
Assembly, is in my mind, not much of a programming language, but a tool by which you get to understand the inner workings of memory and its assignment, code optimization, and also, a bridge towards the mechanisms of the compiler. It is a language that provides you with an intuition for the inner workings of the computational device that you are using, hence, is essential for any serious working computer scientist out there. Yes, we live in a world of applications and user space abstractions, who cares about the rest! Well, learning assembly today is fewer times on stack exchange in the future. It is a gateway to the understanding of how a programming language fundamentally works. I dare to say, Assembly is great! This book makes such a case, with a great style, the author, Jeff Duntemann, clearly understand how to approach the subject and does not take any point of knowledge for granted. The structure of the book is the shining diamond of this work. The sequencing of subjects and introduction of terms is done in the best possible way, leaving no moments for the reader to be lost in the very abstract layer that is assembly. If you are starting learning assembly, this is the only book you need. But remember, you're never truly done learning assembly.
Please note, there are newer and updated versions of this book. Unless you are coding for MS-DOS, I recommend you buy a more recent edition. The 64bit Assembly version of the book is available to pre-order now.
There aren't a lot of people in the world who code in x86 assembly language. But if you really want to understand what a computer is doing, nothing beats some time controlling it via assembly language.
I bought this book as a teenager because I wanted to code programs in Assembler. It helped me do that, but more importantly it got me comfortable with doing binary and hexadecimal math, memory management, and thinking through what the task I'm trying to do step by step.
Jeff Duntemann has a exceptionally friendly writing voice that inspires confidence and exploration. Follow him through the maze of computer logic as he points out what is there, and why it works the way it does.
Even if you never write a program outside the books you'll better understand what your computers are doing and be a better programmer in the other languages.
By reading this book the second time after 3 years, I realized how well this book is written. Readers should be really patient reading this book because in the first half of it (by chapter 8, page 200) you will have a nice time comprehending the concepts of memory and assembly language, Linux internals too! as Jeff teaches you everything you need to know to get you started running in the field, and he did write the book so well that sometimes you even forget that's the assembly book on your hands, but a novel. The problem raises when the rest of the book (chapter 8 through 12) feels the same! This book is more of a gate to opening to the world of assembly than knowing how to write it, that is, you will learn assembly by the end of reading this book but you will not know how to write it. Okay that's weird but true. There are a few good books covering the assembly instructions coding to read afterwards, which I recommend reading more.
First technical book I ever read (and that was when I was in high school) and that left me with great memories. I remember that I literally reread chapter after chapter until I understood deeply every single part. That gave me a solid foundation for my future career and great understanding how things really work down there. Concepts like pointers to the memory that my colleges were struggling with were crystal clear to me thanks to this book.
After finishing it I was able to write quite a big project at that time - it was a sort of a clone of Norton Commander - much simpler but with basic functionality - and written in pure Assembly. Boy I was proud :-)
I believe that parts of this book might have a great value even today - especially to developers who started programming up there in a language chain and never really understood how does the bear metal works.
This book best for one who has some little experience (around 6 months) in programming and curious to know how that program is working at machine level in CPU .This book is story book to me which beginners can enjoy more :)
There's a certain point where assembly goes from being extremely difficult to extremely boring. This was a good book about assembly inasmuch as it didn't assume that I am particularly smart, which is a pretty good assumption to make.
Worked my way through this book in about a month, great way to learn assembly language and learn how the machine works! Some of the analogies are drawn out and overblown, but probably necessary.