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!
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.
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.
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.
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.
This is another great set of introductory content from Treehouse. It focuses on the technical side of being an engineer.
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.
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.
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.
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.
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.
Every year, Harvard publishes their lectures for their Computer Science 50 course, for FREE.
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.
Any tool, software, language, or anything else technical most likely has documentation.
Any engineer will most likely tell you they're a "professional Googler" more than an engineer, here's how it's done.
As you write code, you'll encounter all sorts of errors and odd behaviors. Here's some beginner resources for troubleshooting your work.
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.
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.
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.
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.
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.
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.
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.
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.
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.
(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.
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.
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.
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.
Every programmer must write a guessing game. It's a rite of passage.
Something a bit more complex. It's good to stretch and challenge yourself. Build off what you know. Incorporate new knowledge and concepts.
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.
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".
GitHub is a web-based platform for version control and collaboration, enabling developers to host, review, and manage code repositories using 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.
Using git, create a repo called "my-first-programs", create a directory for each project, add your code, and push it to github.
Get into the habit of storing your projects in git, and incorporating it into your workflow.
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.
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).
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.
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.
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!
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.
Here's an article, which I wrote, showcasing 11 practices to keep in mind going forward.
Instead of writing a new program from scratch, you'll be revisiting the trivia game and the task manager tool.
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.
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.
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.
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.
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.
If you'd like to dive deeper into the history and background around OOP.
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.
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.
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.
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.
Install Go, configure your text editor (VS Code or similar), and Create Hello World
A list of key Go reference materials to keep in mind as you code.
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.
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."
In Go, variables can be passed by value (a copy), or by reference (a pointer to a value). Learn about each.
In an OOP language like Python, Objects can have methods. In Go, you can declare custom Types with their own "methods", called Receiver Functions.
Unlike dynamically typed languages, like Python, in Go there are specific ways to convert between types, and to identify types.
The number cruncher CLI tool is a CLI which provides a basic calculator, unit converter, and area calculator.
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.
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.
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.
Additional Knowledge and tools to keep in mind as you progress
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.
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.
Complete all non-optional steps in this guide. Return to this guide upon completion.
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.
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.
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.
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.
This is nice, simple, example on how to setup an HTTP server with logging and tracing.
A few examples on how to test your server using the httptest package.
Sometimes a book can explain and teach a lot more than online examples and videos which are often too short for deep learning.
Begin the Simple Sticky Note App by completing Phase 1 - MVP.
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.
Why is it that HTML forms only support GET or POST, but not PUT or DELETE?
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.
The most common type of database is a relational DB, but others types exist. Learn about what databases are and the different types.
Structured Query Language is used to query, or interact, with a SQL database. Learn the basics of what it is and how it works.
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.
SQLite is a file-based SQL Database (does not run as a service or process) and is simple to work with.
Use Postgres for a more real-world setup where your app will establish a connection to a DB service.
Complete Phase 2 and 3 - Implement boards and search capability
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.
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".
Learn what an API is and how apps use them.
REST is a type of API pattern you can use to structure how requests should be formed along with their responses.
Complete Phase 4 - Expose REST API.
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.
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.
Great takes on dealing with burnout and motivation.
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.
Complete this guide and work through the next steps in this section as you go.
After Completing - "Introduction to Cryptography, TLS, and HTTPS"
After Completing - "Authentication and Authorization", implement the listed features under Phase 5.
After Completing - "Vulnerability Management and Mitigation", implement the listed features under Phase 6.
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!
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.
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.
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.
There are hundreds of frameworks! But by implementing the same API, they can be mixed and matched to build a tech "stack".
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.
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.
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.
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.
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.
Built by a Former Google Engineer Clement Mihailescu, it contains a course, questions, and explanations, all rolled into one. It is pricy though...
Consider these books for deeper learning and insights.
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!
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.
We also have our bloggers and internet-famous content creators, I often enjoy hearing different takes and opinions on things.
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.
Everything is built and deployed in containers these days, testing, building, running your code. It's the new VM!
DevOps is when development and automation practices are applied to delivering and operating software.
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.
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.
This is a great explanation on how large companies deploy software. It explains what "environments" are very well, and really breaks it down.
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.
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.
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.
AI is extremely valuable as an _experienced_ software engineer. Take the hand example, linked. See my opinions below.
I started in system administration, then DevOps, then cloud engineering, and finally, software engineering. Here's my take on tools.
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.
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!
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.
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.
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.
Love them or hate them, coding interviews are part of the process so you need to be prepared.
Here are my tips on finding the jobs you actually want.
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.