mitre

Become a Software Engineer from Scratch

If I were to become a Software Engineer again, this is how I would do it from scratch. This guide is designed for those looking to transition into software development, whether you're coming straight from high school, from college or switching from an existing career. It begins with approachable content and focuses on building a core knowledge and skill set applicable to nearly any software engineering role. As with any self-guided course, the more effort you invest, the more you will gain!

Before you Begin...
link

I do not cover topics like Java, Javascript, and Frontend Frameworks (React, Angular etc.). If you're looking specifically for those things, this may not be the guide for you. See towards the end, "The Missing Topics", for my thoughts on them, if curious. If you want to walk away with knowing two languages, Python and Go, fairly well, and have a good understanding on how the internet, HTTP, and other protocols work, then let's begin.

Getting Your Feet Wet
link

Software Engineering involves coding but requires setup, such as choosing a computer, a code editor, access to the command line and more. This section skips that setup, letting you start coding immediately to see if you enjoy and want to pursue it.

Tip: Focus on the idea of writing code and whether it interests you. It's okay to make mistakes and struggle with concepts. Enjoying the process and completing the content is a better indicator of success than being "naturally" good at coding.

optional
circle
Complete a Programming Course

When asked how to start coding, I recommend Treehouse. Their videos are high quality and paced well, and they provide all the tools you need right in the browser. I used it years ago and still believe it's a great resource for beginners.

Key Points
  • This and very few other resources I recommend come at a small monetary cost.
  • Treehouse cost $25/m and it's used just for three core introductory courses and then you can cancel. Maybe a month or two's worth total.
  • I make no money from anything I recommend.
Getting Technical
link

Decades ago, programs ran in isolation without communicating with other software, on other computers. Today, most software interacts with the Internet or Web, and without Internet access, many programs lose functionality such as email. Understanding how computers, the Internet, and the Web work is crucial for software engineers. This section shifts focus from coding to foundational knowledge of modern computing.

optional
circle
Complete a Technical Course

This is another great set of introductory content from Treehouse. It focuses on the technical side of being an engineer.

optional
circle
Read About the History of Computers, Software, and the Internet

This book chronicles the events and key players in the history of computers, microchips, programming, software, and the internet. I thoroughly enjoyed it, and if you're enjoying what you're learning so far, I think you will too.

Operating a Computer in a New Way
link

We're all familiar with using a computer via its Graphical User Interface (GUI), however, as a software engineer you will spend a LOT of time using your computer via its Command Line Interface, or CLI/terminal for short.

Tip: The words terminal and CLI, or Command Line Interface, mean the same thing in this context.

optional
circle
Complete a Course on the Terminal

All the things you know as second nature such as navigating to folders, running software, creating and managing files, you'll learn again from a whole new perspective in this introduction.

Core Topics Checkpoint
link

If you've completed the above courses, great job! Writing code, understanding how computers work and communicate, and operating a terminal are what I consider three core pillars that almost every engineer is familiar with to some extent. Additional topics such as HTML, CSS, UI/UX, mobile development, and interacting with databases are optional as engineers begin to specialize in different niches, just like in any field. We're going to step it up a notch from here.

Tip: Future content will test your ability to get frustrated and work through it. Do not become discouraged. Even the most seasoned engineers deal with new topics and frustrations and work through them every day.

optional
circle
Review Content if Needed

If you had a hard time with the above content, review it until it starts clicking. We're going to build off of it and the expectations will be higher.

Key Points
  • Try your hand at writing code
  • Build some foundational knowledge of how computers work, and how they communicate with each other.
  • Become familiar with the terminal, especially navigating through folders/directories, and managing files.
optional
circle
Start Watching Harvard's CS50 Lectures

Every year, Harvard publishes their lectures for their Computer Science 50 course, for FREE.

Key Points
  • This is over 24 hours of lectures; it will take time!
  • You'll be exposed to a lot of topics and concepts.
  • Your goal is to just listen and familiarize yourself.
Learning to Unstuck Yourself
link

One of the most critical skills a software engineer must acquire is the ability to search the web for solutions to unexpected problems. This section includes a few techniques to keep in mind when you get stuck.

Tip: In the following resources, you'll be exposed to a lot of odd terms, it's ok if you don't know what they mean, just absorb what you can.

optional
all_inclusive
circle
Reading Documentation

Any tool, software, language, or anything else technical most likely has documentation.

Key Points
  • Things such as Pandas numPy etc. are related to machine learning, don't worry about these things.
  • Focus on how docs are organized, reference vs Getting Started etc.
optional
all_inclusive
circle
Using Google Effectively

Any engineer will most likely tell you they're a "professional Googler" more than an engineer, here's how it's done.

optional
all_inclusive
circle
Troubleshooting Code

As you write code, you'll encounter all sorts of errors and odd behaviors. Here's some beginner resources for troubleshooting your work.

Key Points
  • When your program doesn't do what is expected, we call it a bug
  • debugging is the process of troubleshooting the cause and implementing the fix of a bug
optional
all_inclusive
circle
Asking for Help

It's inevitable you will simply not know how to get past a problem and you will need to seek help. There's a right way to do it.

optional
all_inclusive
circle
Do not ask Chat GPT!

It's important that you do not use ChatGPT in this journey for the same reason why your math teacher wouldn't let you use a calculator in school. See Missing Topics Section on why.

Upgrade Your Development Environment
link

So far you've been using Treehouse's workspace for code development and learning. As convenient as it was, real software development requires what's know as a development environment. A development environment is simply setting up your workstation in order for it to be suitable to develop and run code on. Here are some options.

Tip: No matter which method you choose going forward, you need to at least know how to setup your own computer for software development.

optional
circle
Develop on Your Computer

Often known as a "local setup" involves installing a text-editor (what you write code in), a runtime (what interprets, or prepares your code for execution), and some sort of terminal to interact with your program and to view its output.

Key Points
  • Keep in mind that the terminal on Mac, Windows, and Linux all behave differently!
  • Mac and Linux, are very similar, Windows is very different (Uses Powershell)
  • Mac Terminals use KornShell by default, you will want to use Bash (Google it!)
optional
circle
Use Windows Subsystem for Linux

Windows users have the option of installing the Windows Subsystem for Linux, which allows you to run a Linux OS on Windows. Its fairly involved, if you're feeling brave.

Key Points
  • If you follow the Setup Python Guide above, stop after "run-a-simple-python-program"
  • Ubuntu is a Linux distribution (type of Linux OS).
  • WSL provides you Ubuntu, which you can access via a terminal (no Desktop Interface)
optional
circle
Use a Browser Based Environment

Development environments have come along way and now its possible to have a fully featured environment in your browser. This is most likely the easiest to setup.

Key Points
  • I highly recommend closing the AI tab, and disabling the AI autocomplete. You need to learn these skills without AI first.
optional
all_inclusive
circle
Get Into the Habit of Using Your Terminal

Using a terminal for the first time when you've only used a Desktop GUI (Graphical User Interface) is very challenging and frustrating. The quicker you get into the habit of using it, the more you will thank yourself later.

Key Points
  • ThePrimeagen is a former Netflix Engineer who runs a Twitch stream where he provides his takes on engineering content.
Prepare for Project Based Learning
link

Reading tutorials and watching videos will only get you so far. The real learning occurs when you attempt to build something, get stuck, fail, and get through it. As an engineer you will be expected to take requirements which describe what the software should do and implement them.

optional
circle
Use Tutorials Sparingly

As a new developer you'll find yourself gravitating towards tutorial based content. This can slow your growth. A few are ok, but it's critical that you challenge yourself with projects.

optional
circle
What are Features and Stories?

(F)eatures are high-level capabilities of a product that address user needs. (S)tories are user-centric descriptions detailing specific aspects or interactions with those features for development purposes.

Key Points
  • In an engineering role, your work will be assigned to you in the form of User Stories.
  • As you implement User Stories, they will contribute to larger Features.
  • As more Features are completed (delivered), the Value of the Software/Product Increases.
  • The bare minimum program that can be shipped (delivered to customers) is called the Minimum Viable Product (MVP).
optional
circle
Review Example Blackjack Project

Here is an example of how the requirements of a Blackjack game are organized into features and stories. When you work a project, you tackle one feature at a time, and one story at a time. This is called staying in scope.

Key Points
  • Each project I present to you in this guide will be in this format.
optional
circle
Learn a Development Process

When you first start out, you are taught a lot of coding syntax (how to write an if, a loop, a function, etc.). This article, which I wrote, demonstrates a methodology for how to develop software using the Blackjack project as an example.

Key Points
  • The article assumes that a developer is working on the entire game at once. When you work one story at a time, simply paste the story requirements as comments and follow the same tips in the article.
  • When you implement all of a story's requirements, paste the next story into the program as comments and repeat the process.
  • Can you challenge yourself and after reviewing the project and reading the article, and implement it yourself?
Complete Entry Level Projects
link

Now without being shown a solution, you should have what you need to complete a few entry-level projects. These include a basic understanding of a programming language, techniques on how to unstuck yourself (engineers call this being blocked), and a methodology for developing software.

Tip: The first time you code on your own it's going to be a frustrating mess. This is perfectly normal, and you'll look back on your first projects and chuckle at some of your techniques and implementations you used.

optional
circle
1. Complete a Guessing Game Project

Every programmer must write a guessing game. It's a rite of passage.

Key Points
  • This project can be completed without the use of functions.
  • Use functions if you want.
optional
circle
2. Complete a Trivia Game

Something a bit more complex. It's good to stretch and challenge yourself. Build off what you know. Incorporate new knowledge and concepts.

Key Points
  • You might think these projects are silly, but given enough time, people have made big bucks developing trivia software. See TriviaMaker ^
optional
circle
Avoid Object Oriented Programming

For now, avoid object oriented programming for these projects. For example, avoid creating your own classes. This guide will introduce the topic later on, in more detail.

Using Code Repositories and Version Control
link

Now that you have code, the question arises on where to store it. In the same way you might store your documents in a cloud drive, software engineers store their code in something called a code repository. A code repository is a storage location for code and other software development assets, such as documentation, tests, and scripts. They are often used to manage and organize a project's codebase and collaborate with other developers. We almost always shorten it to just a "repo".

optional
circle
Create a Github Account, and Install Git

GitHub is a web-based platform for version control and collaboration, enabling developers to host, review, and manage code repositories using Git.

Key Points
  • Git is a Version Control System
  • GitHub is a platform based on git based collaboration workflows.
  • Github offers a LOT of functionality, just stay focused on code repos for now, stay away from topics like Actions, etc.
optional
circle
Learn how to use Git

Another core skill for engineers is their ability to collaborate and contribute to one or more repos. These repos will most likely be using the git version control system. Here are some guides on learning it.

Key Points
  • git - The Simple Guide and Dangit Git are my favorite references for dealing with git. Keep them handy.
  • Your "everyday" commands are going to be clone, branch, add, commit, push, and pull.
  • Your "situational" commands, are going to be merge, checkout, rebase.
optional
circle
Push Your First Projects to Github

Using git, create a repo called "my-first-programs", create a directory for each project, add your code, and push it to github.

Key Points
  • This will be a fun snapshot of your first projects.
  • You'll look back on these fondly and now you will always have them to share with others when you help them out one day.
  • Any new project you work on, should be its own repo.
optional
all_inclusive
circle
Incorporate Git into Your Workflow

Get into the habit of storing your projects in git, and incorporating it into your workflow.

Key Points
  • One project to one repo
Complete an Intermediate Project
link

This next project is going to push you a bit further and introduce you to a few new concepts. Using Git as you work, Error Handling, Testing, and Building CLI Tools.

Tip: Writing good tests is an art all on its own. Just do the best you can for now. Keeping functions small and single purpose (they aim to do one thing), makes testing easier. For now I would write a function, write a test for it, and do not get caught up in the Test Driven Development approach at this point.

optional
circle
Learn About Error and Exception Handling

Errors and Exceptions are what occur when something unexpected occurs in your program. Handling the exception or error is what action your program takes to recover (prevent a crash and continue running).

Key Points
  • Ensure you play around with exceptions and error handling in small programs before moving to the project.
optional
circle
Learn About Unit Testing

Unit testing involves testing individual components or functions of a program to ensure they work as intended. It helps catch bugs early and ensures code reliability.

Key Points
  • Create a python file with a few functions that you write for various things, see if you can write tests for them and find edge cases and account for them.
optional
circle
Learn About Creating CLI Tools

A lot of the software you end up writing will involve creating CLIs or interfaces to your software via a CLI. Here are some guides.

Key Points
  • If you find yourself writing a lot of Python, Python Module of the Week, linked above (Argparse), is a great reference guide for Python's modules.
optional
circle
Build a Task Management CLI Tool

Incorporate everything you know into building a task management CLI tool. This project should take you some time to complete. Stay "in scope", which means only focusing on delivering the requirements of one story at a time!

Key Points
  • Focus on one story at a time!
  • Try to plan out your code and functions using comments.
Refactoring for Readability and Efficiency
link

If you've gotten this far, you should have a few projects under your belt. You've applied the skill of writing code, and solving a few problems. In this section we're going to look at the process of refactoring code, which is revisiting prior work, and introducing improvements to increase efficiency (how well it executes) and readability (how easy it is to understand) without changing how it behaves.

Tip: If you've written tests for your functions, they will prove that your code is still functioning as expected during your refactoring.

optional
circle
Learn About Efficiency and Readability

Here's an article, which I wrote, showcasing 11 practices to keep in mind going forward.

Key Points
  • CodeAesthetic is a great channel to learn and visualize coding techniques
optional
circle
Revisit Past Projects

Instead of writing a new program from scratch, you'll be revisiting the trivia game and the task manager tool.

Key Points
  • Apply what you've read in the prior step to the Trivia Game and Task Manager
  • Create a new git branch for this work
  • Refactor a little bit at a time, focus on one function or portion of your code
  • Run your test as you go to ensure it's not breaking any existing functionality
  • As you complete each portion of your refactor, create a git commit - explain what improvements you've made.
A Paradigm Shift
link

For now you've be writing code as "procedural", meaning your code is organized into procedures, i.e. functions, and executed top-down, or in sequential order. This is one way to write and organize code, known as a coding paradigm. In this section you're going to explore writing code in the Object Oriented Programming (OOP) paradigm. OOP is the idea of thinking about your code as objects with methods, or "things", that can perform "actions".

Tip: If your brain feels fried when trying to wrap your head around OOP, that's fairly normal. As an engineer, the way your brain understands things will continually be challenged and flipped on its head.

optional
circle
Learn About OOP

A set of resources to have handy when learning OOP. The First link used Javascript as it's examples, but explains the four OOP principles very well.

Key Points
  • Python is just one of many OOP languages, the most widely known being Java, and C++
  • Encapsulation - Bundles data and methods that operate on it within a class, hiding internal details.
  • Abstraction - Simplifies complex systems by modeling classes based on essential characteristics.
  • Inheritance - Enables new classes to inherit properties and behaviors from existing classes.
  • Polymorphism - Lets you use a single method name for different types of objects, where each object can respond in its own way.
optional
circle
Expand Your Testing knowledge With Mocks

When writing tests in an OOP context, we often have to create fake objects, called Mocks. These Mocks stand in for the actual objects in our tests.

optional
circle
Apply OOP To an Existing Project

Using the provided codebase, linked below as a starting point, refactor the project to use the OOP paradigm. If you'd like, you can also start the project from scratch using the "create-a-blackjack-game" project guide.

Key Points
  • Think about what becomes an object, what becomes a method etc.
optional
circle
Complete an Intermediate Project using OOP

Apply your knowledge of OOP to create a Monster Battle Game. This Project is a guide, but you can expand it. Have fun with it.

Key Points
  • This project will most likely be the most complex you've created so far.
  • Be creative and make it your own. What would you add to the game?
optional
circle
Further Reading about OOP

If you'd like to dive deeper into the history and background around OOP.

Your First Language Checkpoint
link

Congratulations on reaching this point! You've gained familiarity and experience with Python, a language that can solve nearly any problem. If you're comfortable, feel free to move on. If you're still struggling, revisit the projects and resources, and do your own research to find material that clicks with you. After that, and even if you have doubts, you can still proceed. In the next sections, we'll explore a new programming language which could resonate more with you than Python.

Tip: The next set of sections are designed to move you out of your comfort zone of Python. As a Software Engineer you will be exposed to new languages and new ways of thinking, the sooner you develop the ability to switch into a new language, you will always have the ability to adopt any new languages going forward.

optional
circle
Review Content if Needed

By now you should have built multiple projects using Python. If not, it's important you complete these projects as the best way to learn is by doing.

Key Points
  • Implement multiple projects in Python
  • Implement at least one project in the procedural and again in the OOP paradigms.
Introduction to Go
link

The second programming language this guide focuses on is the Go programming language. Go, or Golang, is a statically typed, compiled language, created by Google. Unlike Python, which is dynamically typed and interpreted, Go emphasizes simplicity, concurrency, and performance. Its syntax is clean and minimalistic, making it easy to learn. While Python excels in rapid development and flexibility, Go shines in speed, efficiency, and ease of deployment for large-scale systems.

Tip: Everyone loves and is biased towards their first language. There is a good chance you will simply hate working with a new language after working with Python and this is normal. Eventually the new syntax and concepts will click into place and you won't notice it anymore. It takes time.

optional
circle
Take a Tour

These are great introductions to Go. It assumes you already know a language and programming concepts such as variables, functions etc. There will be new terms and concepts as well.

Key Points
  • Absorb what you can, it's an introduction after all.
  • The goal is to become familiar and aware, not an expert
  • The video is to inform you, not a tutorial!
optional
circle
Prepare For Go Development

Install Go, configure your text editor (VS Code or similar), and Create Hello World

optional
circle
Keep The Docs Handy

A list of key Go reference materials to keep in mind as you code.

optional
circle
Blackjack, Again!

Revisit the Blackjack game once more, only now code it in Go. Upon completion you should have a Python procedural, Python OOP, and now a Go implementation to compare.

Key Points
  • You already know how to program at this point, this exercise tests your ability to convert a known solved problem into a new language and syntax.
  • Think about how a solution is solved differently in a new language, etc.
  • Remember how to unstuck yourself!
  • Focus using variables, slices, maps, if/if else, for, and for range.
  • You should be able to complete this project without the use of Pointers, Interfaces, Generics, Goroutines. If you find yourself reaching for these, perhaps your implementation is too complicated?
Intermediate Go
link

In this section we're going to introduce some new concepts that are not available in Python but are fairly common in Go - Pointers and Interfaces.

Tip: Pointers and Interfaces can take a while for their concepts to click, especially interfaces. It's one of those things where "you'll know you'll need it when you need it" and you'll say to yourself, "Ah I can use an interface for this."

optional
circle
Learn About Pass by Value and Reference

In Go, variables can be passed by value (a copy), or by reference (a pointer to a value). Learn about each.

Key Points
  • Python also has a similar automatic behavior.
  • Python Objects (like integers, strings) behave as if passed by value because you can't modify them in place.
  • Python Mutable objects (like lists, dictionaries) are passed by reference, meaning changes made inside the function are reflected outside as well.
  • In Go, using pointers allows the developer to explicitly pass something by value or by reference.
optional
circle
Learn About Structs and Receiver Functions

In an OOP language like Python, Objects can have methods. In Go, you can declare custom Types with their own "methods", called Receiver Functions.

Key Points
  • It's important to reiterate that although looks like an OOP language, it is not.
  • When developers are referring to values created from custom Types, it may still be referred to as an "Object", but it is not an object in a OOP sense.
optional
circle
Learn About Type Assertion, and Conversion

Unlike dynamically typed languages, like Python, in Go there are specific ways to convert between types, and to identify types.

Key Points
  • Assertion - Accesses an interface's underlying concrete type, e.g., value.(int). It panics if the type doesn't match.
  • Conversion - Converts a value from one type to another explicitly, e.g., float64(42). It only works between compatible types.
optional
circle
Complete the NumberCruncher CLI

The number cruncher CLI tool is a CLI which provides a basic calculator, unit converter, and area calculator.

Key Points
  • Utilize Pointers and Interfaces in your implementation.
optional
circle
Arcade Project Challenge

Combine previous projects into an arcade. If you're up to the challenge, this is a great exercise to apply what you know to build something bigger.

Key Points
  • Combine the trivia game, Blackjack Game, and Number Guessing Game into one program.
  • Allow the player to choose which game they want to play when running the program.
  • Use an interface to launch each game in the arcade.
  • What other games can you add to the arcade?
Second Language Checkpoint
link

At this point you should have a strong foundation working with Python and Go. In the next few sections we're going to move beyond writing self contained programs and begin working with networked programs (clients and servers). First by focusing on internet protocols IP(network addressing), DNS(converting domain names to addresses), TCP(sending data reliably over a network), and HTTP (the protocol of the web). Along the way you will be writing programs which utilize these protocols.

Tip: Understanding networking technologies is incredibly important. As a software engineer, nearly everything you build will need to interact with another service over a network connection. Protocols are also very established technical standards. You may learn different languages or technologies frequently, but the underlying protocols will nearly always be the same. Any time spent diving deeper into these protocols will always be time well spent.

optional
circle
Review Content if Needed

At this stage, you should be able to write basic programs. If not, review the earlier content until you can. We'll continue with Go, focusing mainly on networking and web-based programming as we progress.

Key Points
  • Ensure you can create basic CLI utilities.
  • Ensure you can read and write to files.
  • Ensure you can read and write JSON data to and from files.
optional
circle
Power Up knowledge

Additional Knowledge and tools to keep in mind as you progress

Key Points
  • As your projects get larger, it's important to stay organized.
  • IDEs are powerful developer tools used to work with and refactor large code-bases, databases and more, VS Code is still fine though!
  • Start looking at how to use your editor's debugger to hunt down bugs using powerful debugging tools.
optional
all_inclusive
circle
Always be Coding

All the projects have been pre-defined up to this point, but part of the fun of being an engineer is creating your own programs for fun or to solve your own problems.

Key Points
  • Get into the habit of writing games, tools, etc. to keep your coding mind fresh.
  • Some sections will not focus on coding as we dive into other topics, it's important you keep coding on your own until another project is recommended.
Concurrency and Socket Programming
link

Along your journey you'll be directed into other guides which cover major topics and techniques. This first guide covers networking more in-depth, and guides you through the completion of a larger project centered on TCP sockets.

optional
circle
Complete the Concurrency and Socket Programming Guide

Complete all non-optional steps in this guide. Return to this guide upon completion.

HTML, CSS, and Hyper Text Transfer Protocol (HTTP) Fundamentals
link

If you've implemented the made-up protocol, STTP, I have a secret to share. It's been done already. The real-world STTP is actually called HTTP. Under the hood HTTP works in a similar way, it interacts with TCP for you so you can just work with a higher-layer protocol suited to applications. This section takes a break from programming to focus on how the web works and specifically HTTP. There is still programming though, using the declarative paradigm, which you will learn more about.

optional
circle
Complete the Basics of HTML, CSS, and HTTP Guide

The topic of the web is huge. Huge. Huge. It's important to dabble with HTML and CSS but your main focus is HTTP. We'll be using it more going forward in our programming.

Key Points
  • HTTP is critical to understand.
  • Complete this guide and return back to here.
  • Yes, building and running your own web server will be painful, but ya just gotta know how it's done.
  • We'll get back to "real" programming soon enough!
Preparing for Larger Projects
link

You're about to start a new project which will last through multiple sections. You'll build a simple web application and slowly add new functionality, features, and security enhancements over time. Stay organized. Take your time. It's important to know what goes into building something big "the hard way" to appreciate how later tools make it easier the next time you want to build something.

Intro to Web Application Servers
link

Unlike a web server and off-the-shelf HTTP servers like NGINX. Application servers not only can serve static pages (content that does not change), but can also dynamically create, read, update, and delete documents for one or more clients. This set of actions performed by an app server is known as CRUD, and nearly every website implements all of these functions. In this section you'll learn how to develop a basic web application server.

Tip: You might see in a lot of examples of developers using and testing JSON and talking about APIs. We'll get there. Just try to stick to basic HTML pages for now.

optional
circle
Build a basic HTTP Server

This is nice, simple, example on how to setup an HTTP server with logging and tracing.

Key Points
  • Logging and tracing provides visibility into you application as it grows bigger and does more things.
optional
circle
Learn About Testing HTTP Servers

A few examples on how to test your server using the httptest package.

optional
circle
Further Reading

Sometimes a book can explain and teach a lot more than online examples and videos which are often too short for deep learning.

optional
circle
Start the Simple Sticky Web App

Begin the Simple Sticky Note App by completing Phase 1 - MVP.

Key Points
  • Introduces you to the basics of CRUD
  • Just focus on Phase 1
  • You'll need to template HTML for this project.
optional
circle
Use a CSS Library

It can be tedious working with CSS, you're welcome to write all your CSS by hand, but I recommend Tailwind CSS to make it easier.

Key Points
  • CSS falls more into the Frontend / Web Design discipline which can distract and eat up time of developers.
  • This library abstracts away CSS's real syntax in favor of a higher-level interface to make it much easier.
  • Just install it from the CDN script tag, do not get into npm and a that mess.
optional
circle
Research it

Why is it that HTML forms only support GET or POST, but not PUT or DELETE?

Key Points
  • What are some workarounds which developers have done over the years?
Databases and SQL
link

Up until now, our app has used the filesystem to store data, but this approach has limitations. If the machine hosting the app crashes, all data is lost. For large apps running in clusters, where multiple instances share data, the filesystem doesn't work. To address these issues, a database is used. Databases allow us to create, modify, and query data using a query language. You'll learn a little about query languages, and using a DB with your app.

Tip: The topic of installing, running, maintaining, and operating a database falls under an entire discipline of IT called database administration. This will just be a taste as software engineers typically have to know enough about the topic to use it with their applications.

optional
circle
Learn About Databases

The most common type of database is a relational DB, but others types exist. Learn about what databases are and the different types.

Key Points
  • When reviewing the types of SQL Databases, focus on what they are, and their pros and cons.
  • We're going to be using SQLite in our app.
optional
circle
Learn About SQL and NoSQL

Structured Query Language is used to query, or interact, with a SQL database. Learn the basics of what it is and how it works.

Key Points
  • Watch the videos, and try the interactive tutorial to become familiar with SQL
  • Refer to SQL reference as needed in your work
  • You're not trying to become an expert! Just broadening your awareness of this technology.
  • We're going to stick with SQL but understanding SQL vs NoSQL is good to know as well.
Utilizing a SQL DB
link

Now that you've become familiar with databases and SQL, configure, and start using it with your app server. You'll continue building the Simple Sticky Note app and swapping out the filesystem storage implementation with a DB implementation.

Tip: Each SQL Database can often have a slightly different syntax when writing and using SQL and may require more research and experimentation.

optional
circle
Use a File Based Database

SQLite is a file-based SQL Database (does not run as a service or process) and is simple to work with.

Key Points
  • Follow the tutorial above, ensure you can get a basic go program working with SQLite
  • SQLite should not need to be "installed", the go package will create and interact with databases as you use it.
optional
circle
Run a Database Service

Use Postgres for a more real-world setup where your app will establish a connection to a DB service.

Key Points
  • Each database uses a different driver or package designed to work with a specific DB technology
  • There are standard packages and a lot of popular packages (defacto standards) other engineers have written which can be used as well
  • Often times where an app runs and where the DB runs are on two different machines.
  • IDEs, such as those from JetBrains can interact and provide tools for working with SQL Databases.
optional
circle
Expand the Simple Sticky App

Complete Phase 2 and 3 - Implement boards and search capability

Key Points
  • Introduce the use of a SQL DB to the app.
  • Choose to use SQLite or Postgres.
  • Just focus on Phase 2 and 3.
optional
circle
The ORM Debate

An Object Relational Mapper is an abstraction library which handles all the SQL for you. But there are debates if it's a good idea or not.

Key Points
  • Engineers are very opinionated, the ORM debate will have strong opinions for and against.
  • You should at least try it out at some point, as working with ORMs is still common to see.
  • A middle ground is to use something like Squirrel which implements a "Builder Pattern" to help build queries for you.
APIs and REST
link

An API (Application Programming Interface) is a set of rules that allows software applications to communicate. It defines how requests should be made and what responses will contain, enabling one app to use functions or data from another. APIs simplify integration, automation, and the building of complex systems. You'll learn what APIs and specifically what a REST API is and build one into the Simple Sticky App.

Tip: I like to think of an API as the menu of a fast-food chain. The menu plays the role of the "API" and it explains to you (consumer) what requests are possible from the restaurant (provider) and what you will receive with each request. APIs are simply the menus which one app (provider) exposes for other apps (consumers) to "order from".

optional
circle
The Role of an API

Learn what an API is and how apps use them.

Key Points
  • Note that I don't like the idea that "APIs connect apps", HTTP/TCP does this.
  • I like to think of an API as a menu, see the tip for my explanation.
optional
circle
Learn About REST APIs

REST is a type of API pattern you can use to structure how requests should be formed along with their responses.

Key Points
  • The Stripe API is one of the most well documented APIs out there. Poke around.
  • What other APIs can you find for known sites?
optional
circle
Expose a REST API for the Simple Sticky App

Complete Phase 4 - Expose REST API.

Key Points
  • You can use Postman, Curl, or any other HTTP Client to interface with the REST API as you build it.
  • Writing tests for APIs is often much simpler than HTML templated apps.
  • Serializing and Deserializing JSON is the process of converting Go struct to and from JSON string equivalents for HTTP requests and responses.
optional
circle
Build a Client CLI

If you're looking for more experience. Implement a CLI tool which can interact with the Simple Sticky API. Similar to the STTP CLI tool.

Key Points
  • Design your own CLI tool and implement it.
Simple Sticky Halfway Checkpoint
link

The Simple Sticky App is a big project and an important one. It provides a hands-on experience on what really goes into building an application, and there's a lot that isn't covered. We're going to pause here and talk about burnout and motivation.

Tip: Every developer goes through burnout phases. It's not just you, you can do it! When ready continue on to the next section.

optional
circle
Burnout and Motivation

Great takes on dealing with burnout and motivation.

Security and Vulnerability Management
link

Shifting back into academics and building strong foundational knowledge, the next topic is security. You may really enjoy the topic or find it a bit dry. Regardless, it's critical to implement security best practices. As you become familiar with the basics of security, you'll work on securing and expanding the Simple Sticky App further.

Tip: If you really enjoy these topics, consider going into cyber security! Your programming skills would come in handy. You'll be able to review code for security flaws and recommended mitigation techniques.

optional
circle
Complete the Basics of Web Security Guide

Complete this guide and work through the next steps in this section as you go.

Key Points
  • After completing each section, come back here to find the corresponding project.
optional
circle
Enable TLS and HTTPs in Your Apps

After Completing - "Introduction to Cryptography, TLS, and HTTPS"

Key Points
  • Following Secure Coding Practices, find the recommended HTTPS Go examples in the linked book and implement it in your past projects.
  • Generate your own self-signed certs and keys. (Never use in production)
  • Enable HTTPs in the Simple Sticky Web App, ensure you can toggle it on and off.
  • Challenge yourself and see if you can secure the TCP client and server for the STTP project.
  • Use Wireshark to see before and after TLS enablement, what's visible over the wire?
  • you can turn off HTTPS in your app once done to make development easier
optional
circle
Implement Phase 5 - Authentication and Authorization

After Completing - "Authentication and Authorization", implement the listed features under Phase 5.

Key Points
  • HTML Authentication
  • HTML Authorization and Access
  • API Authentication
  • API Authorization and Access
optional
circle
Implement Phase 6 - Vulnerability Management and Mitigation

After Completing - "Vulnerability Management and Mitigation", implement the listed features under Phase 6.

Key Points
  • Vulnerability Management and Mitigation
Libraries, Frameworks, and Providers. Oh My!
link

Using libraries, frameworks, and providers accelerates development by offering pre-built, tested solutions for common tasks. They reduce the need to write everything from scratch, ensuring security, scalability, and best practices. Providers offer specialized services, like authentication or payments, with robust infrastructure, letting you focus on core features while leveraging expert-managed systems. Let's explore them.

Tip: You should pat yourself on the back for reaching this far. Most courses place beginners into frameworks right away. This guide aims to develop you into a software engineer, not simply a framework engineer. By using a framework, you'll have an understanding and appreciation of the problems it is solving because you've experienced them!

optional
circle
Third-Party Libraries

Third-Party Libraries are packages of code written by others to solve for common problems. It's often a good idea to consider using a 3rd party library for complex tasks or security concerns.

Key Points
  • Throughout this guide, you have used a few libraries where it makes sense.
  • Treat them as building blocks to use within your project as needed.
  • Engineers have varying opinions on when they should be used.
optional
circle
Frameworks

Frameworks are very opinionated, small or big, pre-built, "starter kits" used to build an application from. It's required to understand a framework's conventions in order to use it. They often follow a design pattern, such as MVC.

Key Points
  • Just simply explore their documentation and usage guides, you'll see they solve a lot of problems for you.
  • They can often abstract a lot of the underlying programming language, i.e. This can be good or bad, depending on your perspective.
optional
circle
Providers

Very complex tasks, such as file upload, authentication, processing payments typically require the use of a provider service. Even entire data centers and more can be provided to you in the form of a cloud provider, like Amazon Web Services.

Key Points
  • Just simply explore their documentation and usage guides.
optional
circle
Mix and Matching

There are hundreds of frameworks! But by implementing the same API, they can be mixed and matched to build a tech "stack".

Key Points
  • It's very easy to fall into a trap of over-engineering an application!
optional
circle
Keeping it Simple

This is a long video but I highly recommend at least reading the article. It's an opinionated take on the importance of keeping things simple. I agree with this opinion.

Next Steps Checkpoint
link

You made it! The Simple Sticky Notes App is done. Feel free to do more with it and really make it yours if you'd like. You've built something from near scratch and at the end, saw the potential value that libraries, frameworks, and providers bring. We're going to look at much smaller problems, and much larger concepts. Data Structures and Algorithms, and Systems Design.

Tip: Coding Problems are the programming equivalent of word problems in math. They're designed to show how well you can think through a problem, collaborate with other people, and how you handle situations when you get stuck. The key is practice, practice, practice.

optional
all_inclusive
circle
Practice Data Structures and Algorithms

Data structures organize data; algorithms solve problems efficiently. Knowing them is vital for writing optimized code and is crucial in interviews to show problem-solving and coding skills. I'll provide a free and paid option for learning.

Key Points
  • Do a few each day, practice makes perfect.
  • Take a brake if you get stuck, or switch to easier problems.
optional
all_inclusive
circle
Learn About Systems Design

In addition to knowing how specific algorithms work, you'll need to have an understanding of Systems Design, which is knowledge on how larger software applications are built and scaled for performance.

Key Points
  • Become familiar with these topics and patterns.
  • I really like the visuals from Byte Byte Go.
  • Watch them in your downtime, they're short but good.
optional
circle
Free - Learn from ThePrimeagen and LeetCode

ThePrimeagen is a former Netflix employee who is a full-time content creator. This course is free when you sign up on Frontend Masters. LeetCode is a free site to practice problems.

Key Points
  • Search YouTube for explanations to problems
optional
circle
Paid - AlgoExpert

Built by a Former Google Engineer Clement Mihailescu, it contains a course, questions, and explanations, all rolled into one. It is pricy though...

Key Points
  • Also contains a Systems Design Course as well.
optional
circle
Further Reading

Consider these books for deeper learning and insights.

The Engineering community
link

Let's move on to a more people centric topic. The Software Engineering Community. Like any industry, we have lots of opinionated people, but most importantly I think it is one of the best industry communities. We like to give away ideas and solutions for free though Open Source, like building things, and overall do not judge you based off your academic background. Lots of us, including myself, are self-taught and come from different backgrounds. Here's a bit about us.

Tip: Communities are best when you get involved!

optional
all_inclusive
circle
Open Source Software - Using and Contributing

Nearly all the code and tools you've used in this guide have been provided online for free. but it's more than free software! It's a culture of collaborate to build bigger things than what any one person or company can do.

Key Points
  • Contribute back to the projects you use and love.
  • Contributing is a great way to get involved.
  • Contributing provides a great experience of working within a team, which can help build your resume.
optional
all_inclusive
circle
Read Blogs. Hear Out Opinions.

We also have our bloggers and internet-famous content creators, I often enjoy hearing different takes and opinions on things.

Key Points
  • Each language and technology also holds yearly conferences.
  • Conference Talks are often published on Youtube afterwards.
DevOps and Tooling
link

Moving back into the technical side. If you remember way up in the the guide, you built your own website and published it on the web. If you thought the task of doing that was tedious and a pain, you're right. Imagine doing that for thousands of systems! Software you build will be deployed to production and operated by a group of automation engineers from the Devolvement Operations discipline, or DevOps. You'll be introduced to them and their tooling in this section.

Tip: If you actually liked working with the technology and infrastructure, consider a role in DevOps! You're programming skills will come in handy as you build and develop automated systems and workflows.

optional
circle
Learn About Containers

Everything is built and deployed in containers these days, testing, building, running your code. It's the new VM!

Key Points
  • Keep in mind that your value is learning how to write software, do not try to become a Kubernetes or Docker expert!
  • Become familiar with them, and know what they are.
  • It's good to have some hands on experience with Docker
  • Build awareness and basic knowledge of Kubernetes.
optional
circle
Intro to DevOps and CI/CD

DevOps is when development and automation practices are applied to delivering and operating software.

Key Points
  • Nana is a great content creator for all things DevOps and tooling. She most likely has a guide on it.
  • The IBM playlist is a good overview of the various concepts in DevOps.
  • Absorb and familiarize yourself.
Software Teams and Company Policies
link

Moving back to the people side of things. Eventually you'll be working at a company with lots of other people. This company will have many teams, and many engineers from all backgrounds. Companies also have a certain work culture to them and follow common working practices. Here's a little about what you can expect.

Tip: Getting things done at companies takes time. The bigger the company, the more friction there normally is.

optional
circle
Agile and Other Methodologies

It's very common that you'll be on a team which incorporates a work methodology called Agile/Scrum. I've secretly had you working on each project in Agile-esq manner. Story by story, feature by feature. There's a bit more to it though.

Key Points
  • Agile software development is a very subjective topic. People either are very for it, or very against it.
  • You'll have your own opinion of it one day, but this is what it is and its terms.
optional
circle
How Large Companies Deliver Software

This is a great explanation on how large companies deploy software. It explains what "environments" are very well, and really breaks it down.

Key Points
  • Web Dev Cody is great to follow especially if you want to build your own products as a solo developer.
  • He also works with frontend and would be a good creator to follow if you want to pursue that.
Final Stretch
link

This is the final stretch of this guide. What's left is a little bit about preparing for the interviewing process, a note about a few missing topics, and generally a few tidbits of wisdom from me.

The Missing Topics
link

You may have noticed a few missing topics, and they're big topics. Why didn't I feature any Javascript and with all the AI hype, where is the AI content? Let's explore these topics and more now.

optional
circle
On Javascript

If you want to build web apps, there's no getting around it. You have the skills now to go learn the language. But be warned, the Javascript community is very framework centric. See "How it Feels..." See more thoughts below.

Key Points
  • If you want to get into Web Development, Learn React and Angular. Big companies use it.
  • If you want to focus on the backend, which this guide did, you can look into HTMX and Alpine JS.
  • HTMX and Alpine are easy to pick up with just a little bit of JS knowledge, and with server-side templates you can build things with it.
  • I built SmeeGuides with HTMX and Alpine by the way, Go on the backend.
optional
circle
On AI

AI is extremely valuable as an _experienced_ software engineer. Take the hand example, linked. See my opinions below.

Key Points
  • Everyone is a hand expert, and can see the subtle extra finger or odd pose.
  • AI does the same thing with code, all the time, but until you know what code should look like, you simply won't spot it as a beginner.
  • If you want to use AI, ask it questions that you know how to recognize correct results, "how to append to a list in python", "how to iterate over keys and values in go". for starts.
  • If you're doing tedious work like defining a bunch of dummy JSON data, you can use it for that.
  • Do not let it solve your problems for you. Although when you get an error, it may be worth asking it.
  • Having it explain Bash and command options are great use cases too.
  • You get what you pay for, the paid version provides better quality and results.
optional
circle
On Tooling

I started in system administration, then DevOps, then cloud engineering, and finally, software engineering. Here's my take on tools.

Key Points
  • Tools are fun but boil down to reading the docs, following the instructions, and troubleshooting it when it breaks.
  • When you become an expert on a tool or a technology, a new one comes few years or so to replace it, and your knowledge is now obsolete.
  • What stuck with me over the years is understanding how protocols (TCP/HTTP) work and building core programming skills.
  • If you like writing CLI tools, and working with infrastructure, seriously consider DevOps. You'll find no shortage of things to tinker with.
optional
circle
On Test Driven Development

A debatable testing practice in the industry is Test Driven Development. Where you write test first, then the logic to implement it. It's like thinking backwards. I have a hard time thinking backwards. Here's some info.

Key Points
  • Learn Go with Tests is an amazing guide which walks though through learning Go but with TDD in mind.
  • Where it Went Wrong was a great talk I enjoyed, now I'm sharing it with you.
optional
circle
On Math

You don't actually need to be a mathemagician to become a software engineer. Now if you want to work on things like AI, Cryptography, and Machine Learning, not simply use them, yes you will needs lots of math!

optional
circle
On Java

If you want a "job", go learn Java and Spring Boot. You will find plenty of work. But in reality, I don't see the purpose of Java in 2024, other than it's what we've always used.

Key Points
  • It's less performant than Go or Rust, which are also statically and strict typed, and compiled.
  • Containerization made Java useless, as now any app can be "compiled once and run anywhere"
  • If the Enterprise FizzBuzz looks like something you want to work with, you'd love it.
Finding a Job, How to Prepare
link

Let's talk about the part you've worked towards. Getting the job. Here's how to prepare and what to do between now and day 1.

optional
all_inclusive
circle
Always be Building and Learning

To gain a job, you need experience and knowledge. And the only way to do that whether employed or not is to keep building things.

Key Points
  • CLI tools are great projects, without dealing with the distractions of Web Development
  • Stay away from building social apps, they're huge! Users, Followers, Comments, Pictures, Media etc. it's a lot and you can expect to be burnt out.
  • Don't worry about not completing them, I have tons of projects which never met the light of day, but I still learned from them!
  • Show off what you do build in Github, that's your portfolio.
  • If you do like Web Development, checkout Google Firebase and things like Next JS.
optional
all_inclusive
circle
The Secret Handshake

Love them or hate them, coding interviews are part of the process so you need to be prepared.

Key Points
  • Make sure you know the algorithms, and be able to talk to them.
optional
all_inclusive
circle
Apply to Jobs you Actually Want

Here are my tips on finding the jobs you actually want.

Key Points
  • Think about companies you want to work for, browse through their Software Engineering postings.
  • Take note of what languages they use, what technologies they use, what frameworks etc.
  • Learn those, and apply.
  • Don't take jobs using tools and languages you don't enjoy, you'll hate it.
  • Be realistic, SpaceX has a lower acceptance rate than Harvard.
  • Interviewing is a skill too, always throw your hat in the ring and give it go.
  • You can apply to the same company multiple times, you may be a good fit for another role they have.
This Isn't The End
link

You've completed what many say they want to do, but rarely finish. Software Engineering is more than bootcamps and frameworks. It's fostering a passion for technology, solving challenging problems, building cool stuff, and most of all a learning journey. This guide is just the start.

Contents