When I read a book, depending on the subject and how relevant it is to my immediate work, I want to make connections either to what I’m actively working on, or just within itself while I’m reading it. I want to have a foundation in the topic that I can continue to build on at any point in the future. My goal is never to remember every detail, or even most details; in fact, I expect to forget most of what I read within a few months or even weeks unless it’s extremely relevant to my current work, which most books aren’t.

To deal with the loss of information, I do a few things: first, like I said, I just accept that it will happen. It’s still valuable to read a wide range of topics, learn a bunch, find interesting topics, etc. Second, I take a ton of notes. Not on paper or on my computer, though, I just write in the margins of my books. I underline and circle terms, draw arrows, smiley faces, anything that I think is valuable to put there. I know people have mixed feelings about writing in books - my stance on this is that books are meant to be learned from, and I’m not learning as much from it if I’m not writing in the margins. (Obviously these are all books that I’ve personally bought, I would never write in a book I’ve borrowed!) And finally, immediately after I’m done reading a book, I go back and write a couple “core takeaways” that I want to be the one or two things I don’t forget about it.

This blog post contains a list of all of the books I read in 2020 along with my core takeaways from them. For the most part it’s just a copy of my local records; however, in my local document I write down the exact date I finish each book, but I’m not going to publish that here because I don’t want to cause any additional time pressure for myself due to the existence of this post. Occasionally I may also include notes about whether or not I recommend a certain book, as well as how the book was recommended to me. I’ve also edited in Amazon links to the books - support a local bookseller if you can, but at least these links are pretty guaranteed to be static.

Six-Step Relational Database Design by Fidel A. Captain
Would recommend: It’s a decent introduction to databases but there’s one I’d recommend a lot more that I read previously (I linked it below but I’ll include it in my post next week, which will be books I read in 2019)
Category: Databases
Core takeaway: “The primary key, the whole primary key, and nothing but the primary key” is a good way to determine if a field belongs in a table. It also went over ER diagrams and stuff but nothing that wasn’t covered in the Mere Mortals book.

The Best Interface is No Interface by Golden Krishna
Would recommend: Maybe, it’s probably not the best use of your time but it was interesting
Category: UI/UX
Core takeaway: Anticipating users’ needs is sometimes more important than empowering users to make decisions. I read this around when “there’s too many preloads and stuff to remember” was an issue for new roster changes, which I think is appropriate timing.

Code Complete by Steve McConnell
Would recommend: Yes, if you haven’t read any book like this before
Category: Best Practices
Core takeaway: I need to write better comments. Most of this book felt comfortably familiar to me, which was pretty cool, except for some language-specific stuff and most of the performance improvement tactics.

Don’t Make Me Think, Revisited by Steve Krug
Would recommend: Yes
Category: UI/UX
Core takeaway: DO USABILITY TESTING!!!!!!!!

The Unicorn Project by Gene Kim
Recommended by: I read The Phoenix Project previously
Would recommend: Yes
Category: Best Practices
Core takeaway: It’s not a bad habit that I have to spend time improving process (spending forever to fix an issue in Sublime that annoys me etc). Localize parts of projects as possible. Ask companies “what annoys you in daily life” when interviewing and take that seriously, and if they are mission-critical things it’s probably a symptom of systemic failure.

Introduction to Algorithms (CLRS)
Would recommend: If you were a math major (or wish you had been) & want to spend a lot of time reliving your undergrad then go for it, otherwise you will probably cry
Category: Algorithms
Core takeaway: This book was a lot like SICP except overall maybe a bit less fun (I read this cover to cover with a rule “cannot continue without fully understanding every passage,” but I didn’t do any exercises, same as SICP). The only immediate (maybe?)practical application that I have is that I want to create a linked lists data type for myself in Lua so I can better delete stuff from the middle of an ordered list in roster portals [did not end up doing this ever lol]. But I think I retained a good amount of what I read and at least will be able to revisit any of the topics later and already have a foundation. (Also I spent the last 3 months reading this…)

100 Things Every Designer Needs to Know About People by Susan Weinschenk
Would recommend: No
Category: Design
Core takeaway: This book didn’t feel that productive to read honestly, since most of it seems to be about marketing and using social/emotional design elements to get people to do things. I’m not sure how it would make sense to apply anything like this to what I’m doing right now, but in general I have a sense that design should be more human.

How to Win Friends and Influence People by Dale Carnegie
Would recommend: YES YES YES everyone should read this
Category: People
Core takeaway: Go out of my way to show I consider other people’s time more important than my own. Agree and say “yes” as much as possible, specifically using this word is really important. Use people’s names in conversation. I should try to reread this multiple times, it has a lot of really good advice in it.

The Art of SQL by Stephane Faroult
Would recommend: Maybe, it was pretty interesting, not really a good introductory book if that’s what you’re looking for but enjoyable & engaging
Category: Databases
Core takeaway: Let the optimizer do its job. Obviously most of this book doesn’t apply to what I’m doing on the wikis, but it was good for a much better understanding of where I stand in relation to “real” SQL queries. The section on “how to exclude all values from a list” was useful, and the section on hierarchical data was interesting. It may be worth spending time considering what data can be considered candidates for denormalization because the wiki’s DB is in a big way more similar to a data warehouse paradigm than a db with frequent read-write.

Forms That Work by Caroline Jarrett
Would recommend: Yes
Category: Design
Core takeaway: Forms are a conversation between user and website. The relationship/context that the form is in matters, as does the appearance, but it’s a conversation. Group topics together. Headings and section text are invisible; help text next to boxes (to the left of or above) can be seen. Do usability testing early and often.

The Unwritten Laws of Engineering by James G. Skakoon
Would recommend: No, waste of time even though I read it in like 2 days
Category: People
Not really that worthwhile, all of it is good advice but nothing really new. Most important thing to note is that defining responsibilities of people I manage is important, and something I likely don’t do well currently. But it was a short read so whatever.

Letting go of the Words by Janice (Ginny) Redish
Would recommend: Yes, a lot of good design advice
Category: Design
Core takeaways:

• Content is conversation
• Bite, snack, meal
• Put actions into verbs, don’t noun-ify action words
• Always go from a familiar thing (context) to unfamiliar thing (new information)
  • this means if then, and not then if
• Use personal pronouns: You = reader, us/we = org or I = reader, us/we = org
• Left-align headings
• Make personas and use them!!!

CSS Secrets: Better Solutions to Everyday Web Design Problems by Lea Verou
Recommended by: Her own blog! I saw it linked from HackerNews
Would recommend: Yes definitely! I learned so much about css from this!
Category: Technical
Core takeaway: This book was so much fun!! I immediately implemented different cursors and a tab size for the edit window in Module namespace. Other than that, nothing was of immediate practical application, but I feel like I can look up a lot of stuff in the future, if I ever care about complex backgrounds or any type of animations. Pseudoelements are OP.

The Effective Engineer by Edmond Lau
Would recommend
Recommended by: A FreeCodeCamp article
Would recommend: Maybe, it’s pretty quick reading, just make sure you don’t give yourself too much “credit” for reading this (same goes for any self-help book) - you didn’t actually accomplish anything by reading it, only by applying what you read to your work and then actually doing work
Category: People
Core takeaway: Look for high-leverage activities, and force yourself to relentlessly prioritize. High-leverage activities are often aimed towards improving people and systems, not product.

Database in Depth: Relational Theory for Practitioners by C. J. Date
Would recommend: Not really
Category: Databases
Core takeaway: Relational topics explored are important to understand but not super practically applicable. A lot of the material was already familiar though. Relations and relvars are different things. Integrity constraints are extremely important. SQL gets a lot of things wrong.

Database Design & Relational Theory by C. J. Date
(Note that there is now a 2nd edition of this book, apparently I bought the 1st edition 3 months after the 2nd edition was published, oops.)
Would recommend: Not really, it was really dense and not at all applicable. Maybe the first half, but only if you’re very interested in theory. The second edition might be a better resource.
Category: Databases
Core takeaways:

• BCNF is the NF wrt FDs, 5NF is the NF wrt JDs
• 5NF only matters when you have multi-column keys
• FDs are equality generating, JDs are tuple generating.

Refactoring UI by Adam Wathan & Steve Schoger
Category: Design
Recommended by: The entire internet basically
Would recommend: Yes definitely!!!!
Core takeaways:

• Create a quantized scale for literally everything you do at the start of your design. A scale for color can be linear, while scales for whitespace & font size should be closer to ratio-y.
• Use hue rotation instead of just lightness, also greys can have hues. You should always use HSL colors. Never use only color to communicate something (but you already knew this).
• Shadows / depth is also something you should pre-define a system for.
• Use empty space!!!! Like, more of it than you think. Don’t overuse borders between things.

Computer Networking: A Top-Down Approach by James Kurose and Keith Ross
Recommended by: Teach Yourself Computer Science
Would recommend: Yes! This was super fun to read & incredibly interesting
Core takeaways: (Ok I wrote notes at the end of each chapter instead of at the end of the book.)

• The internet has 5 layers: Application (HTTP, SMTP, DNS, etc), Transport (UDP/TCP), Network (IP), Link, and Physical.
• UDP (User Datagram Protocol) is a very barebones offering, it’s appropriate when you don’t want to be throttled and when some data loss is ok. TCP (Transmission Control Protocol) is so cool!! It provides a reliable data transfer (by using a checksum, labeling packets (numbering based on bytes), timeout, acknowledgement, and a pipeline/window) as well as congestion control (AIMD - sawtooth method - slow start, congestion avoidance, fast recovery).
• The network layer consists of two parts: data plane (hardware) and control plane (software). Routers (data plane) contain inputs, switching fabric, and outputs. Packet loss can occur on either side of the switching fabric. Routers implement IP (v4 and v6, we are trying to switch to v6 using tunneling). IPv4 blocks are allocated as CIDRized blocks. The control plane determines how forwarding tables are assigned. Traditionally this happens in individual routers, but in SDN it’s done centrally (for example, by OpenFlow protocol). There’s two major algorithms for computing routing tables: link-state (LS) (used in intra-Autonomous System (AS) OSPF) and distance-vector (DV) (used in BGP). Also, Traceroute is a giant hack lol.
• The link layer sends frames over wired/wireless between switches/routers. It provides some error checking via a CRC (cyclic redundancy check). Channels are either point-to-point or broadcast/multiple access. There’s lots of ways to divide Multiple Access channels, FDM/TDM. CDMA, Code Division Multiple Access is used in wireless networks. Random access includes CSMA (Carrier Sense Multiple Access) and varieties - CSMA/CD, CSMA/CA (collision detection can’t be used in wireless because of hidden terminal/obstruction problems) - which use binary backoff. There’s also taking-turns proticols to solve multiple access. Address Resolution Protocol (ARP) is used to get MAC address from IP address (by just asking everyone). Switches are invisible and self-learning to forward packets.
• Security requires confidentiality, authentication of both endpoints, and message integrity, while being immune to replay attacks (the latter is done by using a nonce instead of just an initial sequence number). Security measures can be applied at any level of the network.