Students often tell us that two of the most confusing aspects of learning software development are 1) too many tools, frameworks, workflows and technologies to learn, and 2) too much change around those technologies. There is also uncertainty around what language one should learn first, and whether the hot language of today will be relevant 5 or 10 years down the road.

Students often ask: "What should I learn?", "To what depth or proficiency?", "In what sequence?", "How long will it take?" and "When should I stop learning?".

While the exact answers to those questions will depend on each individual, our hope is that understanding our learning goals will help you form answers to those questions on your own.

The world of software development is awash in tools, libraries, and frameworks. One reason for this diversity of options is because it's so easy to publish one's own solution. Beginners are drawn in by the power of the framework or library, without understanding the fundamental problems or approach.

In order to really understand any tool -- Rails, Angular, React, etc -- you have to start with the first principles. First, you have to learn basic problem solving with a programming language. Next, you have to learn the intricacies of that language. Then, you have to learn web development, which includes HTTP, front-end vs back-end, SQL, relational databases, etc. Finally, you can start to peel back the conventions in a library or framework. Then, you start over from step one (because developing a skill isn't sequential -- we'll talk about that later).

Despite our program's depth and coverage, our core philosophy is around strengthening fundamentals and building proficiency in "things that don't change". While it may look like the world of web development churns at an incredible pace, the core building blocks of the web were created in the mid-1990s. Python, Ruby, JavaScript, CSS, and SQL were all created decades ago, and their core remains nearly unchanged to this day. What has changed, though, are layers of abstractions and tools built on top of those technologies. Don't focus on that. Focus on things that don't change, focus on the fundamentals.

That's one of the core principles of our program, and our goal is to teach you skills that will carry you for the next 20 to 30 years of your career.

In our program, we'll expose you to a lot of knowledge. It's sometimes overwhelming to try to figure out what one should absolutely know as a developer, versus what one should be aware of. This points to two different types of learning goals. We'll call it proficiency vs awareness.

Awareness is adding another bullet point to the general knowledge database in your brain. You can build awareness by watching a video on a topic and then filing that knowledge away.

Proficiency is becoming a skilled practitioner of that topic. You are expected to perform the rituals of that topic extemporaneously and can educate others on that topic. You can only reach proficiency with hundreds or thousands of hours of repetition and practice.

Most students just look at a list of topics when considering different programs, without looking deeper at whether they're learning it to be proficient or just building awareness.

At the core, ours is a skills development program focused on fundamentals. This means we are practicing towards proficiency in fundamental areas and building awareness on higher level topics. This is a very different approach from other training programs that focus only on awareness building across all knowledge layers, without mind to actual skills development. We will ask you to practice over and over and over, and give you hundreds of hours of exercises. It is designed to be repetitive and challenging at the same time.

Once you reach proficiency on the basics, it becomes much easier to understand higher level tools and frameworks. Another reason it becomes easier is that you can appreciate the problems that the framework is addressing. If you skip that understanding and learn the framework first, you'll only be learning solutions. Put another way, a framework is the framework author's perspective on a possible solution to the problem. In larger frameworks, it's likely that the framework addresses many problems in one package; it's effectively a bundle of solutions.

Learning someone else's solution in the beginning is problematic. There are two reasons for this: solutions are opinions and the best solutions abstract away the problem. First, as a studious learner, it's more important that you are exposed to the problem fully, including all of its edge cases. This is the only way to truly understand the problem you're dealing with, but this is also the opposite goal of a framework. The framework hides the problem, so the developer can be more productive. Optimizing on productivity is not the goal for a beginner. Second, the solution is one person's take on the problem at hand and is not the only way to solve this problem. In the beginning, it's important to not fall into a certain mindset, because it blinds you to other solutions. Every solution has tradeoffs, and likely works well with one set of constraints but doesn't work well with another set of constraints. Understand those tradeoffs.

The world of software development appears to have a lot of churn and change, but the core problems remain nearly the same -- the core technologies are largely unchanged for decades. But developers are constantly experimenting and coming up with new solutions, each with their own tradeoffs. Don't start your programming journey by learning someone's solutions.

The best way to truly understand a problem well is experiencing it first hand. Unfortunately, this implies some level of pain. The more acutely you experience the pain, the more likely you'll remember the problem. If it's a true pain, you'll also likely have burned many hours into trying to figure out a solution. It's through the process of turning the problem around in your head over and over that you start to develop an understanding of the nuances of the problem. And it's only through this process that you can start to appreciate the tradeoffs involved in others' solutions.

Our program will help you experience that pain in a structured way, and guide you along the path of exploring and understanding core problems in software development. When it's time to learn a new solution (i.e., tool, library or framework), you'll have clarity on the tradeoffs and be able to form your own opinion, which will be informed through your own first-hand experience struggling with the same problems.

Because our program is focused on exposing you to problems, we won't lead by teaching frameworks or tools. Even when we do use a library, the core concept is still about understanding the problem at hand. Once you understand the problem well, understanding the solution comes naturally. In other words, once you learn fundamentals, picking up new frameworks is no problem.

If we want to focus on fundamentals, then it's natural to teach a programming language first, without tools or frameworks. We want to sequentially build up enough knowledge to move forward from first principles.

The problem with a 100% sequential approach is that it's not possible to "learn a programming language" in a well-defined amount of time. Like learning any skill (eg. playing the piano, playing golf, cooking, etc), the road to mastering programming is endless.

There's a balance between knowing enough to move forward and staying in one place for too long. Our program guides you through that tradeoff, with the understanding that you will revisit the basics throughout our program in a circular fashion. Through this circular manner of learning, you'll be exposed to the same fundamental concepts over time and in different problem domains.

Our focus on fundamentals, building to proficiency, understanding problems and circular learning have a cost: time and effort. Many beginners are looking for a trick or edge or the fastest way of reaching professional level skills. Or, some people are looking for the quickest way to ramp up in order to build an idea. Our program is not designed for any of that.

Our program is built for people who are able to work consistently for an indefinitely long period of time, often seemingly without much progress to show for it.

This is the path to mastery -- this is the Slow Path.

If you've read this far, you might be a good fit for our program. We'll list out the attributes of our best students, and you can make a decision on whether this is for you. You will likely enjoy our program if:

• you are a Studious Learner, looking to transition to a long career in software development.
• you are willing to spend as long as it takes working through the program, which at times will be a slog.
• you are willing to work hard and persevere even if you get stuck. Don't just give up, but avail yourself of the resources provided by Launch School: the Open Bookshelf, our courses, the forums and discussion areas, and Slack. You don't need someone to hold your hand and can get unstuck if nudged in the right direction.
• you are not shy about asking for help or even helping others. You can collaborate in an online environment and be proactive in communication.
• you enjoy problem-solving, troubleshooting, and debugging.
• you want to learn the fundamental problems in software development, and not a framework or library.
• you want to learn "things that don't change".
• you are not easily distracted by React, Angular, Django and other "shiny things". Focus on the fundamentals; they will serve you better in the long run than a framework that will go out of favor in a few years.
• you are not in a rush, believe in the Slow Path, and have set aside 12-24 months with the goal of working towards a long career in software development.

If this list describes you well, we have crafted all aspects of our program to fit your learning goals, and at a price point that is sustainable. As instructors, we're excited to work with you to get you started on a long and rewarding career.

If you aren't sure whether Launch School is for you, we have several free resources you can access. They will give you a good feel for what Launch School has to offer, how we approach learning, and let you see if our approach works for you:

• Our Programming Essentials Workshops
• Our Open Bookshelf
• Our Smooth Start program
• Our Preparatory course (requires free registration.