I apologize for my ignorance in advance... I don't grasp what is meant by First Principles. I have googled the term of course, but their are myriad results and the definition seems to depend on context. Within the context of this book/course, what are "First Principles" and should I pursue them before I attempt to work my way through the course.
Thank you so much to anyone who can offer some direction. :-)
You are absolutely correct in thinking that the idea of "first principles" is highly dependent on context. The authors of the book and the associated course center their first principles on Boolean logic principles and binary arithmetic. They combine these, along with the idea of electronic logic gates and digital flip-flops, to build a simple computing device which is implemented in a computer-based simulator program.
There are levels of abstraction below the first principles adopted by the authors. For example, logic gates are actually implemented from transistors and other electronic devices. Similarly, Boolean logic is derived from lower-level mathematical ideas.
The course stands on its own without requiring an understanding of things at a lower level. As you proceed through it, you will sometimes be directed to the background areas that you might want to investigate. My advice would be to concentrate on the material presented and master it before moving to lower levels.
I second what rleininger has said and echo his recommendations.
In general, "first principles" is meant to imply that our foundation is a small collection of very basic, fundamental concepts, often given as axioms (meaning that we can't -- or at least don't bother to -- prove them and simply accept them as given), and then everything else is built starting from those axioms or things that have previously build built using those axioms. What we choose as our axioms is often a matter of some preference, but once chosen we have to live with them.
In this course there are two axioms -- a two-input Nand gate and a D-type flip flop. The behavior of these two devices is described and we accept that they behave as described. We then proceed to build up our computer piece by piece with everything being traceable back to combinations of those two parts eventually.
We actually break these rules a little bit here and there -- for instance, we are given a keyboard device and a screen device and we don't build those up from our two fundamental parts. We also have a clock signal and that signal does not come as a result of us building something up out of Nand and DFF components. But this is fine. The authors sidestep this by essentially saying that our computer lives in a box and there are things outside the box, like a keyboard and a screen display and a clock source, and those interact with what we have built inside the box in very specific and limited ways. The keyboard and screen interact only through the contents of specific RAM locations and the clock signal comes into our box and is distributed to every DFF in our computer.
The same is true for our software stack. We have an assembly language instruction set and we build a set of tools where the software eventually flows from a Jack source code file to a VM command file to an assembly language program, to a sequence of 16-bit instruction codes. We sidestep the notion of having the tools that we use to perform these translations being written in these languages, but that is minor since the goal is to understand the relationships between the levels of software abstraction that is running on our computer.
Thank you so much for the responses; I definitely feel confident moving forward with the lessons now with this fundamental understanding of what is meant by "first principals" - though I am sure I will return to the forum often as I work my way through each milestone.