9. Why are these tools organized this way?#
Today we’re going to do a bit more practical stuff, but we are also going to start to get into the philosophy of how things are organized.
Understanding the context and principles will help you:
remember how to do things
form reliable hypotheses about how to fix problems you have not seen before
help you understand when you should do things as they have always been done and when you should challenge and change things.
9.1. Admin#
Important
An issue or PR is always welcome and worth a community badge if I make a release and the website does not update
Note
I used mulitple cursors to type out that checklist by copying from the _toc.yml file and then editing each line to start - [ ] fix instead of - file
9.2. Why should we study design?#
it is easy to get distracted by implementation, syntax, algorithms
but the core principles of design organize ideas into simpler rules
9.3. Why are we studying developer tools?#
Recall:
The best way to learn design is to study examples [Schon1984, Petre2016], and some of the best examples of software design come from the tools programmers use in their own work.
note
we will talk about some history in this course
I will not take a “great men of history” approach
This is because:
I think that history is important context for making decisions
Many of these “great men” are actually, in many ways, Not Great^TM
It is important to remember that all of this work was done by people
all people are imperfect
when people are deeply influential, ignoring their role in history is not effective, we cannot undo what they did
we do not have to admire them or even say their names to acknowledge the work
computing technology has been used in Very Bad ways and in Definitely Good ways
9.4. Unix Philosophy#
sources:
composability over monolithic design
social conventions
The tenets:
Make it easy to write, test, and run programs.
Interactive use instead of batch processing.
Economy and elegance of design due to size constraints (“salvation through suffering”).
Self-supporting system: all Unix software is maintained under Unix.
For better or worse this is dominant, so understanding this is important.
Also, this critique is written that unix is not a good system for “normal folks” not in its effectiveness as a context for developers which is where *nix (unix, linux) systems remain popular.
“normal folks” is the author’s term presumably attempting to describe a typical, nondeveloper computer user
If you have the gh CLI installed and working locally, open the terminal that it works in and navigate to your KWL repo.
If you do not have that working locally, open a codespace on the main branch of your KWL repo
(I have it working locally and working locally lets me save my terminal output for the notes more easily)
cat the action file that posts your badges
cd Documents/inclass/systems/fa23-kwl-brownsarahm/
then check the repo’s status
git status
On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean
cat .github/workflows/getassignment.yml
name: Create badge issues (Edit before Running)
on:
workflow_dispatch
# once you edit, change the name
jobs:
check-contents:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
# Install dependencies
- name: Set up Python 3.9
uses: actions/setup-python@v1
with:
python-version: 3.9
- name: Install Utils
run: |
pip install git+https://github.com/introcompsys/courseutils@main
- name: Get badge requirements
run: |
pretitle="prepare-"$(date +"%Y-%m-%d")
sysgetassignment | gh issue create --title $pretitle --label prepare --body-file -
rtitle="review-"$(date +"%Y-%m-%d")
sysgetassignment --type review | gh issue create --title $rtitle --label review --body-file -
pratitle="practice-"$(date +"%Y-%m-%d")
sysgetassignment --type practice| gh issue create --title $pratitle --label practice --body-file -
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
# edit the run step above for the level(s) you want.
# You should keep the prepare, because they are required for experience badges
# You may choose to get only the review or only the practice (and change this any time)
gh
Work seamlessly with GitHub from the command line.
USAGE
gh <command> <subcommand> [flags]
CORE COMMANDS
auth: Authenticate gh and git with GitHub
browse: Open the repository in the browser
codespace: Connect to and manage codespaces
gist: Manage gists
issue: Manage issues
org: Manage organizations
pr: Manage pull requests
project: Work with GitHub Projects.
release: Manage releases
repo: Manage repositories
GITHUB ACTIONS COMMANDS
cache: Manage Github Actions caches
run: View details about workflow runs
workflow: View details about GitHub Actions workflows
EXTENSION COMMANDS
classroom: Extension classroom
ALIAS COMMANDS
co: Alias for "pr checkout"
ADDITIONAL COMMANDS
alias: Create command shortcuts
api: Make an authenticated GitHub API request
completion: Generate shell completion scripts
config: Manage configuration for gh
extension: Manage gh extensions
gpg-key: Manage GPG keys
label: Manage labels
ruleset: View info about repo rulesets
search: Search for repositories, issues, and pull requests
secret: Manage GitHub secrets
ssh-key: Manage SSH keys
status: Print information about relevant issues, pull requests, and notifications across repositories
variable: Manage GitHub Actions variables
HELP TOPICS
actions: Learn about working with GitHub Actions
environment: Environment variables that can be used with gh
exit-codes: Exit codes used by gh
formatting: Formatting options for JSON data exported from gh
mintty: Information about using gh with MinTTY
reference: A comprehensive reference of all gh commands
FLAGS
--help Show help for command
--version Show gh version
EXAMPLES
$ gh issue create
$ gh repo clone cli/cli
$ gh pr checkout 321
LEARN MORE
Use 'gh <command> <subcommand> --help' for more information about a command.
Read the manual at https://cli.github.com/manual
gh
Work seamlessly with GitHub from the command line.
USAGE
gh <command> <subcommand> [flags]
CORE COMMANDS
auth: Authenticate gh and git with GitHub
browse: Open the repository in the browser
codespace: Connect to and manage codespaces
gist: Manage gists
issue: Manage issues
org: Manage organizations
pr: Manage pull requests
project: Work with GitHub Projects.
release: Manage releases
repo: Manage repositories
GITHUB ACTIONS COMMANDS
cache: Manage Github Actions caches
run: View details about workflow runs
workflow: View details about GitHub Actions workflows
EXTENSION COMMANDS
classroom: Extension classroom
ALIAS COMMANDS
co: Alias for "pr checkout"
ADDITIONAL COMMANDS
alias: Create command shortcuts
api: Make an authenticated GitHub API request
completion: Generate shell completion scripts
config: Manage configuration for gh
extension: Manage gh extensions
gpg-key: Manage GPG keys
label: Manage labels
ruleset: View info about repo rulesets
search: Search for repositories, issues, and pull requests
secret: Manage GitHub secrets
ssh-key: Manage SSH keys
status: Print information about relevant issues, pull requests, and notifications across repositories
variable: Manage GitHub Actions variables
HELP TOPICS
actions: Learn about working with GitHub Actions
environment: Environment variables that can be used with gh
exit-codes: Exit codes used by gh
formatting: Formatting options for JSON data exported from gh
mintty: Information about using gh with MinTTY
reference: A comprehensive reference of all gh commands
FLAGS
--help Show help for command
--version Show gh version
EXAMPLES
$ gh issue create
$ gh repo clone cli/cli
$ gh pr checkout 321
LEARN MORE
Use 'gh <command> <subcommand> --help' for more information about a command.
Read the manual at https://cli.github.com/manual
cd fa23-kwl-brownsarahm/
-bash: cd: fa23-kwl-brownsarahm/: No such file or directory
pwd
/Users/brownsarahm/Documents/inclass/systems/fa23-kwl-brownsarahm
cat .github/workflows/getassignment.yml
name: Create badge issues (Edit before Running)
on:
workflow_dispatch
# once you edit, change the name
jobs:
check-contents:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
# Install dependencies
- name: Set up Python 3.9
uses: actions/setup-python@v1
with:
python-version: 3.9
- name: Install Utils
run: |
pip install git+https://github.com/introcompsys/courseutils@main
- name: Get badge requirements
run: |
pretitle="prepare-"$(date +"%Y-%m-%d")
sysgetassignment | gh issue create --title $pretitle --label prepare --body-file -
rtitle="review-"$(date +"%Y-%m-%d")
sysgetassignment --type review | gh issue create --title $rtitle --label review --body-file -
pratitle="practice-"$(date +"%Y-%m-%d")
sysgetassignment --type practice| gh issue create --title $pratitle --label practice --body-file -
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
# edit the run step above for the level(s) you want.
# You should keep the prepare, because they are required for experience badges
# You may choose to get only the review or only the practice (and change this any time)
history | gh issue create --title example --body-file -
Creating issue in introcompsys/fa23-kwl-brownsarahm
https://github.com/introcompsys/fa23-kwl-brownsarahm/issues/32
We can use gh commands without an option to get the help for how to use them.
gh issue
Work with GitHub issues.
USAGE
gh issue <command> [flags]
GENERAL COMMANDS
create: Create a new issue
list: List issues in a repository
status: Show status of relevant issues
TARGETED COMMANDS
close: Close issue
comment: Add a comment to an issue
delete: Delete issue
develop: Manage linked branches for an issue
edit: Edit issues
lock: Lock issue conversation
pin: Pin a issue
reopen: Reopen issue
transfer: Transfer issue to another repository
unlock: Unlock issue conversation
unpin: Unpin a issue
view: View an issue
FLAGS
-R, --repo [HOST/]OWNER/REPO Select another repository using the [HOST/]OWNER/REPO format
INHERITED FLAGS
--help Show help for command
ARGUMENTS
An issue can be supplied as argument in any of the following formats:
- by number, e.g. "123"; or
- by URL, e.g. "https://github.com/OWNER/REPO/issues/123".
EXAMPLES
$ gh issue list
$ gh issue create --label bug
$ gh issue view 123 --web
LEARN MORE
Use 'gh <command> <subcommand> --help' for more information about a command.
Read the manual at https://cli.github.com/manual
gh issue view
accepts 1 arg(s), received 0
gh issue view 32
example #32
Open • brownsarahm opened about 2 minutes ago • 0 comments
762 gh
763 gh
764 cd fa23-kwl-brownsarahm/
765 pwd
766 cat .github/workflows/getassignment.yml
767 history | gh issue create --title example --body-file -
View this issue on GitHub: https://github.com/introcompsys/fa23-kwl-brownsarahm/issues/32
We can see how this group of commands work with
gh issue
Work with GitHub issues.
USAGE
gh issue <command> [flags]
GENERAL COMMANDS
create: Create a new issue
list: List issues in a repository
status: Show status of relevant issues
TARGETED COMMANDS
close: Close issue
comment: Add a comment to an issue
delete: Delete issue
develop: Manage linked branches for an issue
edit: Edit issues
lock: Lock issue conversation
pin: Pin a issue
reopen: Reopen issue
transfer: Transfer issue to another repository
unlock: Unlock issue conversation
unpin: Unpin a issue
view: View an issue
FLAGS
-R, --repo [HOST/]OWNER/REPO Select another repository using the [HOST/]OWNER/REPO format
INHERITED FLAGS
--help Show help for command
ARGUMENTS
An issue can be supplied as argument in any of the following formats:
- by number, e.g. "123"; or
- by URL, e.g. "https://github.com/OWNER/REPO/issues/123".
EXAMPLES
$ gh issue list
$ gh issue create --label bug
$ gh issue view 123 --web
LEARN MORE
Use 'gh <command> <subcommand> --help' for more information about a command.
Read the manual at https://cli.github.com/manual
gh issue close 32
✓ Closed issue #32 (example)
cat .github/workflows/getassignment.yml
name: Create badge issues (Edit before Running)
on:
workflow_dispatch
# once you edit, change the name
jobs:
check-contents:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
# Install dependencies
- name: Set up Python 3.9
uses: actions/setup-python@v1
with:
python-version: 3.9
- name: Install Utils
run: |
pip install git+https://github.com/introcompsys/courseutils@main
- name: Get badge requirements
run: |
pretitle="prepare-"$(date +"%Y-%m-%d")
sysgetassignment | gh issue create --title $pretitle --label prepare --body-file -
rtitle="review-"$(date +"%Y-%m-%d")
sysgetassignment --type review | gh issue create --title $rtitle --label review --body-file -
pratitle="practice-"$(date +"%Y-%m-%d")
sysgetassignment --type practice| gh issue create --title $pratitle --label practice --body-file -
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
# edit the run step above for the level(s) you want.
# You should keep the prepare, because they are required for experience badges
# You may choose to get only the review or only the practice (and change this any time)
gh issue list
Showing 28 of 28 open issues in introcompsys/fa23-kwl-brownsarahm
#31 practice-2023-10-04 practice about 1 day ago
#30 review-2023-10-04 review about 1 day ago
#29 prepare-2023-10-04 prepare about 1 day ago
#28 Lab 4 about 5 days ago
#27 practice-2023-09-29 practice about 5 days ago
#26 review-2023-09-29 review about 5 days ago
#25 prepare-2023-09-29 prepare about 5 days ago
#24 practice-2023-09-27 practice about 8 days ago
#23 review-2023-09-27 review about 8 days ago
#22 prepare-2023-09-27 prepare about 8 days ago
#21 Lab 3 about 12 days ago
#20 practice-2023-09-22 practice about 13 days ago
#19 review-2023-09-22 review about 13 days ago
#18 prepare-2023-09-22 prepare about 13 days ago
#17 practice-2023-09-20 practice about 15 days ago
#16 review-2023-09-20 review about 15 days ago
#15 prepare-2023-09-20 prepare about 15 days ago
#14 Lab 2 about 19 days ago
#13 practice-2023-09-15 practice about 20 days ago
#12 review-2023-09-15 review about 20 days ago
#11 prepare-2023-09-15 prepare about 20 days ago
#10 practice-2023-09-13 practice about 22 days ago
#9 review-2023-09-13 review about 22 days ago
#8 prepare-2023-09-13 prepare about 22 days ago
#7 practice-2023-09-07 practice about 26 days ago
#6 review-2023-09-07 review about 26 days ago
#5 prepare-2023-09-08 prepare about 26 days ago
#4 Lab 1 about 26 days ago
Important
This part did not happen in class due to time, but is still important.
We will see these commands again, but this reference will be useful in lab
9.4.1. Processing issues on the terminal#
We can use a pipe to also get a count of the issues using the wc command which is for word count and its -l option to count lines instead.
gh issue list | wc -l
28
Or we can filter to get a subset of them using grep to filter. By default grep searches std in, so when we use it with a pipe it works well.
gh issue list | grep 'prepare'
29 OPEN prepare-2023-10-04 prepare 2023-10-04 02:38:50 +0000 UTC
25 OPEN prepare-2023-09-29 prepare 2023-09-29 17:52:35 +0000 UTC
22 OPEN prepare-2023-09-27 prepare 2023-09-27 03:25:47 +0000 UTC
18 OPEN prepare-2023-09-22 prepare 2023-09-22 11:11:52 +0000 UTC
15 OPEN prepare-2023-09-20 prepare 2023-09-20 02:00:07 +0000 UTC
11 OPEN prepare-2023-09-15 prepare 2023-09-15 02:06:05 +0000 UTC
8 OPEN prepare-2023-09-13 prepare 2023-09-13 01:42:24 +0000 UTC
5 OPEN prepare-2023-09-08 prepare 2023-09-08 22:11:50 +0000 UTC
Important
You should have fewer prepare than me, in this list becaues by default we only see the open ones
we can use gh issue list --help to see more options
List issues in a GitHub repository.
The search query syntax is documented here:
<https://docs.github.com/en/search-github/searching-on-github/searching-issues-and-pull-requests>
For more information about output formatting flags, see `gh help formatting`.
USAGE
gh issue list [flags]
FLAGS
--app string Filter by GitHub App author
-a, --assignee string Filter by assignee
-A, --author string Filter by author
-q, --jq expression Filter JSON output using a jq expression
--json fields Output JSON with the specified fields
-l, --label strings Filter by label
-L, --limit int Maximum number of issues to fetch (default 30)
--mention string Filter by mention
-m, --milestone string Filter by milestone number or title
-S, --search query Search issues with query
-s, --state string Filter by state: {open|closed|all} (default "open")
-t, --template string Format JSON output using a Go template; see "gh help formatting"
-w, --web List issues in the web browser
INHERITED FLAGS
--help Show help for command
-R, --repo [HOST/]OWNER/REPO Select another repository using the [HOST/]OWNER/REPO format
EXAMPLES
$ gh issue list --label "bug" --label "help wanted"
$ gh issue list --author monalisa
$ gh issue list --assignee "@me"
$ gh issue list --milestone "The big 1.0"
$ gh issue list --search "error no:assignee sort:created-asc"
LEARN MORE
Use 'gh <command> <subcommand> --help' for more information about a command.
Read the manual at https://cli.github.com/manual
and then we can use the -s flag set to all to see all to make yours match mine.
9.5. How do we Study (computer) Systems#
When we think of something as a system, we can study it different ways:
input/output behavior
components
abstraction layers
These basic ideas apply whether a computer system or not. We can probe things in different ways.
In a lot of disciplines people are taught one or the other, or they divide professionally into theorists or experimentalists along the lines.
People are the most effective at working with, within, and manipulating systems when they have multiple ways to achieve the same goal.
These are not mutually exclusive, we will use them all together and trade off.
When we study a system we can do so in two main ways. We can look at the input/output behavior of the system as a whole and we can look at the individual components. For each component, we can look at its behavior or the subcomponents. We can take what we know from all fo the components and piece that together. However, for a complex system, we cannot match individual components up to the high level behavior. This is true in both computers and other complex systems. In the first computers in the 1940s, the only things they did was arithmetic and you could match from their components al the way up pretty easily. Modern computers connect to the internet, send signals, load complex graphics, play sounds and many other things that are harder to decompose all at once. Outside of computers, scientists have a pretty good idea of how neurons work and that appears to be the same across mammals and other species (eg squid) but we do not understand how the whole brain of a mammal works, not even smaller mammals with less complex social lives than humans. Understanding the parts is not always enough to understand all of the complex ways the parts can work together. Computers are much less complicated than brains. They were made by brains.
But that fact motivates another way to study a complex system, across levels of abstraction. You can abstract away details and focus on one representation. This can be tied literally to components, but it can also be conceptual. For example, in CSC211 you use a model of stack and heap for memory. It’s useful for understanding programming, but is not exactly what the hardware does. At times, it is even more useful though than understanding exactly what the hardware does. These abstractions also serve a social, practical purpose. In computing, and society at large really, we use standards these are sets of guidelines for how to build things. Like when you use a function, you need to know it’s API and what it is supposed to do in order to use it. The developers could change how it does that without impacting your program, as long as the API is not changed and the high level input/output behavior stays the same.
9.5.1. Behavior#
Try something, see what happens
This is probably how you first learned to use a computer. Maybe a parent showed you how to do a few things, but then you probably tried other things. For most of you, this may have been when you were very young and much less afraid of breaking things. Over time you learned how to do things and what behaviors to expect. You also learned categories of things. Like once you learned one social media app and that others were also social media you then looked for similar features. Maybe you learned one video game had the option to save and expected it in the next one.
Video games and social media are classes or categories of software and each game and app are instances. Similarly, an Integrated Development Environment (IDE) is a category of software and VS Code, … are instances. Also, version control is a category of software and git is an instance. A git host is also a category and GitHub is an instance. Just as before you were worried about details you transferred features from one instance to another within categories, I want you to think about what you know from one IDE and how that would help you learn another. We will study the actual features of IDE a=and what you might want to know about them so that you can choose your own. Becoming a more independent developer you’ll start to have your own opinions about which one is better. Think about about a person in your life who finds computers and technology overall intimidating or frustrating. They likely only use one social media app if at all, or maybe they only know to make documents in Microsoft word and they think that Google Docs is too much to learn, because they didn’t transfer ideas from one to the other.
We have focused on the behavior of individual applications to this point, but there is also the overall behavior of the system in broad terms, typing on the keyboard we expect the characters to show (and when they don’t for example in a shell password, we’re surprised and concerned it is not working).
9.5.2. Components#
Take it apart, asess the pieces
We have the high level parts: keyboard, mouse, monitor/screen, tower/computer. Inside we also tend to know there is a power supply, a motherboard, graphics card, memory, etc.
We can study how each of these parts works while not worrying about the others but having them there. This is probably how you learned to use a mouse. You focused your attention on the mouse and saw what else happened.
Or we can take an individual component and isolate it to study it alone. For a mouse this would be hard. Without a computer attached its output is not very visible. To do this, we would need additional tools to interpret its output and examine it. Most computer components actually would need additional tools, to measure the electrical signals, but we could examine what happens at each part one at a time to then build up what they do.
This idea, however that we can use another tool to understand each component is an important one. This is also a way to again, take care and study each piece even within a software-alone system without worrying about the hardware.
9.5.3. Abstraction#
use a model
As we talked about the behavior and abstraction, we talked some about software and some about hardware. These are the two coarsest ways we can think about a computer system at different levels of abstraction. We can think about it only in physical terms and examine the patterns of electricity flow or we can think about only the software and not worry about the hardware, at a higher level of abstraction.
However, two levels is not really enough to understand how computer systems are designed.
Application - the software you run.
Algorithm - the way that it is implemented, in mathematical level
Programming language - the way that it is implemented for a computer.
Machine code translates to binary from assembly.
After the Programming language level, there is assembly. The advantage to assembly is that it is hardware independent and human readable. It is low level and limited to what the hardware can do, but it is a version of that that can be run on different hardware. It is much lower level. When you compile a program, it is translated to assembly. At this level, programs written in different level become indistinguishable. This has much lower level operations. We can do various calculations, but not things like compare. Things that were one step before, like assign become two, choose a memory location, then write to memory. This level of abstraction is the level of detail we will think about most. We’ll look at the others, but spend much less time below here.
The instruction set architecture is, notice, where the line between software and hardware lives. This is because these are specific to the actual hardware, this is the level where there are different instructions if you have an Intel chip vs an Apple chip. This level reduces down the instructions even more specifically to the specifics things that an individual piece of hardware does and how they dit.
The microarchitecture is the specific circuits: networks of smaller individual components. Again, we can treat the components as blocks and focus on how they work together. At this level we still have calculations like add, multiply, compare, negate, and we can store values and read them. That is all we have at this point though. At this level there are all binary numbers.
The actual gates (components that implement logical operations) and registers (components that hold values) break everything down to logical operations. Instead of adding, we have a series of and, nand, or, and xor put together over individual bits. Instead of numbers, we have registers that store individual zeros or ones. In a modern digital, electrical computer, at this level we have to actually watch the flow of electricity through the circuit and worry about things like the number of gates and whether or not the calculations finish at the same time or having other parts wait so that they are all working together. We will see later that when we try to allow multiple cores to work independently, we have to handle these timing issues at the higher levels as well. However, a register and gate can be implemented in different ways at the device level.
The device (or transistor in modern electrical digital computers) level, is where things transition between analog and digital. The world we live in is actually all analog. We just pay attention to lots of things at a time scale at which they appear to be be digital. Over time devices have changed from mechanical switches to electronic transistors. Material science innovations at the physics level have improved the transistors further over time, allowing them to be smaller and more heat efficient. Because of abstraction, these changes could be plugged into new hardware without having to make any changes at any software levels. However, they do enable improvements at the higher levels.
9.6. Prepare for Next Class#
note this is posted on 2023-10-05 because October 10th is a “Monday” for URI classes
Read the notes from October 5 and October 3. We will build on both of them on October 12. Make sure you have completed all of the steps in the github inclass repo from September too.
Start recording notes on how you use IDEs for the next couple of weeks using the template file below. We will come back to these notes in class later, but it is best to record over a time period instead of trying to remember at that time. Store your notes in your kwl repo in idethoughts.md on an
ide_prepbranch. This is prep for much later, it does not go in the October 12 experience branch
9.7. Review today’s class#
Read today’s notes when they are posted.
Add to your software.md a section about if that project does or does not adhere to the unix philosophy.
create methods.md and answer the following:
- which of the three methods for studying a system do you use most often when debugging?
- do you think using a different strategy might help you debug faster sometimes? why or why not?
9.8. More Practice#
Add to your software.md a section about if that project does or does not adhere to the unix philosophy and why. You can see what badge it was previously assigned in and the instructions on the KWL file list.
create methods.md and answer the following:
- which of the three methods for studying a system do you use most often when debugging?
- which do you use when you are trying to understand something new?
- do you think the ones you use most often are consistently effective? why or why not? When do they work or not work?
- what are you most interested in trying that might be different?
9.9. Experience Report Evidence#
Give examples of how you have used different ways of understanding things.
9.10. Questions After Today’s Class#
9.10.1. Why would we need to know about the lower layers of hardware and software if there are abstractions in place for us?#
This is a great question!
Most of the time that is exactly the advantage to the abstractions, but you typically need to know about the things at least in the adjacent levels. Some times knowing about more layers can help you make better design choices or understand edge case behavior. We will see some of those throught the rest of the semester.
Another part of why we teach these things in a CS degree is so that you can make a more informed choice about what you want to specialize in later, too.
9.10.2. what an example of Instruction set architecture#
the x86 isa is an example.
9.10.3. How to install gh?#
9.10.4. How often do software engineers touch machine code?#
Software engineers is a very broad category. If you write drivers, that might be very different than if you write front ends.
If you write compilers, again another very different amount.
9.10.5. how physics play into abstraction#
The actual physics of how electricity works is the lowest level of abstraction, or most concrete/least abstract way to describe how a computer works.
9.10.6. why do brew and gh keep uninstalling from my terminal?#
This might be a setting somewhere in your system that erases or resets things? If you find the answer to this and add it as an FAQ, that is worth a community badge.
9.10.7. Should I install the gh CLI?#
You can, it’s a little harder on Windows, but possible.
9.10.8. What is a GUI based tool?#
GUI stands for graphical user interface. Everything on a modern compputer except the terminal is a GUI.
9.10.9. Is it useful to create models during the process of development, or is it mostly useful after the fact?#
Models are often made before things are built. Sometimes they are refined after, but usually they are used to guide the development.
9.10.10. How deep should we really understand abstraction layers and how useful is it as a developer to know it?#
We will see them again and they will come up at least implicitly in other classes as well. It is important to know that they exist and what they are for sure. How much you directly interact with them will vary though.
9.10.11. How will our view on memory change with abstraction as we get to the higher level classes?#
We will talk about the physical device that implements memory later and you will learn more about it again in 411 if you take that.