-
Notifications
You must be signed in to change notification settings - Fork 15
Elements of Computing Systems Chapter 5
Vaidas managed to buy Understanding Computation A great purchase nonetheless.
Chapter 4 and Von Neumann architectures throws the reader in at the deep end. We agreed that seeing the assembler and instruction set first clarifies the design in Chapter 5.
Is it a Von Neumann architecture or a Harvard architecture? In the book’s architecture the program data is stored in ROM and data is stored in RAM. Whereas it seems in Von Neumann the data and program reside in the same memory.
Murray reminded us that the computers that some of us started writing programs, e.g. the BBC Model B, on had their OS's on ROMs and so an OS upgrade meant replacing a chip.
Page 97/98 explains the difference between a general purpose and dedicated computer. They choose to use ROM and RAM rather than just RAM in order to have a single cycle fetch/execute logic.
Looking ahead: will Tetris be implemented in ROM. Or will our OS load it from somewhere else?
Memory mapping: what preceeded it?
What do we have to do in this chapter? To what extent will we have to think about fetch/execute?
decode
is a roundrect. What does this indicate?
Drew gets a crash course in HDL.
We took a look at our implementation of RAM16K for reference.
Another question of which is the most significant bit.
Had a brief conversation about tick/tock and whether they’re seen at all from outside.
We caused the test to hang by not implementing Keyboard in our Memory.
Turns out we’ve been getting the indexing the wrong way around all this time.
The Memory test has to be performed in the simulator because it requires us to interact (pressing keyboard and visually verifying screen).
We got Memory working but ran out of time and spent a little while deciding how to proceed. The group preferred meeting again sooner to tackle the rest of the exercise with it fresh in our heads.
With this in mind we plan to have a bonus Computation Club meeting on Tuesday 10th Feb at Geckoboard for those who wish to work through the rest of the exercises from chapter 5 together.
Then normal service will resume on Tuesday 24th Feb when we will look at Chapter 6.
Thanks to Leo for hosting us at Geckoboard's offices and thanks to Geckoboard, Jamie and Drew for providing refreshments and snacks.
- 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