What is Reddit's opinion of Computer Organization and Design MIPS Edition: The Hardware/Software Interface (The Morgan Kaufmann Series in Computer Architecture and Design)?

From 3.5 billion Reddit comments

I had to look it up. It's the intro to computer architecture class.

Here's the textbook on Amazon without an affiliate link -- https://www.amazon.com/Computer-Organization-Design-MIPS-Architecture/dp/0124077269

Not because I think you're going to buy it on Amazon, but because you can "Look Inside" from that link.

It looks like they're still teaching from an old edition of that textbook. I would have converted to the RISC-V edition by now.

Sad.

That's a good textbook, though. The authors are legends (literally, look them up) in computer architecture. I actually prefer their other textbook ( -- A Quantitative Approach), but it's not suited for an intro class.

Have fun.

Sure! Yeah I got it from this site, it goes over I guess "essential" CS theory to know. My class on this stuff was with the other book he recommends, this one...I thought it was waaay too dense for my tastes.. It's pretty good if you want to learn more CS theory but didn't come from a college background.

https://www.amazon.com/Computer-Organization-Design-MIPS-Fifth/dp/0124077269

I believe this is the one. I had just rented it for the semester from Amazon, but they also have it in the bookstore. I don't doubt there's PDF's you could find of it online too.

The Assignments changed in difficulty a lot, some things were very nit picky things from the textbook, others were writing general Assembly programs.

the topics in general were what was difficult, writing Assembly itself wasn't that hard, but understanding how everything fits together with the diagrams was the difficult part.

we used Computer Organization and Design as our textbook, however the book is not designed very well and contains errors, it has a lot of information, but making sense of the information is what was difficult for me.

That's why I am trying to learn Digital Logic because I feel being grounded in that would make reading the diagrams and everything easier. Appendix B in that textbook, tries to cover digital logic, but it isn't explained very well and assumes you already know it when going through the actual material in the book.

IMO the best book that gives an general overview of computer architecture is the book Computer Organization and Design by David A. Patterson and John L. Hennessy. That being said this is a difficult book. However, it goes over how memory hierarchy works to virtual memory to even showing you the data path of how instructions are executed. Is this is going to tell everything you need to do pen testing and so forth?. Not a chance.

My guess is because you are using this textbook written by Patterson & Hennessy, in which Hennessy was the lead of the team that designed MIPS in the 80's.

From my understanding MIPS is very similar to ARM, but simpler.

I don't know about "beginner", but I was introduced to a lot of the key ideas when I took my Computer Architecture course in college, using a book like this.

Emulator 101 should be a good guide getting started, and other posts like Imran Nazar's about emulating the Game Boy in Javascript would be useful.

Chip-8 is a simple starting point (just a few operations, very simple architecture, only expects to run at about 500-1000 Hz, there are timers but not really interrupts, etc). Makes sense that it's simple and slow; it's actually a VM that ran on some microcomputers in the latter half of the 70s.

Space Invaders (the arcade game) has a more complex CPU, straightforward graphics and audio, and predictable timing on the interrupts.

Game Boy is a cleaner design than the NES, and the CPU can very nearly be adapted from the Space Invaders one. It introduces interrupts, interrupt priorities, memory bank-switching, more complex graphics and audio.

NES is similar to the Game Boy in some ways, but I feel like the quirkiness is even closer to the surface. Fewer interrupts, split memory map between CPU and PPU (the graphics chip), and a horrendous number of bank-switchers used in different games.

A lot of Sega's hardware, the SNES, or even something more obscure might make sense at this point.

My own path, so far, has been NES, started Game Boy (took a small break to build Chip-8), then finished Game Boy, added Color. Took a bit more time, then jumped into Game Boy Advance, which is my current thing (and being fair, I've taken a lot of breaks...I think I was seriously looking into GBA over a year ago).

Find it here on Amazon. It's actually a pretty good textbook and worth reading even if you're mostly a software developer.

You don't need architecture perse unless you want high performance. If you want high performance, you pretty much want to learn the equivalent of a class in computer organization and computer architecture. So if you aren't dealing with raw pointers directly, advanced multithreading, vector/simd math, HPC, 3d graphics, gpu cards, etc, you really don't need computer architecture. If any of those things interest you, you should probably learn it, and you can definitely learn it as you learn C++. If you are mainly dealing with C++ standard library and gui stuff, you will rarely encounter computer architecture topics.
The standard texts (and my favorites) are http://www.amazon.com/Computer-Organization-Design-Fifth-Edition/dp/0124077269/ (Patterson and Hennesey). http://www.amazon.com/Computer-Architecture-Fifth-Edition-Quantitative/dp/012383872X ( Computer Architecture, Fifth Edition: A Quantitative Approach, Hennesey) Those are not referral links, and I recommend they be read in that order.

Some people might say those books are a bit rough for a beginner, so try to get a sample or borrow one to see if you like them. There are some other easier computer org /arch books out there but I'm not aware of any really good legally free ones off the top of my head.

Uhh. Good question. Honestly, I'm not a book learner kind of guy, but the standard "Computer Architecture and Organization" textbook is standard because it's just fucking excellent. Link

For digital logic design, I don't have a favorite source. It's a fairly basic subject. When I say basic, I mean it forms the base of all future knowledge. That means it's important to learn it well. Unfortunately, it also means that five years after learning it, I've internalized it so much that I have no idea what book I used, or precisely what it taught. Except, wait, I actually found what I used, Link. But the point still stands: this stuff is basic in every sense of the word.

Roughly speaking, this is where books end their usefulness for me. You can buy books on assembly and compilers, and you can buy books on C, including The C Programming Language which is of course the C bible. I haven't ever even opened it.

So what do you really need if books don't cut it?

1. FPGA, plus appropriate software to program it. Xilinx or Altera are both acceptable. They both sell student versions of their cheapest development boards, and there are third-party development boards sold on sites like sparkfun and adafruit. You can also buy something from Lattice Semiconductor. Their boards are cheaper and FPGAs are smaller, both physically but also have fewer cells to implement your design. I have never used their software, but the software from both xilinx and altera is clunky. Windows is annoying, linux is even more annoying, mac basically nonexistent. Budget $50 here.
2. A microprocessor development board. For example, PICs are microcontrollers from Microchip (yes, they named their company that, very creative). They are super low cost, very easy to work with, very easy to develop with, easy to program, easy to code for, easy to implement in hardware designs. There are TONS of different chips from all sorts of vendors - atmel, texas instruments, and so on. It doesn't matter. I like PICs. Link On the other hand, the Arduino is far more popular. I'd probably get that over a PIC unless you want to learn to do the hardware design and layout.
3. Free software: a MIPS emulator. Why MIPS? Because the comp arch book I linked does MIPS. It's super simple. It is pretty much not used anymore so you don't have politics (like x86 vs arm whining).
4. Follow the books, learn digital logic design, implement things on the FPGA, drive some lights based on your input. Like (A and B => light 1 lights up).
5. Follow the books, learn comp arch, implement much bigger things on the FPGA, learn assembly using the book and the MIPS emulator.

Once you get to this point, you have roughly finished what college will teach you about digital logic, comp arch, assembly, verilog, and FPGAs.

But wait, we haven't touched that dev board I talked so much about, an arduino board or a pic board or a custom-made pic design you do yourself. College teaches you the basics. Let's dig deeper.

First, embedded programming. You will use the standard IDE to write C for the microcontroller. It will work. This will take much longer than you think to set up and get running predictably and to your satisfaction. If someone teaches you, you can save ~50 hours of bullshit debug work. I taught classes once a semester in school to help people avoid pitfalls that fucked me in the past. But it's a mark if pride if you suffer through it alone and make it to the other side.

Then you branch off. Write assembly for those microcontrollers. Make it work. Then another left turn: write straight up hex (assemble on paper, essentially). This is still relatively easy because many/most software packages you already use will spit out a hex file you can decompile (on paper) and compare to what you'd expect.

Now the FPGAs. Implementing a small processor is easy, especially if you don't add too much functionality. You can stick to just the basics: add, subtract, shift left/right, and, or, xor, not, compare, jump, branch, call, return, load, store. It would take you a decent amount of time to implement and test this but it can definitely be done.

As for the rest: write some assembly, assemble it on paper, run the resulting code, make sure it works. Write an assembler, for such a simple set of instructions this is easy (~1 day of work), make sure it works. Writing a compiler is a huge job, but writing a super simple compiler to deal with just the super basic c constructs (for example, assume everything is an 8-bit integer, no multiplication or division, no printing or reading, etc etc - you're looking more at things like: loop ten times, add the counter to a sum, display the sum when done) should only take a couple days.

Going beyond that is, frankly, hardcore. Much more hardcore than almost anyone will ever do.

As you go down the list - definitely do the parts that you would do in college; after that, decide how far you want to go. You might choose to go super deep into an area (optimizing an assembler) or broad like I did (make everything work in a basic way.)

Decent?

Good book on pipelining basics on mips.https://www.amazon.com/Computer-Organization-Design-MIPS-Architecture/dp/0124077269?ref=d6k_applink_bb_dls&dplnkId=d76010a3-d9c1-44d4-bac8-e4542a51e035

It's a bit vague but yes, this is correct as an outline.

I just replied to what I think was another similar question of yours. I'd strongly suggest finding a copy of https://www.amazon.com/Computer-Organization-Design-MIPS-Architecture/dp/0124077269

It's the more mild textbook from two of the biggest people in the computer engineering world. They're the people that invented RISC.

It's a pricey book but for the sorts of questions you're after, any edition from the 3rd on to newer should be fine.

Veja o primeiro capítulo da última edição desse livro

https://www.amazon.com/Computer-Organization-Design-MIPS-Architecture/dp/0124077269

Mobile em alta, desktop em baixa

This book was used in CPEN 211 last year. It is a very elaborate book and thoroughly covers introductory Computer Architecture topics.

We use vivado in school and they teach verilog. My impression is that VHDL is more of an industry standard, but I'm still a student so don't quote me on that. The way my university introduced digital logic was by having us start at logic gate level then use those modules to make state machines and last semester we made a MIPS processor.

Vivado (web pack should be free) https://www.xilinx.com/products/design-tools/vivado.html

Here is the book we used for the processor https://www.amazon.com/Computer-Organization-Design-Fifth-Architecture/dp/0124077269

https://www.amazon.com/gp/product/0124077269/ref=oh_aui_detailpage_o03_s00?ie=UTF8&psc=1

There is a PDF version floating around though.

All I could recommend you are the texts I picked up in college. I haven't looked for any other resources. That being said:

http://www.amazon.com/Computer-Organization-Design-Fifth-Architecture/dp/0124077269

This text is really only useful after learning some discrete math, but is THE book to learn algorithms:

http://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844

This one wasn't given to me in college, but at my first job. Really opened my eyes to OOD & software architecture:

http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612

This is a great one, we used this in computer architecture

http://www.amazon.com/Computer-Organization-Design-Fifth-Edition/dp/0124077269

I read this one in a class and really liked. http://www.amazon.com/Computer-Organization-Design-Fifth-Architecture/dp/0124077269/ But it may be a little heavy.

Sure, I just need you to teach me real analysis without getting too deep into calculus...

Probably start here: http://www.amazon.com/Computer-Organization-Design-Fifth-Edition/dp/0124077269