My List of Books & Resources for LS Students

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!

Ruby

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.

Eloquent Ruby

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.

Ruby Warrior

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!

JavaScript

Just as with 101 & 120, the LS courses covering JavaScript do an excellent job of teaching what you need to know. With JavaScript, I reached for resources that helped me understand the many quirks of the language or supplement certain areas of the last few courses in the core curriculum.

JavaScript: The Good Parts

This book is excellent in concisely explaining the good parts of JavaScript and includes sections on the bad & awful parts to avoid. I’ve had many people say that this book helped further their understanding of the language and prepare them for interview questions on JavaScript, and I completely agree with them. LS gives you the core of what you need to know, and Douglas Crockford takes you further by really targeting the important topics to review and know. All in a wonderfully small book!

NodeSchool

NodeSchool is a free collection of workshops that you can download to learn JavaScript and Nodejs, the latter of which is extremely important if you want to learn full-stack JavaScript. Nodejs is a JavaScript runtime designed to run on the server and has many topics that aren’t fully covered in the LS courses like using promises, accessing stdin/stdout streams, using npm, and many more.

For students in the core curriculum, NodeSchool has workshops that pair nicely with the LS JavaScript courses and provide exercises to practice your skills before tackling the assessments and projects. Relevant workshops cover basic JavaScript, debugging, prototypes, scopes & closures, and testing. If you find yourself needing more practice with JavaScript or targeted learning of certain topics, I highly recommend using NodeSchool. And once you’ve completed the core curriculum, check out the Nodejs workshops as Nodejs is an extremely popular technology and has often been used in many Capstone projects.

You Don’t Know JS: Book Series

This series is a monster, and I would only recommend it once you’re preparing for the 239 assessment or have finished the front-end courses. There are six books in the series (all free to read online) and the author Kyle Simpson peels back the many layers of abstractions that come with JavaScript. What I really appreciate about this series is that each book is fairly self-contained, so you can dive into the areas that you wish to learn about. In particular, there is an entire book on ES6, which completes the LS curriculum nicely as ES6 isn’t deeply covered in the last course (at least at the time of writing this article). There is also a separate book on this & Object Prototypes that I found useful to understand what I felt was one of the hardest concepts when learning JavaScript. And once you’ve finished the core curriculum/Capstone, look more into these books. I consider them to be part of a “finishing school” for students who wish to learn JavaScript extremely well.

Terminal

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.

Mastering the Shell

This course is a brief intro to topics of the shell that go beyond the LS command line book. The benefit is that you’ll see how powerful it can be and that there are a lot of tasks that you can do without needing Ruby or JavaScript. This course is also a good way to get context for the following resources, plus it can all be completed in a day (and yes, the irony of a course titled “Mastering the Shell” that can be completed in a day is not lost on me, but it’s still worth a look).

The Art of the Command Line

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.

LS Linux Study Group

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!

The Linux Command Line

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.

BaseCS

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.

Note: The author has recently started a new blog series called BaseDS that delves into distributed systems every alternate Wednesday. Her first article is out and can be found here.

A Common Sense Guide to Algorithms

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.

GeeksforGeeks

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.

LeetCode & CodeWarsExercism

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.

Project Euler

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.

JS30 Series

This series consists of 30 small projects for targeting those HTML/CSS and JavaScript skills. The 230 course on DOM & Asynchronous JavaScript contains a ton of projects and exercises to practice the material, and I still found these projects helpful to add. There are a lot of concepts coming together and mixing when you start making dynamic web apps and handling user events, and I found that the more projects you complete for practice the greater your skills and confidence will become.

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.

High Performance Browser Networking

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.

Web Architecture 101

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.

System Design Primer

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.

Exclusions

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.

The Well-Grounded Rubyist

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.

Practical Object-Oriented Design in 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.

Eloquent JavaScript

This book faces the opposite problem of The Well-Grounded Rubyist. It teaches you JavaScript with the expectation that the reader has zero knowledge of the language, while also providing little material that goes beyond the LS courses. If you complete the LS JavaScript courses, then you’ll already have covered everything in this book and more.

Cracking the Coding Interview

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.

The Pragmatic Programmer, Clean Code, Programming Pearls, Code Complete

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.


Conclusion

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!