Computer Systems: A Programmer's Perspective

I greatly recommend for anyone who is interested in the subject.

"Computer Systems: A Programmer's Perspective" è uno dei testi più interessanti che abbia mai acquistato nel corso della mia carriera da informatico. Spiega nel dettaglio come lavora un calcolatore, fornendo solide basi per programmare a basso livello. E' un mix tra un testo di "Sistemi Operativi", "Calcolatori elettronici", "Assembly" e "System programming". Gli esercizi/esempi peraltro sono brillanti e talvolta intriganti. Testo favoloso. E' molto costoso certo, circa 100 euro, ma a parer mio li vale tutti. Il testo in oggetto, la seconda edizione, si concentra sullo studio della programmazione dei sistemi Unix su architettura x86 32 bit (IA-32).

Excellent service, great book for teaching

I've finished reading this book cover to cover after about 4 months and found the first few chapters (number representation, Assembly and processor architecture) cover materials in more depth compared to later chapters (e.g Unix signalling, network programming and concurrent programming). I suppose it's reasonable to only 'scratch the surface' on these more advanced topics, since in depth discussions would require a book of much larger volume (likely multiple books). In the bibliography at the end of each chapter, the authors provide a list of suggested readings for more comprehensive study on the main topics covered in that chapter. Overall, I think this is a great option for textbook that could be used for a typical sophomore level computer organization class, while also provides introduction to more advanced topics that are usually taught in upper year classes.

This fast-paced book touches on every level of computer organization, from the logic design level, through compilers and linkers, to memory models, parallelism, and computing in networks. It presents a broad-based survey, for the diligent early student who wants to know more about what to expect from future coursework Still, the field is huge and there's only so much you can cram into 1000 pages or so - this really does just touch on each topic rather than going into any great depth. If there's anything I might fault this for, it's the tendency to treat each topic in isolation. For example, debuggers depend on both object code formats and hardware exceptions. Processor instruction sets are influenced by compiler design, OS synchronization needs, debugger features, and lots more. Compiler implementation supports the needs of driver developers and multithreaded applications. Complex instructions (like floating point) can be implemented in hardware or in software, using traps, depending on design tradeoffs. In short, everything depends on everything - but it's almost impossible to present all those relationships in a linear text. But, that's the kind of thing that a classroom instructor can add to the curriculum. This already presents a sound foundation and framework. -- wiredweird

This is a great book, in fact one of the best I've ever read. It's a bit dense if you haven't had much contact with assembly at first, but it moves forward in a pace good enough for you to follow (with help from external resources, like the Intel manuals, to sometimes see what an instruction is about). For example, I had to go online to fully understand that the LEAL instruction actually did and was generally used for as well as to discover that the TEST instructions actually AND-ed the operands, but that's ok, because the main focus of the book is not to be an assembly course. It assumes you already know C well and have at least a good grasp of the major assembly instructions for x86. The book is a bit costy IMO but still it's a great book and well worth it if you want to know how things work "under the hood" in your system and a great guide for those wanting to optimize their code and generally be a better programmer. Also it's very focused on GCC and Unix/Linux, which is awesome.