-
Notifications
You must be signed in to change notification settings - Fork 15
Elements of Computing Systems Chapter 5b
We welcomed back Tom and James who missed our previous meeting (Elements of Computing Systems Chapter 5) and briefly recapped what progress we had made. We briefly discussed the issues we'd had last week, keen to avoid making the same mistakes again, especially focussing on improving our debugging ability (as so much time was spent being unsure of whether there was a bug in the simulator or in our code).
After a quick run-through of our completed Memory, we started to tackle the rest of the Computer.
We began by discussing our plan of attack for the CPU: debating whether to start with a simple Decoder
chip and then implementing the proposed architecture from the book. While it would give us a small unit to start with, we decided against extracting this so early on as it seemed premature without knowing how the rest of the CPU connected together. With that in mind, we worked backwards from the outputs of the book's proposed architecture, simply stubbing out internal wires with false
as we went.
We then used the tests provided with the project to guide us closer to the solution, implementing functionality in the sequence it was used in the test script.
There was some frustration as we hit test failures and were guilty of using trial and error to proceed but there was a call for clearer understanding before we simply raced ahead. By methodically using test failures and implementing only the functionality to make that test pass, we tried to avoid introducing too much complexity at once.
At 8:29 pm (after our most difficult exercise yet), we managed to make all tests pass for the CPU: https://github.com/computationclub/nand2tetris/commit/f0b8420efd5e24951259a1ce7c439eaeeb559142
As we won't be revisiting this material again in the next meeting, we decided to push on to glue together the final piece: the Computer
itself as it largely just wires together existing chips. Thankfully, mere minutes later, we had our Computer
: https://github.com/computationclub/nand2tetris/commit/9930339b786c0dfc76f05e635b2fa201dd68902c What's more, we saw it draw a little rectangle on screen and felt triumph in our collective hearts.
We discussed the possibility of refactoring our solution by extracting the decoding and jump logic into separate chips which might produce more readable code (forcing us to name the various instruction
pins) but this was relegated to extracurricular homework as we'll be moving onto the next chapter in our next meeting.
Thanks again to Leo and Geckoboard for hosting the meeting and James for driving the simulator.
- Home
- Documentation
- Choosing a Topic
- Shows & Tells
- Miscellaneous
- Opt Art
- Reinforcement Learning: An Introduction
- 10 Technical Papers Every Programmer Should Read (At Least Twice)
- 7 More Languages in 7 Weeks
- Lua, Day 1: The Call to Adventure
- Lua, Day 2: Tables All the Way Down
- Lua, Day 3
- Factor, Day 1: Stack On, Stack Off
- Factor, Day 2: Painting the Fence
- Factor, Day 3: Balancing on a Boat
- Elm, Day 1: Handling the Basics
- Elm, Day 2: The Elm Architecture
- Elm, Day 3: The Elm Architecture
- Elixir, Day 1: Laying a Great Foundation
- Elixir, Day 2: Controlling Mutations
- Elixir, Day 3: Spawning and Respawning
- Julia, Day 1: Resistance Is Futile
- Julia, Day 2: Getting Assimilated
- Julia, Day 3: Become One With Julia
- Minikanren, Days 1-3
- Minikanren, Einstein's Puzzle
- Idris Days 1-2
- Types and Programming Languages
- Chapter 1: Introduction
- Chapter 2: Mathematical Preliminaries
- Chapter 3: Untyped Arithmetic Expressions
- Chapter 4: An ML Implementation of Arithmetic Expressions
- Chapter 5: The Untyped Lambda-Calculus
- Chapters 6 & 7: De Bruijn Indices and an ML Implementation of the Lambda-Calculus
- Chapter 8: Typed Arithmetic Expressions
- Chapter 9: The Simply-Typed Lambda Calculus
- Chapter 10: An ML Implementation of Simple Types
- Chapter 11: Simple Extensions
- Chapter 11 Redux: Simple Extensions
- Chapter 13: References
- Chapter 14: Exceptions
- Chapter 15: Subtyping – Part 1
- Chapter 15: Subtyping – Part 2
- Chapter 16: The Metatheory of Subtyping
- Chapter 16: Implementation
- Chapter 18: Case Study: Imperative Objects
- Chapter 19: Case Study: Featherweight Java
- The New Turing Omnibus
- Errata
- Chapter 11: Search Trees
- Chapter 8: Random Numbers
- Chapter 35: Sequential Sorting
- Chapter 58: Predicate Calculus
- Chapter 27: Perceptrons
- Chapter 9: Mathematical Research
- Chapter 16: Genetic Algorithms
- Chapter 37: Public Key Cryptography
- Chapter 6: Game Trees
- Chapter 5: Gödel's Theorem
- Chapter 34: Satisfiability (also featuring: Sentient)
- Chapter 44: Cellular Automata
- Chapter 47: Storing Images
- Chapter 12: Error-Correcting Codes
- Chapter 32: The Fast Fourier Transform
- Chapter 36: Neural Networks That Learn
- Chapter 41: NP-Completeness
- Chapter 55: Iteration and Recursion
- Chapter 19: Computer Vision
- Chapter 61: Searching Strings
- Chapter 66: Church's Thesis
- Chapter 52: Text Compression
- Chapter 22: Minimum spanning tree
- Chapter 64: Logic Programming
- Chapter 60: Computer Viruses
- Show & Tell
- Elements of Computing Systems
- Archived pages