notes and ac

_practice/2024-11-19.md

@@ -0,0 +1,5 @@
+1. Evaluate abstraction in some code that you are familiar with and, in {term}`abstraction.md` answer the following:
+- what are the details it hides
+- what concepts does it introduce
+- how does the abstraction help you understand and use the code?
+1. Find another example of a leaky abstraction (besides git) in programming or a hobby. You can use anything to find the example, but be sure that you understand the abstraction fully.   Explain the abstraction and why it is leaky in {term}`leakyabstraction.md`

_practice/2024-11-21.md

@@ -0,0 +1,4 @@
+*this is integrative-2*
+1. Create `in_five_years.md` and answer the following two questions: What do you think you will remember from this class in five years? What parts of this course's content do you think will change the most in five years?
+1. Reflect on how this course has impacted programming/debugging skills in `skillup.md`.  You can write this as how you think your own skill has improved **or** as if you are convincing another student to take this class. Touch on at least *three* topics.
+2. Submit a PR with either [advice to future students on how to succeed in the course](https://github.com/compsys-progtools/spring2024/blob/main/resources/testimonials.md) or [on why a student should take this course](https://github.com/compsys-progtoolsc/introcompsys.github.io/blob/main/fromstudents.md). Each of those is linked to where you should add your advice.

_prepare/2024-11-21.md

@@ -0,0 +1,2 @@
+```{index} 
+```

_prepare/2024-11-26.md

@@ -0,0 +1 @@
+Preview the [Stack Overflow Developer Survey](https://survey.stackoverflow.co/2023/#technology) Technology section parts that are about tools. Create {index}`dev_insights.md` with 3-5 bullet points for discussion.  These can be facts you found most interesting or questions you have based on the results (it can be clarifying or deeper questions)

_review/2024-11-19.md

@@ -0,0 +1 @@
+1. Find another example of a leaky abstraction (besides git) in programming or a hobby. You can use anything to find the example, but be sure that you understand the abstraction fully. Explain the abstraction and why it is leaky in `leakyabstraction.md`

_review/2024-11-21.md

@@ -0,0 +1,3 @@
+*this is integrative-2*
+1. Add `conclusion.md` to your KWL repo. In the file include 2 sections: (1) summary with an overall description of what you learned and how this course was/not helpful to you (paragraph or bullet form is fine) (2) key points with the top 10 thigns you want to make sure you remember from this class
+1. Reflect on how this course impacts programming/debugging skills in `skillup.md`.  You can write this as how you think your own skill has improved **or** as if you are convincing another student to take this class. Touch on at least *three* topics.

activities/practice.md

@@ -149,3 +149,18 @@ Activities:
 ```{include} ../_practice/2024-11-07.md
 ```
 
+
+## 2024-11-19
+
+[related notes](../notes/2024-11-19)
+
+Activities:
+```{include} ../_practice/2024-11-19.md
+```
+## 2024-11-21
+
+[related notes](../notes/2024-11-21)
+
+Activities:
+```{include} ../_practice/2024-11-21.md
+```

activities/prepare.md

@@ -119,4 +119,18 @@ Activities:
 
 Activities:
 ```{include} ../_prepare/2024-11-012.md
+```
+## 2024-11-21
+
+[related notes](../notes/2024-11-21)
+
+Activities:
+```{include} ../_prepare/2024-11-21.md
+```
+## 2024-11-26
+
+[related notes](../notes/2024-11-26)
+
+Activities:
+```{include} ../_prepare/2024-11-26.md
 ```

activities/review.md

@@ -147,3 +147,18 @@ Activities:
 ```{include} ../_review/2024-11-07.md
 ```
 
+
+## 2024-11-19
+
+[related notes](../notes/2024-11-19)
+
+Activities:
+```{include} ../_review/2024-11-19.md
+```
+## 2024-11-21
+
+[related notes](../notes/2024-11-21)
+
+Activities:
+```{include} ../_review/2024-11-21.md
+```

notes/2024-11-19.md

@@ -0,0 +1,83 @@
+---
+file_format: mystnb
+kernelspec:
+    name: python3
+---
+
+
+
+
++++{"lesson_part": "main","type":"heading"}
+
+## Why do we need to know about this? 
+
+
+- computers are not magic and edge cases help you see that
+- in case you want to do high performance programming
+- it's good practice with abstraction 
+
+
+
+
++++{"lesson_part": "main","type":"heading"}
+
+## Hardware vs Software abstraction
+
+
+Abstraction is to remove details and use higher level units 
+
+
+
+![abstraction layers](../img/)
+
+
++++{"lesson_part": "main"}
+
+
+in hardware our abstractions are less leaky becuase it is less forgiving.  
+
+software abstractions can suffer from leaks; think git- it's hard to learn because the abstraction is leaky. 
+
+
+
++++{"lesson_part": "main"}
+
+
+a lot of programming is *designing* abstractions, to get good at making something, you study examples first- good and bad- to learn what to do, and not to do. 
+
+
++++{"lesson_part": "main"}
+
+[leaky abstractions](https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions/)
+
+
+- the above is a blog post by one of the co-founders and the 2010-2019 CEO of Stack Overflow [Joel Spolsky](https://www.joelonsoftware.com/about-me/)
+
+
+
+## Prepare for Next Class 
+
+```{include} ../_prepare/2024-11-21.md
+```
+
+## Badges
+
+`````{tab-set}
+````{tab-item} Review
+```{include} ../_review/2024-11-19.md
+```
+
+````
+
+````{tab-item} Practice
+```{include} ../_practice/2024-11-19.md
+```
+
+````
+`````
+
+
+
+## Experience Report Evidence
+
+## Questions After Today's Class 

notes/2024-11-21.md

@@ -0,0 +1,132 @@
+---
+file_format: mystnb
+kernelspec:
+    name: python3
+---
+
+
+
++++{"lesson_part": "main","type":"heading"}
+
+## How to store a value 
+
+
+
++++{"lesson_part": "main"}
+
+
+We need a few more components: 
+
+- [mux](https://lodev.org/logicemu/#id=mux) select one of two values
+- [flip-flop](https://lodev.org/logicemu/#) hold a value until told otherwise
+
+
+
+
++++{"lesson_part": "main"}
+
+
+[register](https://lodev.org/logicemu/#id=register)
+
+
+
++++{"lesson_part": "main"}
+
+
+this gives us SRAM which can hold a value as long as the system has power 
+(1963)
+
+
+
++++{"lesson_part": "main","type":"heading"}
+
+## another way to physically store a value 
+
+
++++{"lesson_part": "main"}
+
+
+DRAM uses one transistor and one capacitor. (SRAM uses 4-6 transistors)
+
+a capacitor holds a charge for a time, but gradually fades, so it has to be refreshed
+
+
+
++++{"lesson_part": "main"}
+
+ROM is a diode matrix traditionally
+- hardward encodes the instructions
+- cannot be changed without rewiring
+
++++{"lesson_part": "main"}
+
+PROM
+- can be reprogrammed once after device is made
+- used for firmware/microcode
+
+(programmable ROM)
+
++++{"lesson_part": "main"}
+EPROM or EEPROM
+- treated like ROM
+- can be erased & reprogrammed
+- but not infinitely, very limited number of tmes
+- holds value when power goes away, UV light or electriciy can re-program
+
+
++++{"lesson_part": "main"}
+
+SRAM:
+
+- is volatile; it needs power to hold a value
+- is fast 
+- takes up more space on the chip (uses 4-6 transistors per bit)
+- typically used of cache and internal registers
+
++++{"lesson_part": "main"}
+DRAM: 
+- is volatile;  it needs power to hold a value
+- is slower and requires a refresh
+- is small (1 transistor + 1 capacitor per bit) and space efficient
+- used for the main RAM
+
++++{"lesson_part": "main"}
+
+Flash memory 
+- non-volatile; holds a value without power, can be electircally erased and re-programmed
+- comprised of memory "cells" in layerd boards
+- memory cells are mosfets - a different type of transistor that retains a state after power is removed and put bag
+- implemented with EEPROM 
+- designed for large blocks and limited writes (~10k)
+- used for ssd, usb flash drives, smartphones, etc
+- slow to write, fast to read
+
+
+
+
+## Prepare for Next Class 
+
+```{include} ../_prepare/2024-11-26.md
+```
+
+## Badges
+
+`````{tab-set}
+````{tab-item} Review
+```{include} ../_review/2024-11-21.md
+```
+
+````
+
+````{tab-item} Practice
+```{include} ../_practice/2024-11-21.md
+```
+
+````
+`````
+
+
+
+## Experience Report Evidence
+
+## Questions After Today's Class