Daniel's Computer Science Notes

Intro

This document is my record of work towards a Self-Taught equivalent of a CS degree. I want to pursue mastery in my craft and the aim for this project that will most likely span years is to keep track and log of all things and be able to share it with people who could benefit form it. The core curriculum is as perscribed by Oz Nova and Myles Byrne, authors of teachyourselfcs.com, but consists of many additional resources that I have completed / am interested in. If you want to ask questions about the core curriculum, all the answers are to be found at the link above. The files in this repository are a collection of all the possible files, notes, etc. that I have been using for my work. It's a snapshot of a real-life workplace, with various papers and books scattered around than a repository of coherent code, and it should be treated as such. Use it to guess my process, look at resources I've worked on, etc.

The purpose of this repository is twofold - to keep myself organised and accountable, and also to be able to share my experience with other people who are undertaking a similar challenge of completing this curriculum.

Summer 2021 Update

Time flies. I've been working on my cs knowledge since Dec 2020, and ATOW it's August 2021. Since then I've actually enrolled in a intensive computer science course offered by Bradfield. For transparency - it's offered by the authors of the teachyourselfcs curriculum. That means that the title of this repository, and by extension, the actual notion of teaching yourself cs changes a little bit, since I'm actually enrolled in an institution where I'm being taught. Nonetheless, I am going to keep maintaining it for visibility, inspiration, accountability, and numerous other reasons, and I'm sure its maintenance will outlive taking that course.

Progress

Here's a list of all courses I'm planning to take. They're mostly taken from the tycs website, which I'm treating as a central point of my curriculum, but I've been adding other resources as I was exploring varous avenues. The content and topics vary, and over the months of maintaining this list I have found myself diverting form the original course, and coming back, and generally noting down things that I've done, cause they were interesting at the time. I became a record of my interests. update August 2021: Also, it hosts a scrapbook notepad of my notes from Bradfield.

Completed

2020

(book) You Don't Know JS, by getify books 1-6. Absolutely an amazing piece of work on JS. Highly recommend.
(book) C.O.D.E by Charles Petzold. Stunning book on the nature of computers, clear explanations, great storytelling.
(book/video course) Learn C the Hard Way by Zed Shaw. I've learned a lot about modern C programming from Zed, but more importantly, good habits. The learning methodology really stuck with me and pays dividends on all learning since. I highly recommend it even just for that reason.
(mooc + book) Learning How To Learn and A Mind for Numbers by Barbara Oakley. Transforming course and a book. Understanding the neuroscience behind learning has helped me treat a lot of imposter syndrome and made my learning more efficient.

2021

next in line

Next in line

General Findings

Biggest Challenges

By far the most challenging part of taking a self-guided course like this is not doing it with other people. I have started a Discord Server (now not very active) for people who are also working through that curriculum, and it is helpful to exchange experiences and advice. Be ready for a lot of frustration trying to find solutions to your problems without a centralised place for people who are doing something similar hang out. Luckily there are groups centered around various resources and topics (SICP has a big community).

First few weeks

Working through the first month of the curriculum has been a challenge - especially in guiding my learning and scheduling sessions. Working on your own you have to answer questions regarding what to study, for how long, and what are measurable deliverables. I've iterated over a few frameworks and I've found that having a clear view of a week ahead with a minimum goal works best for me. The study topics are organised in sections as per the teachyourselfcs curriculum, so for example:

I'm working through the Programming section, directly on Composing Programs, therefore every day I spend 3-5h on the main topic. To add variety, and for pleasure of it (I find it brings me the most joy to do) I also schedule daily code challenge sessions (leetcode / codewars / advent of code etc). That takes up a couple hours, and I use it to not only brush up on Algorithms, Data Structures, and Problem Solving, but also polish a language of my choice that I'm currently working with. As a tetriary topic of the day I include meta-study, on the tooling that I am using. Therefore there's always a 30-60 minute session on vim / tmux / shell scripting etc.. Lastly, I make sure to review recent knowledge.

Flashcards, flashcards, flashcards.

I'm using a tool called Anki to organise my knowledge into bite-sized reviewable flashcards. It's an incredible and simple tool that enabled me to actually retrieve a lot of knowledge. Simply as I read / watch / code, every time I stumble upon a nugget of information, I distill it to a fact, write it down into the flashcard database and review them daily. Time invested in those is worth its weight in gold for me.

Rethinking development process and tooling

A few weeks in it became clear that counting on inspiration and good mood for learning is not enough, and so to ensure that I progress at a rate I'd like to, I had to put a few systems in place. As most of the challenges I'm facing are due to the nature of self-learning, most advice here is on how to stay motivated and engaged without outside stimuli and accountability.

Rule of thumb: There is always something to learn. A few years ago at a startup I worked at, a colleague of mine said a phrase that went something like that: "I refuse to believe that there is nothing to do here". We were talking about a colleague of ours who quite frankly was straight down slacking for hours, but the context aside, the phrase stuck with me. The point discussed was the notion of feeling responsible and proud about the work being done. I found myself slacking for hours or sometimes days, purely due to a lack of sense of ownership of my learning. Formalizing my processes and holding myself accountable to a schedule and deliverables changed everything. To re-coin the phrase: "If you care about your work, I refuse to believe there was nothing you could do that day to move towards what you want to achieve."
Every day, after I complete my work I do a very quick evaluation of what I think I achieved (often differs from what I've actually done) vs what I intended to do, and whether I feel proud of my efforts today. Learning is often so fuzzy and without specific boundaries, that it's easy to feel like you're under-achieving. Keeping myself in check with daily mini-retros and one at the end of every week fixes that problem.
When facing a lot of new information and feeling discouraged about having trouble 'getting it', I learned to persevere and continue learning. Having learned about how brains process new information from A Mind for Numbers I have developed a process of immersing myself in the topic nonetheless. To get more comfortable with a topic I can't fully understand I work through it from various angles, whether it be drawing things out on paper or whiteboard, trying to explain it to a friend, coding out my own solutions and implementations, etc. It feels weird and forced, but after a few days of focusing on the topic, whatever it could be, there is no way you won't start feeling familiar with it and the discomfort disappears. And with it, comes confidence and knowledge.

Working on the core Computer Science content is one thing, but becoming more proficient with the tooling while doing so is a completely different topic. I've been used to working in VSCode + separate terminal setup, but due to the fact that I am working on two different computers often (macos and linux), I need a reliable and replicable setup on both machines. For that reason I have narrowed the text editing and all work on a computer to using tmux, and vim. If you're not sure where to start with that, I suggest a great series of video lectures.

One example of a simple gain is to use a tool like nodemon to speed up iteration through the coding challenges / exercises. Do not ignore it for just being a JS tool, take a look at the documentation and the --exec flag.

(newfound) Love for Mathematics

I always steered away from was mathematics. I've fallen in love with it this time around, mostly thanks to a few things that have made it way more applicable, relevant, and fun. If you're feeling iffy about maths, make sure to read Mathematician's Lament, watch a video on the Mandelbrot Set, and read about The Library of Babel (do not forget to read the original story. Those are the things that I have found enjoyable and were the tipping point. They may not be this for you, so just keep looking. Mathematics is a beautiful art form and I'm sure you can find that.

One thing that was very challenging early on was writing proofs. Here's a list of resources I've used to get more advice and support:

Command Line tools i highly recommend

All should be supported under most unix systems.

fzf for fuzzy matching searches in text files. a good alternative to grep/ripgrep for quick searches
broot for a very neat alternative to ls -R or tree commands
nnn a more advanced alt to broot
ranger for navigating files with vi bindings
tldr for snippets of usage examples of tools, saves you stackoverflow googling
pretzo for a really pretty zsh prompt.

Course

Various notes from the course content, that I will probably want to look up later.

Programming

Composing Programs

I found this article useful while digesting Partition Trees described in section 2.3.6. Excerpt:

A partition tree is a way of representing a hierarchy of these partitions of an entity. The way it works is as follows:

Each node in the tree represents a part of the whole entity. In particular, the root node of the tree represents the entity in its entirety.
As is usual with trees in computer science, a node is either a branch node or a leaf node. (The distinction is that a branch node has child nodes, whereas a leaf has none.) In a partition tree, the children of a branch node represent a partition of the branch node (properly speaking, the parts of the entity represented by the children of the branch node represent a partition of the part of the entity represented by the branch node, but continually distinguishing between nodes and the sub-entities they represent is tedious).
Each layer in the hierarchy represents a partition of the entire entity.

Using our pizza analogy, we could imagine first dividing our pizza into three portions, one for each person at the table. Each person's portion is then further sub-divided into four slices. Each person's slices are a partition of their portion, and the portions are a partition of the pizza as a whole. Furthermore, if you take all the slices, or all the portions, together, you have the entire pizza.

References

This repository would not have existed if I had not been insipred by the people who did things like that before me. I'm eternally grateful for efforts of others publishing resources online, and here is a list of just a select few that I've used over the years to become a better programmer.

Name		Name	Last commit message	Last commit date
Latest commit History 774 Commits
CS186_databases		CS186_databases
advent_of_code		advent_of_code
algoexpert		algoexpert
backup		backup
bradfield		bradfield
brainfuck		brainfuck
c		c
complete_intro_to_databases		complete_intro_to_databases
composing_programs		composing_programs
coursera/mathematical_thinking_in_computer_science		coursera/mathematical_thinking_in_computer_science
cracking_codes_with_python		cracking_codes_with_python
cracking_the_coding_interview		cracking_the_coding_interview
educative/data_structures_and_algorithms_in_python		educative/data_structures_and_algorithms_in_python
exponential_backoff		exponential_backoff
go		go
graphql/learn		graphql/learn
grokking_algorithms		grokking_algorithms
gynvael_coldwind/zmienne_i_stale		gynvael_coldwind/zmienne_i_stale
how_to		how_to
hrm		hrm
leetcode		leetcode
linux_command_line_william_shotts		linux_command_line_william_shotts
little_schemer		little_schemer
math		math
operating_systems_concepts		operating_systems_concepts
over_the_wire/bandit		over_the_wire/bandit
practical_algorithms_and_data_structures		practical_algorithms_and_data_structures
practical_vim		practical_vim
project_euler		project_euler
python/data_structures/doubly_linked_list		python/data_structures/doubly_linked_list
reference_material		reference_material
ruby		ruby
schedules		schedules
sicp		sicp
skiena_algorithm_design_manual/chapter_01		skiena_algorithm_design_manual/chapter_01
typescript/effective_typescript		typescript/effective_typescript
zrozumiec_programowanie		zrozumiec_programowanie
.gitignore		.gitignore
README.md		README.md
list.md		list.md
postgres.md		postgres.md

danielkaczmarczyk/dk-cs-notes

Folders and files

Latest commit

History

Repository files navigation