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

I took this 15213 course at Carnegie Mellon University last year. This book was one of the required reading material, (the other one was "C Programming Language"). We were lucky enough to have Randal E. Bryant and David R. O'Hallaron as instructors that semester. The book covers almost every fundamental concepts in OS. It does contain a significant amount of information, but the way it's written does not confuse readers nor make them sleepy as some brick textbooks do. Actually it is pretty well written and organized so readers can follow through without much trouble (might need clarification and guidance once in a while). The practice questions after each chapter is excellent material to get a favor of how each little piece works. Lab assignments from the book aim to help readers assembly these pieces into a whole. Labs do require certain degree of time and effort, especially for beginners. Lectures from two authors went extremely well with the book too. I am still feeling glad today that I took the course, which lead me to this book and two excellent instructors.