Low-Level Programming: C, Assembly, and Program Execution on Intel® 64 Architecture 1st ed. Edition, Kindle Edition

tl;dr: buy this book if you're interested in the underlying principles of low-level programming. If you just want to learn some C and assembly, there are plenty of free tutorials online. The book is probably too terse for absolute novice programmers but is a delight for those with some experience who seek to learn basic concepts of low-level programming while systematizing their gut feelings of programming patterns and good practices into a coherent view.There are books on programming that are best used as references, standing on one's desk and waiting for its owner to forget a name of a handy function. Then there are books that seek to land their readers a job by providing the minimal knowledge required to pass a programming iterview and do some productive programming, learning the missing pieces later in the field. And then there are books that outline the underlying principles on which programming is built. The present book is of the latter kind.That isn't to say the book can't be used to land a job. The presented examples and topics are not merely for academic pondering but practical enough for a reader to be able to apply the acquired knowledge in the field. However, if one just wants to start writing assembly and C, this book is probably an overkill. It doesn't hold one's hand and requires much more effort from the reader than necessary to start producing working code, so if one's goal is to be able to read and write some C, online tutorials would probably be a better place to start.Who is this book for, then? Well, one of its major focus is on good practices, so if one is somewhat experienced in programming, the book can help to solidify the intuitive understanding of how to write. The other focus is on the underlying principles of low-level programming: many connections to other branches of computer science are provided, putting low-level programming into a broader perspective, which results in better programs. For example, one doesn't exactly need to know about finite-state machines, but structuring an assembly program to resemble this concept helps significantly to produce listings that are easy to read and debug. Exposure to other models of computation doesn't have any immediate benefits, but if one familiarize themselves with Forth (an interpreter of which the book suggests to write), they are bound to use some little tricks inspired by it from time to time. How does knowing about parsing of formal languages help with low-level programming if one doesn't expect to write compilers? Well, it makes compiler messages more intuitive. And so on; I suggest that you look at the table of contents, available freely by clicking on the book cover, and observe the sheer breadth of the covered material.Of course, the book isn't limited to things that are only marginally connected to low-level programming. The programming itself is described definitively, with many helpful examples, assignments, and useful asides which warn about important caveats. I was sold the moment I saw a warning about a names of sections in assembly not being case-insensitive, because first, I've once spent an evening fighting with a mysterious segfault because of this, and second, I haven't seen a similar warning in any other resources. The book is good; however, I still believe that its greatest strength is in acquainting readers with indirectly related concepts, and reading it solely for the sake of learning how to write C isn't practical as there are many easily googlable free resources providing the means to acquire this skill.With all that said, I still believe that even though exposure to many different topics indirectly connected to low-level programming makes one a better programmer, beginners would be overwhelmed by the amount of content they have to absorb in addition to learning the basic concepts.Summary:+ Breadth+ Depth+ Interesting examples and assignments+ Caveats+ Instructions for tooling (often discarded in other books)- The book is quite terse (the consequence of being deep and broad)- The language in which the book is written is sometimes weird due to the Russian origin (for example, 'loop' is 'цикл' in Russian which is incorrectly translated as 'cycle' in some places, but 'loop' isn't even nearly the same as 'cycle'')DISCLOSURE: I'm personally acquainted with the author and have read the book before it went to print. However, I'm not currently one of his students and so will not receive good grades for this review.

Very well written book on Intel 64 architecture and programming using both Assembly language and C. Clear instructions, numerous code samples compilable from the first try and many assignment forcing the reader to apply his newly acquired knowledge to writing useful and quite complicated code from scratch. The chapters on using C and Assembly in ensemble are especially valuable. There are many good books about C but this one is the best I've seen so far on Assembly and its productive use with C.

Good information but presentation is a bit awkward. For example, each chapter heading includes the author's name and city. Language is also a bit stilted. But if you can get beyond those aspects, the information contained in the book is useful.

This book is about assembly language, mostly about C, and how to make them work together. What is written is written well, especially the first (assembly) part is good. It is truly engaging though I think the pace is too fast and the final problem (writing Forth interpreter) adds more noise than signal to overall content (just count it -- you are supposed to learn asm, low-level C, and Forth -- in my opinion it is too much) -- anyway, I immediately felt nostalgic about the times I wrote code in 6502 and 68K asm.Let me list all the drawbacks I noticed. The minor ones are the format of the book (taller, and narrower than usual) and persistently printing copyright notice over the pages. I don't know where APress is heading with it but I see it again and I am really tired of this. What next -- "you wouldn't steal a car..." warning?The big one starts with author's statement that there is no point in duplicating info about assembly language because everybody can check Intel spec. As the effect you get as little info as possible in a book about assembly. This decision made me really angry -- I paid for the printed book just to be reminded about existence of the internet? Now I have to switch constantly between book and computer monitor -- yeah, new dimension of comfortable reading.But what really broke the straw was page 127 -- beginning of the C part. Author included just a little info about asm because there is one spec available ("Many books try to include exhaustive information about instruction set. it gets outdated quite soon; moreover, it BLOATS the book unnecessarily.", upper case is from me)? Hear this -- there is entire C tutorial included, 140 pages long, even with programming style tips. It is probably because there is no other book about C on the planet, and K&R is about to be written yet. Yes, I am buying this reasoning, sure.Author also included such rare gems as description of regular expressions and finite state machines. But asm... oh big no-no, there is Intel spec already, every line of duplication is a crime ("There is no virtue in copying the instruction descriptions from the “original” place they appear in; it is much more mature to learn to work with the source.") Why a reader cannot work with the sources about regexes or grammars?As for wasting space I was also not happy seeing questions supposed to help me learn -- I read books because I am curious, to learn more, so my mind is already set on asking. I think it is more valuable to provide information than to ask and ask (because I am already doing that). "What does instruction xor rdi, rdi do" -- is it really valuable? There are 423 questions in total and I think they are geared more to make this book a textbook (making life easier for lazy lecturer) than to truly help any self-taught reader.It is not the book is not useful, far from it, author relies solely on open-source tools, I have learned about Intel asm (and Forth), part 3 (C+asm) showed me new low-level details. But despite all those good things this book is too heavily ill-balanced to get a higher score. The second edition will be good with the second part completely removed, or really great with expanded part one at the expense of removing part two. Until then we have to live with the average.

This is a great book for learning low level programming. Although, I am C++ programmer, I learned so much from it. Really get it and you won't be disappointed!

To understand this book you have to already know assembly programming. The author does not do a good job teaching the concepts. Alot of the answers to the questions posed in the book are not properly introduced. So you must already have knowledge of NASM(assembly) to complete the questions, so whats the point? if I already know the subject matter, why should I buy the book? The author refers the reader to the intel documentation, which is very obtuse. You probably won't learn assembly programming with this book, you'll need something else to supplement it.

I thought the book was going to be more begginer friendly.But i was wrong,So if you looking for more begginer friendly this book is not for you.

The book bombards you with a lot of subjects along with lots of random info, but fails to give a very clear explanation on anything.

What this book is not about: it's not an x86 assembly manual, in fact, it doesn't give thorough description of any of the topics mentioned.It's better than that! It's more like a guide book, i.e. it's an overview of the whole modern software stack, starting with low-level assembly and ending with relatively high-level C code. So if you want to get an idea of how things work under the hood, and how those pieces stick together - this is the book for you.

Within a few pages of starting the book doesn't at all adequately explain pretty much anything about basic assembly. Instead jumping from a barely explained hello_world.asm to a not at all explained print_rax.asm example.The entireity of the ASM protion of the book is largely over without explaining the examples or indeed ensuring understanding at any level. I understand the need to show the reader how to learn via the Intel IA64 Manual, but it really should explain the basics much more clearly. I would go so far as to say much of the information is so shallow it just provides confusion.A poor start which means the liklihood of using the rest of the book is highly unlikely.

Great book to learn or refresh Assembly language. It uses the latest Intel x64 architecture and very good examples to dive you into the low level programming. I love this book! Some topics like Forth interpreter/compiler are seem to be not so useful at a first glance, but this is actually one of the gems of this book.PS I have been programming in Assembly regularly, starting at the Secondary school.

Tl;dr:- This book isn't well suited both for beginners and people already familiar with Assembly and C.- It contains quite a lot of spelling and grammatical errors.- The author tells you on numerous occasions to just look it up online or in the documentation.- The answers to the questions asked in the book are only available online.- Contains errors regarding C pointers and arrays.- Other than that it is actually a decent book.Let me explain...Firstly, the topic of this book is very interesting and there aren't any similar books as far as I know. Thus, I appreciate the effort that the author and the technical reviewer put into it.The author seems to be very knowledgeable with the exception of a few significant errors regarding C (more on that later). However, his writing style isn't the best. Unfortunately, the editor did a bad job because this book contains numerous spelling errors (e.g. "can not" instead of cannot). If you can't afford a proper editor, just ask on Twitter etc. if some people would be interested in proofreading a draft of the book in exchange for a free copy of the final product. There are even a few sentences that end completely different than they started as far as I remember. At least you can figure out what he meant.Who is this book for? I don't know it either.The book says on the cover "[...] teaches you to freely write in assembly language". But it simply doesn't. The author doesn't even teach the basics of assembly. All you get it an impression of how assembly works. There is no way that anyone can write freely in assembly after reading this, you probably can't even write a running program that is more complex that "hello world". Instead he focuses on all the fancy stuff in favor of teaching actual assembly language. For most things that would actually be helpful for learning assembly, he just tells you to look it up in the Intel/NASM documentation. I don't get it. If a beginner wanted to learn assembly from the documentations, then why would he buy this book?Since this book is mainly targeted to intermediate or advanced programmers (at least that's what the cover says), one might argue that this book doesn't need to be beginner friendly. In that case, why write that it teaches assembly when it clearly doesn't. Additionally, including an introduction to Assembly and C wouldn't be necessary in that case. So clearly there is no actual target group for this book except students who read this alongside a course in college. That's a shame since it offers some useful bits of information that most intermediate programmers probable don't know already.Further, I almost lost it when I saw the answers to the questions are only available online. I didn't buy a hardcopy of an expensive book just to use a computer anyway!For me personally it was over when the author said, and I quote: "[...] an expression myarray [an int array] has actually a type int*, because it is a pointer to the first array element!", p. 153. That's wrong. An array is more than just a pointer to its first element. If you don't believe me, check out "Understanding and Using C Pointers" by Richard Reese. At that point, the book lost some of its credibility. In case I misinterpreted this, it should be explained more carefully. He also mixes pointer and array notation (e.g. using array notation on a pointer), which could be considered bad practice.My advice for a possible 2nd edition would be to decide whether this book should teach asm/C or not and to market it accordingly. If they decide not to teach them, change part one and get rid of part two. Otherwise, append part one and actually teach assembly and maybe get rid of the unnecessary Models of Computation chapter. In any case, include the answers to the questions, at least summarize some of the contents of the documentations when you're referring to them, hire an editor and fix the chapters about pointers and arrays in C.If you do that, the 2nd edition will be a decent book.

The book's subject is very interesting. However, I hope it was written with more care. Loads of grammatical errors and strange sentences that feel like this was meant for a draft version and not the final one. I appreciate that the author is not a native speaker; but there is a difference between that and being just careless about furnishing a good product.Please, if you are working on a second version, be more careful than that.