In this blog post, I want to provide a list of books and resources that I’ve found useful as I worked through the Launch School core curriculum and Capstone. I’ll focus on the ones that I feel are most relevant for the general reader (a student in the core curriculum or Capstone) while also avoiding niche topics that may be too specific (such as containers, P2P architecture, NoSQL databases, etc).
The rule of thumb that I used for selecting these resources is that it needed to run parallel with the course that I was currently studying, while giving me some needed depth on the course material. All links to the resources are accessible by clicking the resource title.
And with that, here we go!
The resources that I chose for Ruby were fewer than the other areas, and that’s mainly because the LS curriculum covers a ton of the material for you. Additionally, the first two courses in the core (101, 120) can feel overwhelming in the beginning with all the information they cover and I didn’t want to tack too much on top of them.
This is a fantastic book to read through after finishing the 101 & 120 courses in the core. Russ Olsen provides a good breadth of topics and serves as a welcome refresher if you find yourself getting rusty on Ruby over time. I also found the writing to be clear and the author to do a great job of keeping you engaged. Additionally, it serves as a good reference by giving you concise, self-contained chapters on topics while also telling you where you can get into trouble with the topic and how to avoid it. The first half of the book will be relevant to LS students and the second half can be read if you want to take your Ruby skills further.
I love this game! It’s a fantastic way to practice your OOP skills in the 120 course and to prepare for the 129 assessment, and the difficulty ramps up after a few levels. While you can get through the first few levels with some large conditionals to handle the obstacles, you’ll quickly find yourself having to refactor your code to handle the more complicated levels. The reason that I chose this resource is that while 120 provides a lot of great material, I found myself needing some more practice writing OO code to solidify the concepts and this game addressed that need fairly well. This game provided that for me while also being more difficult than any examples I could come up with on my own. Plus it’s loads of fun!
The terminal/shell is an essential tool in every developers arsenal. It’s our work bench for building projects, running code, debugging, monitoring, and so much more. And as you start developing whole systems with remote components, you’ll need to be extremely comfortable with working solely on the command line. As developers, our craft depends on knowing our tools extremely well and learning how to operate your computer (and in the future whole systems) from the terminal will pay large dividends in your future career.
For most LS students in the core curriculum, their use of the command line will often be navigating the file system, creating and deleting files/directories, using Git & Github, and working on projects. This is fine and the first two resources below will be the most relevant. For students who wish to go further or students wishing to do Capstone, the last two resources will be pretty helpful as they start building projects that require them to use remote servers, handle multiple processes, access the std/stdout streams, and much more.
This is a big cheatsheet of things to know regarding the command line. The basics and everyday sections are great for making you more aware of what you can do from the terminal and I’ve learned a lot of useful tricks from it.
It’s mainly to help you become more efficient with using the command line in your everyday tasks. I wouldn’t recommend going through it all at once since there is a lot of breadth and many of the points can lead to potential rabbit holes. Look through the basics and everyday sections, and come back to this cheatsheet over time.
Once you’ve got a handle of the basics and see the motivation for mastering the terminal, I recommend that you check out the LS Linux Study Group. Started by fellow student Ian Evans, the group is a fantastic resource for furthering your learning of the terminal, shell, and Linux with a curated list of topics to study and fellow students ready to help each other learn. There is also a slack channel you can join to discuss the topics together!
This is one of the main resources used in the LS Linux Study Group and for good reason. Going through this book will greatly improve your knowledge of the command line and help you realize how much control you can have over your computer and systems, and the author has generously provided it for free online.
Before Launch School, I used my computer mainly for schoolwork, internet browsing, and social media for ~25 years and viewed it mainly as a “black box”. But LS combined with this book and the resources above truly show how much control you can have in actually “driving” your computer as you see fit. Parts 1 + 2 will be relevant for many LS students, and parts 3 + 4 are good reference sections for future studies and projects. I’d recommend that you check this book and the LS Linux Study Group out after finishing the 170 course.
Algorithms & Data Structures
Now we come to algorithms and data structures, which are vital to learn for not only job interviews but also to step up to the next level as a developer. The resources listed here provide the background and context, and the next section on practicing code challenges will provide you with opportunities to use them. Look into these resources once you’ve finished the core curriculum or are about to start Capstone.
This blog series is a slam dunk and I’m obsessed with it. Vaidehi Joshi spent a whole year writing about algorithms & data structures and each article contains a wonderful amount of depth. There isn’t any code in the articles, but you’ll learn the background about a data structure/algorithm, how and why it’s used, and the tradeoffs of using them. I used this series to gain the background information needed to start solving coding challenges.
This book is similar in many ways to the BaseCS series in that it provides the background information on algorithms and data structures. The reason for its inclusion in this list is that each chapter has code implementations of the covered topic and I’ve found it helpful in my learning to read different approaches to new topics. It’s another useful resource for bridging the gap between having the knowledge of a data structure/algorithm and then being able to use that knowledge to solve problems and develop projects. Also, this book has been part of the Capstone curriculum (at the time of writing this article) so its been thoroughly vetted and its worth can be attested to.
This website is extensive in its offerings of information of data structures and algorithms. Along with informative articles, there are coding challenges with solutions and suggested projects to practice using the knowledge you’ve gained from the previous two resources. I consider GeeksforGeeks as a step up from BaseCS and A Common Sense Guide to Algorithms due to its use of more technical language and heavy use of Java & C++ solutions to problems (though many problems do have a Python solution). This isn’t a true barrier to LS students but I have found that it requires more time for me to work through the unfamiliar language syntax. Just remember, no matter the language a loop is still a loop, a conditional is still a conditional, and so on.
Practicing Code Challenges
So now we come to solving problems with all the knowledge you’ve acquired! Here are some of my favorites sites for practice that can be used during the core curriculum for extra practice or to prepare for the job hunt.
These sites list hundreds of problems with provided test cases, and many have solutions for you to learn from. What I especially like about LeetCode is that it also categorizes problems based on data structures, so you can focus your time on the topics that you need to practice. Additionally, many companies pull their interview questions directly from LeetCode and its not unheard of for developers to solve one of their problems, then walk into the interview and be given the exact same problem.
Another useful site for practicing your problem solving skills with a focus on mathematics. I once read an article that advocated for developers to solve the first 50–100 problems on this site in whatever language they’re learning in order to cement the language syntax and intricacies, and I think it’s an excellent idea.
System Architecture & Networking
This final area is for students who have either completed the core curriculum, started doing Capstone, or have enough spare time on their hands to consider learning more about system architecture and networking. These resources will help introduce you to the wider world of programming and designing complete systems, and are helpful for learning exactly how web apps come together with their various components.
This book is amazing, and the author Ilya Grigorik has generously made it available for free in an online format. I’ve learned so much about browser networking, HTTP, TCP/IP, latency, bandwidth, optimizations, and much more from this book, and consider it instrumental to bridging the gap between the core curriculum and Capstone or the job hunt. But even before that, you’ll find chapters helpful for certain LS courses.
It provides a depth of information on HTTP and TCP/IP for students in the 170 course, describes techniques for optimizing the delivery of assets to decrease the latency of web apps for students in the 230 course, and has sections on relevant technologies like WebSockets, WebRTC, etc. Personally, I have found this book to be a cornerstone to the success of my team’s Capstone project SpaceCraft.
This blog gives a nice overview of the many architecture components that make up a web app like web servers, caches, content delivery networks (CDNs), job queues, and more. It helps you see the high-level design of web apps and describes how each component fits into that design.
After reading the Web Architecture 101 blog, check out this Github repo on system design. It takes each of the components in the above blog and provides tons of more information, as well as the tradeoffs of using each component. It also has case studies of systems used by Dropbox, Uber, Facebook, and more that will prepare you for system design interviews during the job hunt.
Now that I’ve provided my recommendations, I wanted to go over a list of books that I’ve either seen tossed around among LS students or find mentioned in many popular lists of “Books Every Programmer Should Read”, but that I would NOT recommend you read at this time. I’ll explain why as well as when you should use them below.
This is a great book and its part of many lists for books that every Ruby developer should read. I actually used to recommended this book to other LS students while I was in the 101 & 120 courses, but I’ve stopped doing so. The reason that I’ve made it an exclusion is that it both goes into way too much depth and many of the topics are already covered extensively by the 101 & 120 courses. So it essentially repeats a lot of the material that you’ll learn in those courses and each of the chapters are pretty beefy to get through. I’d recommend this book as a reference for the future if you find yourself working with Ruby.
Here is another popular book for Ruby developers and for good reason. Sandi Metz is a fantastic teacher and really breaks down how to write good OO code. However, this book lands in that area of being more useful for working developers rather than LS students since it’s aimed to teach you how to break bad habits, spot troublesome patterns, and work with OOP in a newer, better light. Some of the topics covered in the book are things that sound like a good idea if you’ve never seen them before, but will only truly hit home once you’ve felt the pain of writing or working with bad/problematic OO code. It’s on my bookshelf for my career, but not for the LS core curriculum.
This book is widely regarded as essential for the job hunt, and I agree. It provides a ton of problems to practice for interviews, describes what the interview process is like at the top tech companies (Facebook, Amazon, Microsoft, Google, Palantir), and even gives problem solving steps to add to PEDAC for optimizing your solution. However, this book is extremely narrow in its usefulness and unless you are about to start looking for a job then there is no need for you to pick it up. Once you do start job hunting, combine this book with LeetCode and GeeksforGeeks to maximize your practice.
All of these books are fantastic and deserve a place on your bookshelf for your career. However, they have the same problem as Practical Object-Oriented Programming in Ruby — they are targeted toward improving professional developers, not newer developers still learning the fundamentals. These books are meant to make you a better developer at work and many of the lessons they cover are things which in my opinion you need to feel the pain of before you can appreciate their lessons. You have to learn things one step at a time, and these books are for that step you take after starting your career.
I hope that you find this list useful in your journey as a LS student. There are too many resources out there for anyone to completely go through and many require a specific point in your studies or professional life to be worth their value. The resources that I’ve listed here have been useful to me and I’ll likely come back to them in the future as I circle back on topics that I need to review.
What I would like to emphasize before closing out this blog is the following: always put your LS course before any of these resources (especially if you are pressed for time) and find what works best for you. Your priority should be mastering the LS material and acing the assessments, and while these resources are great they are no substitute for what LS has already created. Your journey toward being a professional software engineer is your own and you need to take ownership of it by using the resources that work for you.
If you have any comments, questions, or other recommendations, please leave them in the comments below! Thanks for reading!