feat: Added cs61a

Author: mdrkrg

constants/nav.ts

@@ -11,37 +11,78 @@ export const sidebar: DefaultTheme.Sidebar = [
     text: 'Computer Science & Software Engineering',
     items: [
       {
-        text: 'CS106B',
+        text: 'CS61A: Structure and Interpretation of Computer Programs',
+        link: '/pages/coding/cs61a/info',
+        collapsed: true,
+        items: [
+          {
+            text: 'Python',
+            collapsed: true,
+            items: await getNavItems(`${noteRootDir}/coding/cs61a/src/python`),
+          },
+          {
+            text: 'Programming Ideas',
+            collapsed: true,
+            items: await getNavItems(`${noteRootDir}/coding/cs61a/src/programming`),
+          },
+          {
+            text: 'Object Oriented Programming',
+            collapsed: true,
+            items: await getNavItems(`${noteRootDir}/coding/cs61a/src/oop`),
+          },
+          {
+            text: 'Data Structures',
+            collapsed: true,
+            items: await getNavItems(`${noteRootDir}/coding/cs61a/src/ds`),
+          },
+          {
+            text: 'Scheme',
+            collapsed: true,
+            items: await getNavItems(`${noteRootDir}/coding/cs61a/src/scheme`),
+          },
+          {
+            text: 'Labs and HW Reflection',
+            collapsed: true,
+            items: await getNavItems(`${noteRootDir}/coding/cs61a/src/labs`),
+          },
+        ]
+      },
+      {
+        text: 'CS106B: Programming Abstractions in C++',
         link: '/pages/coding/cs106b/info',
         collapsed: true,
         items: await getNavItems(`${noteRootDir}/coding/cs106b/src/`),
       },
       {
-        text: 'CS61B',
+        text: 'CS61B: Data Structures and Algorightm',
         link: '/pages/coding/cs61b/info',
         collapsed: true,
         items: [
           {
             text: 'Java',
+            collapsed: true,
             items: await getNavItems(`${noteRootDir}/coding/cs61b/src/java/`),
           },
           {
             text: 'OOP',
+            collapsed: true,
             items: await getNavItems(`${noteRootDir}/coding/cs61b/src/oop/`),
           },
           {
             text: 'Data Structures',
+            collapsed: true,
             items: await getNavItems(`${noteRootDir}/coding/cs61b/src/ds/`),
           },
         ]
       },
       {
-        text: 'CS61C',
+        text: 'CS61C: Machine Structure in C and RISC-V',
         link: '/pages/coding/cs61c/info',
         collapsed: true,
         items: [
           {
             text: 'C',
+            collapsed: true,
             items: [
               { text: 'Intro to C', link: '/pages/coding/cs61c/src/c/Intro to C' },
               { text: 'Generics', link: '/pages/coding/cs61c/src/c/Generics' },
@@ -51,6 +92,7 @@ export const sidebar: DefaultTheme.Sidebar = [
           },
           {
             text: 'RISC-V',
+            collapsed: true,
             items: [
               { text: 'Intro to RISC-V', link: '/pages/coding/cs61c/src/riscv/Intro to RISC-V' },
               { text: 'RISC-V Instructions', link: '/pages/coding/cs61c/src/riscv/RISC-V Instructions' },
@@ -61,6 +103,7 @@ export const sidebar: DefaultTheme.Sidebar = [
           },
           {
             text: 'CPU',
+            collapsed: true,
             items: [
               { text: 'Design Hierarchy', link: '/pages/coding/cs61c/src/cpu/Design Hierarchy' },
               { text: 'Combinational Logic', link: '/pages/coding/cs61c/src/cpu/Combinational Logic' },
@@ -75,6 +118,7 @@ export const sidebar: DefaultTheme.Sidebar = [
           },
           {
             text: 'Performance',
+            collapsed: true,
             items: [
               { text: 'Caches', link: '/pages/coding/cs61c/src/performance/Caches' },
               { text: 'Data-Level Parallelism (DLP)', link: '/pages/coding/cs61c/src/performance/Data-Level Parallelism (DLP)' },

pages/coding/cs61a/img/Complexity Chart.png

@@ -0,0 +1,24 @@
+CS61A: Structure and Interpretation of Computer Programs
+===
+Ahh... This is where this all begins.
+
+It was late night at 2024-01-16 (Yes I literally just `stat` my files), when I took the first step into this course, and all my journey of programming begins.
+
+Look back on these notes, I'm surprised to remember most of the contents apart from the code are summarized with my own opinions and reflections over the materials given by Prof. DeNero, which is quite praiseworthy due to the fact that during these days I prefer reading over the text, and just yanking and pasting them all over into my notes.
+
+I rarely approach these notes today. Partly because they're already known, and partly because I'm busy and lazy. There are some new stuff I've rediscovered when I'm filtering through them, like the keyword `nonlocal` and function decorator `@`. I might need to come back to these later on when I get my hands on some backend projects...
+
+I stopped, as the new semester approached, shortly after I finished the project 3 "Scheme". (This is why I always joke about '学期' (semester) to be '学间期' (somewhere in the middle of learning) since I have no control over my learning during these times.) It is a pity that I didn't leave any design info or docs other than the code itself, which could have been a good material to reflect on. I had also done it way too fast, for the fear that I might not be able to finish it. The price is, I didn't remember a single byte from it.
+
+It is fair enough to say, "You've came across so much burdens during the semester, so forgetfulness is just normal", but it did remind me of the importance of **writing design docs and reflections**. (Though you didn't write it again in CS61C Project 1, 2.)
+
+The missing parts are SQLs. Initially I thought it was not a big deal. This didn't strike me until I suddenly become NIMO's WebDev, and need to take care of all of those frontend, backend and stuff. I will come back to them later.
+
+***
+:::info Timespan
+2024-01 - 2024-02
+:::
+***
+
+Oh, by the way, in the meantime I took another one called SysAdmin Decal, for learning Linux usage and management, git, apt, and fun. Unfortunately I didn't leave text materials behind. Great course though, I'll recommend all those who want to at least know about Linux to take a look at this course.
+

pages/coding/cs61a/info.md

@@ -0,0 +1,50 @@
+---
+tags:
+  - CS
+  - Python
+  - CS61A
+---
+Linked List Class
+===
+```python
+class Link:
+    """A linked list.
+    
+    >>> s = Link(1)
+    >>> s.first
+    1
+    >>> s.rest is Link.empty
+    True
+    >>> s = Link(2, Link(3, Link(4)))
+    >>> s.first = 5
+    >>> s.rest.first = 6
+    >>> s.rest.rest = Link.empty
+    >>> s                                    # Displays the contents of repr(s)
+    Link(5, Link(6))
+    >>> s.rest = Link(7, Link(Link(8, Link(9))))
+    >>> s
+    Link(5, Link(7, Link(Link(8, Link(9)))))
+    >>> print(s)                             # Prints str(s)
+    <5 7 <8 9>>
+    """
+    empty = ()
+
+    def __init__(self, first, rest=empty):
+        assert rest is Link.empty or isinstance(rest, Link)
+        self.first = first
+        self.rest = rest
+
+    def __repr__(self):
+        if self.rest is not Link.empty:
+            rest_repr = ', ' + repr(self.rest)
+        else:
+            rest_repr = ''
+        return 'Link(' + repr(self.first) + rest_repr + ')'
+
+    def __str__(self):
+        string = '<'
+        while self.rest is not Link.empty:
+            string += str(self.first) + ' '
+            self = self.rest
+        return string + str(self.first) + '>'
+```

pages/coding/cs61a/src/ds/Linked List Class.md

@@ -0,0 +1,135 @@
+---
+tags:
+  - CS
+  - Python
+  - CS61A
+---
+Linked Lists
+===
+A linked list is either empty or a first value and the rest of the linked list.
+```mermaid
+%%{init: {"flowchart": {"defaultRenderer": "elk"}} }%%
+graph LR
+subgraph 1
+direction LR
+A[Data] -.-o B((Rest))
+end
+B --> 2 
+subgraph 2
+direction LR
+C[Data] -.-o D((Rest))
+end 
+D --> 3
+subgraph 3
+direction LR
+E[Data] -.-o F((null))
+end
+```
+## Linked List Class
+We use object system to implement linked lists in Python
+```python
+class Link:
+    empty = ()
+    
+    def __init__(self, first, rest=empty):
+        assert rest is Link.empty or isinstance(rest, Link)
+        self.first = first
+        self.rest = rest
+    def __getitem__(self, i):
+        if i == 0:
+            return self.first
+        else:
+            return self.rest[i-1]
+    def __len__(self):
+        return 1 + len(self.rest)
+    
+    def __repr__(self):
+        if self.rest is self.empty:
+            rest = ''
+        else:
+            rest = ', ' + repr(self.rest)
+        return f'Link({self.first}{rest})'
+        
+
+s = Link(3, Link(4, Link(5)))
+>>> def join_link(s, separator):
+        if s is Link.empty:
+            return ""
+        elif s.rest is Link.empty:
+            return str(s.first)
+        else:
+            return str(s.first) + separator + join_link(s.rest, separator)
+>>> join_link(s, ", ")
+'3, 4, 5'
+```
+
+- For `__len__`, the base case is reached when self.rest evaluates to the empty tuple, `Link.empty`, which has a length of 0.
+## Processing
+```python
+def range_link(begin, end):
+    """Return a Link containing consecutive integers from start to end.
+    
+    >>> range_lilnk(3, 6)
+    Link(3, Link(4, Link(5)))
+    """
+    if start >= end:
+        return List.empty
+    else:
+        return Link(start, range_link(start+1, end))
+
+
+def map_link(f, s):
+    """Return a Link contains f(x) for each x in Link s.
+    
+    >>> map_link(square, range_link(3, 6))
+    Link(9, Link(16, Link(25)))
+    """
+    if s is Link.empty:
+        return s
+    else:
+        return Link(f(s.first), map_link(f, s.rest))
+
+
+def filter_link(f, s):
+    """Return a Link that contains only the elements of x of Links s for which f(x) is a true value.
+    
+    >>> filter_link(odd, range_link(3, 6))
+    Link(3, Link(5))
+    """
+    if s is Link.empty:
+        return s
+    filtered_rest = filter_link(f, s.rest)
+    if f(s.first):
+	    return Link(s.first, filtered_rest)
+	else:
+	    return filtered_rest
+```
+
+## Mutating
+Linked list object instance can be mutated through mutating `List.first` and `List.rest`.
+
+The rest of a linked list can contain the linked list as a sub-list.
+Do not mutate directly the `List`, which might leads to recursive definition.
+```python
+s = Link(1, Link(2, Link(3)))
+s.first = 5
+t = s.rest
+t.rest = s # It is mutating s because t.rest is s.rest.rest
+```
+```mermaid
+%%{init: {"flowchart": {"defaultRenderer": "elk"}} }%%
+graph LR
+subgraph linked_1
+direction LR
+A[5] -.-o B((Rest))
+end
+B --> linked_2
+subgraph linked_2
+direction LR
+C[2] -.-o D((Rest))
+end 
+D --> linked_1
+t --> linked_2
+s --> linked_1
+```
+To copy a linked list, use `Link(List.first, List.rest)`