I’ve decided to take some time to learn new computer science skills. I’ve been so busy with work the past few years that I’ve had to put a number of compelling topics on the back burner.
I know that I’ve missed a lot because I am a mostly self trained programmer. In undergrad I decided to move away from my technical courses and towards courses in the liberal arts. Even though I have about 24 credits in computer science, math, and logic I ended up with a degree in sociology. I’ll always kick myself for that.
I had a 9 year career in the public sector. I was always the person least afraid of diving into new technology, and eventfully decided that was my passion. I then went to a 4 month boot camp where I was the only student to take both the RoR and JS tracks. After that I worked as a programmer for 4 years. During that time I took two part time code school courses on React.js. I’ve learned the most while I was on the job. I’ve also have read numerous: books, stack overflow threads, and lots of blog posts on a variety of topics.
As an engineer that comes from a non-traditional background, I find it important to continually level up. I want to fill in the gaps of my knowledge in areas I know. I’m always looking to expand my skills into new territory as well.
There are a lot of great introductory programs for complete newbies, including bootcamps, courses, and websites. However, there are not a lot of similarly structured pathways for people looking to move from an intermediate to a senior level. It seems like you have to take the initiative and design your own coursework to get there.
To that end, I’ve been decided to unpack these topics:
- The Fundamentals of Computer Science
- Microservices Architecture
- Python and Flask
- Diving Deep into Ruby and Object Oriented Programing
- Refactoring and Code Reviews
I collected a few books on these topics over the course of the last 6 months and decided it was time to dive in and read and code during the month of December. Here is a brief overview of what I’m learning from them.
The Imposter’s Handbook
‘The Imposter’s Handbook’ by Rob Conery has been a great help in understanding the fundamentals of computer science.
The Imposter’s Handbook is an excellent primer for people who have been in the field for awhile and are looking to learn/revisit the building blocks of computer science.
Topics in the Imposter’s Handbook included, but are not limited to what you would find in a computer science program:
- Big O
- Lambda Calculus
- Data Structures
- Algorithms: Simple and Advanced
- Software Design Principles
- Functional Programming
- Essential Unix
I highly recommend this book to anyone that is looking to get an engineering job, and wants to level up or revisit what they have learned. Its a great way to prepare for an interview. I’ve learned so much for this book. The thing this book helped most might be surprising to some people. It helped me most by bringing me to the edge of my own knowledge, and showing me a map of the next set of questions I need to ask. I will be unpacking the lessons found in this book for the rest of my career. I plan on reading it again in the future.
Building Microservices, Designing Fine-Grained Systems is an OReilly book by Sam Newman. Its a super pragmatic and approachable book about microservices. Its also language agnostic, which I think will make it more timeless.
In the past few years there has been a shift in the way systems have been designed. Web applications systems have been moving from code-heavy monolithic applications to smaller, self-contained microservices. But developing these systems brings a new set of challenges. This book takes a holistic view of the topics that system architects and administrators consider when building, managing, and evolving microservice architectures.
This book provides you with a firm grounding in the concepts while diving into current solutions for: modeling, integrating, testing, deploying, and monitoring your own services.
- how microservices allow you to align your system design with your organization’s goals
- options for integrating services with the rest of your system
- how to take an incremental approach when splitting monoliths
- how to deploy individual microservices through continuous integration
- the complexities of testing and monitoring distributed services
- how to manage security with user-to-service and service-to-service models
- some of the headaches of scaling microservice architectures
I have been working with in systems that have a service oriented architecture (SOA). I’ve always wanted to know the thinking behind them. This book was a deep dive into this topic. Its great for anyone currently working with microservices/SOA or that wants to move their system towards a microservice style of architecture. In some ways I feel like I’ve been using the patterns and methods discussed in the book, and just never had a name or a theory behind them. This book helped me to understand why am doing what I was doing.
Learn Python the Hard Way
Learn Python the Hard Way was great way to start to absorb Python. Its recently been updated for Python 3. This book helps you to quickly learn how to read and write Python by using it. I like its approach of getting behind the keyboard and actively typing code. Its a great jumping off point to dive into other books on Python.
The Flask Mega-Tutorial
The Flask Mega-Tutorial The Flask Mega-Tutorial is an overarching tutorial for beginner and intermediate Python developers. Flask is a micro-framework for Python based on Werkzeug, Jinja 2, and good intentions. This book was a touchstone for me when I was creating my own Flask App for my Raspberry Pi.
Some of you might remember that this book was written originally for Python 2. The tutorial has been thoroughly revised and expanded for its 2017 release. The concepts that are covered go well beyond Flask, including a wide range of topics Python web developers need to know when writing their own applications.
The Flask Mega-Tutorial teaches you about:
- practically applying Python,
- using modern web development practices,
- all the nooks and cranny's of the Flask micro-framework,
- and introduces you to lots of useful Pip libraries
I like that these books stripped away a lot of the magic involved behind the scenes. I feel like I learn best when things are transparent and I can see exactly what’s happening. When I first learned Ruby I took a similar approach with the language by using Sinatra. Both of these books were a great confidence booster when it comes to using Python. There are lots of wrinkles that make it different than JS and Ruby. But there also lots of similarities in the way they are used. Learning all this will help me to work with Python code in production, and more importantly utilize my Raspberry Pi~! Now that I have a better understanding of Python and Flask, I also feel more prepared to absorb Django.
Refactoring: Ruby Edition
Refactoring: Ruby Edition by Martin Fowler, Jay Fields, and Shane Harvie is an excellent introduction to the discipline of refactoring. I'm starting to see these lessons reappear everywhere in my code and in other learning materials.
The authors introduce a detailed catalog of more than 70 refactorings (is that word? lol), with guidance on when to apply each of them, step-by-step instructions for using them, and good (mostly good) examples Ruby code illustrating how they work.
This book helps you to understand the core principles of refactoring and the reasons for doing it Recognize “bad smells” in your Ruby code.
I like this book, its approach is very pedantic. It walks you through how to do all of the following things step-by-step:
- Reworking bad designs into well-designed code.
- Building tests to make sure your refactorings work properly
- Understanding the challenges of refactoring and how they can be overcome
- Composing methods to package code properly
- Moving features between objects to place responsibilities where they fit best
- Organizing data to make it easier to work with
- Simplifying conditional expressions and make more effective use of polymorphism
- Creating interfaces that are easier to understand and use
- Generalizing code more effectively
- Performing larger refactorings that transform entire software systems
- Refactoring Ruby on Rails production code.
The lessons taught in this book are extend-able beyond just Ruby. One could apply them to most other object oriented languages including Python and JS (if you are using it with OO). I plan on re-reading this book many times. Indeed, I start my day, every work day anyway, by re-reading 2-3 sections of this book. the I want to eventually become an expert at understanding and applying the patterns these authors elucidate.
I plan to use these books as touch stones in the coming months. I will be moving into a more active phase where I will be coding phase during my sabbatical. I’m also sure I will be unpack and implementing the lessons I’ve learned through out my software engineering career.