When you learn to code, there is a moment when everything begins to change. At Firehose, we like to call this the inflection point of coding. After this phase, the way you operate as a developer will be dramatically different. Building up to the inflection point is the process of becoming self-sufficient in programming, to the point where you no longer need any hand-holding. It can be a frustrating experience, but once it’s behind you, it is incredibly empowering.
当你学习编码时，那是所有事情开始改变的时刻。在Firehose（培训机构）,我们更愿意称这个为编程的拐点。在这个阶段之后，你作为一个开发者的操作之路将会显著的不同。建立这个拐点是在编程中自给自足的一个过程。到达这个位置的点，你不再需要任何的手把手的帮助。这可能是一种令人沮丧的经历。但是你一旦达到这个拐点，将会获得令人难以置信的强劲的力量。
At Firehose, our goal isn’t just to teach you Ruby, how to build web applications, or how to write tests. Although we do teach these skills and more, our primary goal is to accelerate students past the inflection point so they gain the ability to solve any problem they encounter. We believe that being able to problem solve on your own is an invaluable skill, and this method of teaching will take you much further than simply learning how to build a set of apps.
The Tutorial Phase (3-8 weeks of serious coding) 教程阶段(3到8周高强度编程训练)
When you start out learning to code, there’s a lot of information that you don’t know yet. This information is called domain-specific knowledge. Examples include: knowing how to write a loop in ruby or how to extract something from a database using Ruby on Rails. Domain-specific knowledge encompasses the protocols unique to a certain programming environment.
The first step to becoming a self-sufficient developer is learning how to do specific tasks. Once you master certain tasks, the broad strokes of how the pieces fit together will start to become apparent. Over time, you’ll begin to recognize patterns and eventually, the things that initially seemed confusing and foreign will become second nature.
For students starting out, the most important skill to acquire is attention to detail.对于初学者来说，最重要的技能是注重细节
Paying close attention to detail is important when going through materials like documentation or tutorials. Even the most minor typos and misspellings will result in error messages or bugs. Seeing error messages is a frustrating experience at first, but it’s a crucial step in the learning process. Dealing with error messages and problems in this phase teaches you one of the most important skills of programming within a safe environment: being detail-oriented.
在阅读文档或教程等材料时，密切关注细节非常重要。 即使是最小的拼写错误也会导致程序报错。 一开始看错误消息是令人沮丧的经历，但这是学习过程中的关键步骤。 处理此阶段中的错误消息和问题可以教给您在安全环境中编程的最重要技能之一：面向细节。
Debugging error messages is incredibly important. The fact of the matter is, error messages are just a part of programming: they are seen by inexperienced and very experienced developers alike. The only difference is, the more experience you have dealing with error messages, the less time you’ll need to spend trying to fix them. Here’s why:
调试错误消息非常重要。 事实上，错误消息就是编程的一部分：缺乏经验和非常有经验的开发人员都可以看到它们。 唯一的区别是，处理错误消息的经验越多，花在尝试修复错误消息上的时间就越少。 原因如下：
- Over time, you will learn how to read error messages and extract the relevant details of the problem quickly. The first time you see an error message, it will take you a while to decode what it actually means. But after you’ve seen hundreds of error messages (and you will see hundreds!), you will be able to pinpoint the problem’s location and the relevant details you need in order to fix it.
- You should learn from each error message that you resolve. Don’t just fix the error and be done with it; understand what is wrong with the code you’re fixing. By learning from each of your errors, the next time you make the same mistake, you’ll be able to fix it much faster.
- Initially, you will probably ask for help on each error message you see. Over time, you’ll learn to ask for help less frequently by double-checking your code and conducting smart Google searches.
- 随着时间的推移，您将学习如何阅读错误消息并快速提取问题的相关详细信息。 第一次看到错误消息时，需要一段时间来解码它实际意味着什么。 但是，在您看到数百个错误消息（您将看到数百个！）之后，您将能够查明问题的位置以及解决问题所需的相关详细信息。
- 您应该从您解决的每条错误消息中学习。 不要只是修复错误并完成它; 了解你正在修复的代码有什么问题。 通过了解每个错误，下次出现同样的错误时，您将能够更快地修复错误。
- 最初，您可能会在看到的每条错误消息上寻求帮助。 随着时间的推移，您将学习通过仔细检查代码和进行Google搜索来减少求助频率。
In the tutorial phase, you will follow instruction. At first, you’ll find it challenging to follow instructions and error messages will happen frequently. Over time, you’ll develop the skill to debug errors and pay better attention to small details, and you’ll be able to make progress much quicker. As you’re wrapping up the tutorial phase, you’ll notice you’re able to write code at a much more rapid pace.
在教程阶段，您将遵循指示。 首先，您会发现遵循指示很有挑战性，并且会经常出现错误消息。 随着时间的推移，您将学习发展调试错误的技能并更好地关注小细节，并且您将能够更快地取得进展。 当你完成教程阶段时，你会发现你能够以更快的速度编写代码。
At this point, some people feel confident– like they’re ready to ditch the training wheels and start building things without structured guidance– and will happily dive into the deep end. Other students will reach for more tutorials, trying to obtain more domain-specific knowledge in search of a “full understanding.” Unfortunately, tutorials will only take you so far, and true confidence isn’t found in tutorials or guides. True confidence comes from struggling through a problem you have no idea how to solve, and discovering a solution on your own.
在这一点上，有些人感到自信 - 就像他们已经准备好放弃训练轮并在没有结构化指导的情况下开始建造东西 - 并且乐意潜入深渊。 其他学生将获得更多教程，试图获得更多领域特定的知识，以寻求“完全理解”。不幸的是，教程只会带你走到目前这么远，真正的信心在教程或指南中是找不到的。 真正的信心来自于解决您不知道如何解决的问题，以及自己发现解决方案。
The dirty little secret of programming is… 编程的肮脏小秘密是......
You will never know everything you need to know to solve all your problems. Going into the journey, you probably envisioned yourself eventually learning everything you need to learn, and then being squared away. This moment will never happen.
Programming is a life-long learning experience. Experienced software engineers seek to find solutions to problems they haven’t solved yet because it gives them the opportunity to learn more. If you find yourself waiting for the moment when you finally feel like you know everything there is to know about coding, know this: the day you’re waiting for will never come. And that is a wonderful thing.
编程是一种终身学习体验。 经验丰富的软件工程师寻求找到尚未解决的问题的解决方案，因为这为他们提供了学习更多知识的机会。 如果你发现自己等待那一刻，你终于觉得你知道关于编码的一切的那一刻，你应该知道：你等待的那一刻永远不会到来。 这是一件很棒的事情。
图：the master has failed more times than the beginner has even tried
You will be ready to jump into the next phase of your journey when: 在以下情况下，您将准备好进入下一阶段的旅程：
- You’ve seen enough error messages that they no longer startle you. Instead, you know how to decipher what they mean and where to look for the problems in your code.
- You’re a pro at Googling for solutions. When you’re working to add a feature or see a confusing error message, you know what to search for to find the information you need.
- You’re able to reference code you’ve written in other parts of your application and follow patterns within them, rather than always seeking out step-by-step instructions.
- 您已经看到了足够的错误消息，这些错误不会再惊吓到你。 相反，您知道如何解码它们的含义以及在你的代码中找到问题。
- 你擅长谷歌找到解决方案。当你准备添加功能或者看到一个扑朔迷离的错误，你知道搜索什么来找到你需要的信息。
- 您可以引用您在应用程序的其他部分编写的代码并遵循其中的模式，而不是总是寻求逐步说明，来一步一步从头编写。
The Inflection Point (2-4 weeks with the right mentality) 拐点(2-4周正确的心态)
The inflection point stage is one of the most frustrating stages of learning to code, but in many ways, it’s the only stage that matters. It’s the point when you phase out of using tutorials and begin solving problems for which no one has lined up a solution for you.
拐点阶段是学习编码最令人沮丧的阶段之一，但在许多方面，它是唯一重要的阶段。 这个点是，当您逐步停止使用教程并开始解决没有人为您提供解决方案的问题时。
At some points, you will feel like you aren’t ready to tackle this phase and like you want to return to building something with an outline of exactly what to do. Don’t fall prey to this mentality. The reason you’ll feel frustrated is:
在某些时候，你会觉得你还没有准备好应对这个阶段，并且你想要回到构建具有确切要做的概要的东西。 不要成为这种心态的牺牲品。 你会感到沮丧的原因是：
During the inflection phase, you will be coding 10-20 times SLOWER than in the previous phase. 在拐点阶段，您的编码速度会比上一阶段编码速度低10-20倍。
You may start questioning yourself and wondering if you are actually capable of becoming a programmer. Feelings of insecurity and doubt are common in this stage.
您可能会开始质疑自己并想知道您是否真的有能力成为程序员。 在这个阶段，不安全和怀疑的感觉很常见。
Despite the fact that you’ll feel like you’re learning and accomplishing things at a much slower rate, in reality, you are achieving the things that matter the most. While your domain-specific knowledge is screeching to a putter, everything you’re learning will be about procedural knowledge.
尽管事实上你会觉得你正在慢慢地学习和完成事情，但事实上，你正在实现最重要的事情。 虽然您的特定领域知识的学习非常缓慢，但您所学的一切都将与程序知识有关。
Procedural knowledge is the ability to teach yourself what you don’t know along the way. When you need to implement a new feature, what type of Google search should you do? At this point in time, you’ll feel like you’re “in the dark” when it comes to many of the things you want to accomplish. Learning how to find the light on your own is critical because you can never know everything there is to know, so you need to be able to teach yourself how to solve the problem at hand.
Most people do not realize that in order to learn to code, you need to learn both domain-specific and procedural knowledge.
大多数人都没有意识到，为了学习编码，你需要学习特定领域和程序(过程性)知识。
For the rest of your life, go outside your limits every single day
在你的余生中，每一天都超出你的极限
Some software engineers stay inside their comfort zone once they find their footing. These types of programmers are known as maintenance programmers– not something you should strive to be. Instead, you should strive to go outside your limits every single day. The most common reason programmers quit their jobs is because “it’s not challenging anymore since I’ve solved all the interesting problems.”
一些软件工程师一旦找到自己的立足点就会留在舒适区内。 这些类型的程序员被称为维护程序员 - 你不应该成为这样的程序员。 相反，你应该努力每天超出你的极限。 程序员辞职的最常见原因是“因为我解决了所有有趣的问题，所以不再具有挑战性。”
Rather than trying to pull coding projects into your comfort zone, you should be seeking out problems that are outside your current skill set. This is the only way to build on and expand your skills.
您应该寻找超出当前技能的问题，而不是试图将编码项目拉入您的舒适区。 这是建立和扩展您的技能的唯一方法。
In the words of a Firehose student upon passing his inflection point:
用Firehose学生通过他的拐点时的话：
I still feel like I’m in the deep end! I’m just getting more comfortable knowing that’s where I’ve got to be!
我依然感觉我身处黑暗，我感觉到很舒服因为我知道我要去哪里！
In web development, there are actually two inflection points that will come together.
在Web开发中，实际上有两个拐点将会一起到来。
The web development inflection point is the point when you become capable of building any database-driven application that you want. This means being able to build a web application with many pages that stores and retrieves information from a simple database. Web developers call this: “mastering CRUD.” At this phase, you should also be able to integrate with any 3rd party library (a ruby gem for example) simply by following the documentation provided on GitHub or a blog post.
Web开发拐点是您能够构建所需的任何数据库驱动的应用程序的关键点。 这意味着能够构建具有许多页面的Web应用程序，这些页面存储和检索来自简单数据库的信息。 Web开发人员称之为“掌握CRUD。”在此阶段，您还应该能够通过遵循GitHub或博客文章中提供的文档与任何第三方库（例如ruby gem）集成。
The algorithm and data structures inflection point is a less superficial inflection point, but it is actually more important. Someone who has conquered this point will have mastered the programming language they’re working in, in addition to mastering the fundamentals of programming and having a depth of knowledge for solving complex coding challenges.
算法和数据结构拐点是一个不那么肤浅(有难度和深度)的拐点，但实际上更重要。 除了掌握编程的基础知识和掌握解决复杂编码挑战的知识深度之外，已经掌握了这一点的人将掌握他们正在使用的编程语言。
People who have conquered the algorithm and data structures inflection point will be able to:
征服了算法和数据结构拐点的人将能够：
- Write sorting algorithms
- Implement and reverse linked lists
- Understand and write programs leveraging stacks, queues, and trees
- Write computer programs using recursive or iterative solutions
- 写排序算法
- 实施和反转链表
- 理解和编写利用堆栈，队列和树的程序
- 使用递归或迭代解决方案编写计算机程序
In short, once you pass this inflection point, you will have mastered data manipulation and will understand the performance implications of your code decisions. Traditional computer science degrees focus exclusively on getting students past the algorithm and data structures inflection point. Many universities teach this with programming languages that are generally not used in the industry, like Scheme, Racket, or LISP.
简而言之，一旦通过此拐点，将掌握数据操作并将了解代码实现对性能影响。传统的计算机科学学位专注于让学生超越算法和数据结构的拐点。许多大学都使用工业化生产中不使用的编程语言来教授这一点，例如Scheme，Racket或LISP。
In most technical interviews, the interviewer will assume you’ve passed the web development inflection point, given that’s easier to do, and focus their questions on evaluating your skill in algorithms and data structures. These questions will generally focus on the topics we mentioned above: sorting algorithms, reversing linked lists, and using stacks, queues, and trees.
在大多数面试中，面试官会假设您已经通过了Web开发的拐点，因为web开发拐点比较容易，并且将他们的问题集中在评估您的算法和数据结构技能上。 这些问题通常集中在我们上面提到的主题：排序算法，反转链表，以及使用堆栈，队列和树。
Once a developer has passed both the web development inflection point and the algorithm and data structures inflection point, they hold the keys to the kingdom.
一旦开发人员通过了Web开发拐点和算法以及数据结构拐点，他们就掌握了通向王国王位的钥匙。
These developers will be able to solve challenges that intersect the two: complex algorithms that need to be built in the context of advanced web applications. This is at the heart of what professional web developers do every single day.
这些开发人员将有能力解决交叉挑战：在高级Web应用程序环境中构建复杂算法。 这是专业Web开发人员每天都在做的核心。
Consequences of the Inflection Point 拐点之后的结果
The biggest consequence of the inflection point will sound a bit counterintuitive when you first hear it. Take a deep breath in:
当你第一次听到拐点的最大的结果时，听起来有点违反直觉。深吸一口气：
When learning to code, domain-specific knowledge doesn’t matter in the grand scheme of things.
在学习编码时，特定领域的知识在宏观方案中并不重要。
Yup. I’m not joking– it really doesn’t matter that much at all. Once you pass the inflection point, these concepts will fluidly translate with just a week or two of tutorials, maybe even days!
对。 我不是在开玩笑 - 这根本不重要。 一旦你通过拐点，这些特定领域的知识将只用一到两周，甚至几天即可流畅学习使用！
What ultimately really matters is:
- You have a solid grasp on a web development framework
- You have a solid grasp on writing algorithmically complex code in any programming language
- 您对Web开发框架有扎实的把握
- 您可以很好地掌握在任何编程语言中编写算法复杂的代码
Hiring managers want developers with solid web development and algorithm skills.
招聘经理希望开发人员具备扎实的Web开发和算法技能。
While I was working at PayPal, my team hired a Senior Rails Developer who had no experience in Rails– he had been coding a lot in Python, LISP, and Perl. Within a couple of days, he was already making a big impact. And within weeks: a huge impact. He quickly rose to become the technical team lead and was one of the best hiring decisions I’ve ever been involved in.
当我在PayPal工作时，我的团队聘请了一位没有Rails经验的高级开发人员 - 他不得不经常使用Python，LISP和Perl编写代码。 在几天之内，他已经发挥了巨大的作用。 并在几周内：巨大的影响。 他很快就成为了技术团队的领导者，这是我参与过的最好的招聘决策之一。
Don’t sweat the stack. Many people will say things like, “AngularJS is hot these days,” “JavaScript is on the rise,” or “the latest fad is…” My response to that is: “so?” When you’re learning how to program, your singular goal should be to find the inflection point and annihilate it. Once you do, learning that new, sexy fad won’t be a difficult task at all.
不要不安(心里没安全感)。 许多人会说“AngularJS这些天很热门”，“JavaScript正在崛起”或“最新流行的......”我的回答是：“是这样么？”当你学习如何编程时， 你的唯一的目标应该是找到拐点并消灭它。 一旦你做到了，学习这种新的，时髦的技术根本不是一项艰巨的任务，会非常简单。
Become self-reliant. Having the ability to learn new coding skills without structured guidance means you no longer need to wait for anyone to help you out. This means that for the majority of what you need to learn, you can simply search the internet and read the various material on what you need to know.
变得自力更生。 能够在没有结构化指导的情况下学习新的编码技能意味着您不再需要等待任何人帮助您。 这意味着，对于您需要学习的大部分内容，您只需搜索互联网并阅读有关您需要了解的内容的各种材料。
This doesn’t mean you immediately “know” everything, but just that everything is now “figure-out-able,” so in essence, you are unstoppable.
这并不意味着你立即“知道”所有事情，但只是现在所有事情都“可以解决”，所以从本质上说，你是不可阻挡的。
The Skills You Will Develop During the Inflection Point
在拐点期间你的技能将会发展。
As a software developer, the best reference material is similar code that you have already written. When you fully understand the code you’ve written, you don’t need to commit all the details to memory. This means that the first question you should ask yourself when building a new feature is: “Have I built something similar before?” If the answer is yes, revisit the code and walk through the code line-by-line in your head. Re-explain to yourself what it’s doing and ask yourself, “could I use the same approach now?”
作为软件开发人员，最好的参考资料是您已编写的类似代码。 当您完全理解您编写的代码时，您不需要将所有细节记忆到大脑中。 这意味着在构建新功能时您应该问自己的第一个问题是：“我之前是否构建了类似的内容？”如果答案是肯定的，请重新访问代码并逐行浏览代码。 重新向自己解释它正在做什么并问自己，“我现在可以复用这段代码么？”
Videos suck at explaining domain-specific details because they take so darned long to watch. Say you want to integrate with the Google Maps API. Once you’ve experienced doing so once, it can take less than a minute to open the code up in GitHub, copy the code, and paste it into a new project. Videos, on the other hand, can often take 10-30 minutes to re-watch.
视频很难解释特定领域的详细信息，因为 观看它们需要花费很长时间。 假设您要与Google Maps API集成。 一旦您经历过这样的操作，在GitHub中打开代码可能需要不到一分钟的时间，复制代码并将其粘贴到新项目中。 另一方面，视频通常需要10-30分钟才能观看完毕。
Strategies for Passing the Inflection Point as Efficiently as Possible 使用策略尽可能有效的到达拐点。
Because passing the inflection point is the most important part of learning to code, you should set yourself up to make the process as smooth as possible. This means you should start preparing while you’re in the tutorial phase and maintain the right mindset during this period of time.
因为通过拐点是学习代码最重要的部分, 所以你应该设置调整自己, 使过程尽可能顺利。这意味着你应该在进入教程阶段之前开始准备, 并在这段时间里保持正确的心态。
During the tutorial phase, take breaks from going over structured material and give yourself challenge problems along the way.
在教程阶段，从浏览结构化材料中获得一些休息，并在此过程中给自己带来挑战问题。
- For every handful of lessons, try to do something that is outside the scope of the tutorial you’re following. If the tutorials you’re going through provide “challenges” or “self-directed” pieces, do all of them. Solving unguided challenges will give you the important experience of doing things without structured guidance.
- Try to use tutorials as little as possible. At Firehose, we often walk students through how to integrate certain gems or do things using the provided documentation. Rather than simply following the instructions explained in tutorials that are geared towards people who are just starting out, many students will follow the documentation and use the tutorials as a back-up.Note that documentation will treat you like a developer who has passed the inflection point. Getting comfortable reading and following documentation on GitHub will give you a leg up when you’re on your own.
- Focus on the essentials and use repetition. Learn how to do common things like spinning-up an application from scratch, pushing a new app to GitHub and Heroku, and building a database migration early on.
- 对于每几节课, 尝试做一些超出你所关注的教程范围的事情。如果您正在进行的教程提供了 "挑战" 或 "自我导向" 的部分, 请执行所有这些部分。解决无引导的挑战将为您提供在没有结构化指导的情况下做事的重要经验。
- 尽量少使用教程。在Firehose，我们经常指导学生如何集成某些gem或使用提供的文档进行操作。与其简单地按照针对刚开始学习的人的教程中解释的说明进行操作，许多学生将按照文档进行操作，并将教程用作备份。请注意，文档将把您视为已经过了拐点的开发人员。在Github上轻松阅读和跟踪文档会让您在自己的工作中获得帮助。
- 注意要点，重复使用。学习如何做一些常见的事情，比如从头开始编写应用程序，将新的应用程序推送到Github和Heroku，以及尽早构建数据库迁移。
Pushing through the inflection point can be challenging. Here are some pointers to get you through it:
接近通过拐点是很有挑战性的。这里有一些建议帮助您通过拐点。
- Understand that this is a difficult process and go easy on yourself. Also, set realistic expectations. You can’t compare your “superman”-level speed of going through tutorials to your “snail”-speed of learning things on your own. Keep in mind that you’re learning plenty, but at this phase, you’re learning a brand new skill of figuring new things out on your own.
- If you’re struggling with self-confidence, know that what you’re feeling is completely normal. Keep working. If you continue to struggle, try talking to someone who has recently passed the inflection point. They will be able to relate to the position you’re in and will assure you that what you’re experiencing is only temporary.Work consistently, but don’t overwork yourself. At this phase of the game, know that you can only be productive for around 6 hours a day at the most. Working in an exhausted state will only prolong the time you spend building up to the inflection point.
- 了解这是一个艰难的过程，对自己说这很容易。 此外，设定比较现实的期望。 你无法将你的“超人”级别的通过教程速度与你自己学习的“蜗牛”速度进行比较。 请记住，你正在学习很多，但在这个阶段，你正在学习一种全新的技巧，可以自己解决新事物。
- 如果你在自信心中挣扎，要知道你的感受是完全正常的。 继续工作。 如果你继续挣扎，试着和最近通过拐点的人交谈。 他们曾和你在同样的位置有同样的感受，并向您保证您所遇到的只是暂时的。 一直工作，但不要过度劳累。 在游戏的这个阶段，要知道你每天最多只能工作6小时左右。 在疲惫不堪的状态下工作只会延长你到达拐点的时间。
The best way to gain confidence at this stage is to power through any doubts you have. Your emotions may start to feel like a roller coaster. At times, you’ll feel like you’re on fire, but after 15 hours of struggling on the same problem, it’s very common to feel the polar opposite.
在这个阶段获得信心的最好方法是有力的解决自己的疑惑。 你的情绪可能开始像过山车一样。 有时候，你会觉得自己很着火(着急生气)，但经过15个小时的努力解决同样的问题后，感觉到两极相反是很常见的(问题解决后感觉整个人都好了起来)。
It can be frustrating to have no idea if something will take you 5 minutes or 5 hours, but every time you power through and successfully implement a new feature, the rush of confidence will be everything you need. After solving a handful of hard problems without any help, you’ll be addicted to the feeling of building things outside your comfort zone.
5分钟或5个小时对于一个问题还没有任何头绪，那将是令人沮丧的，但每当你有力的通过并成功实现新功能时，信心的涌现将会成为你所需要的一切。 在没有任何帮助的情况下解决了一些难题之后，你会沉迷于在舒适区之外建造东西的感觉。
How to know when you’ve passed the inflection point
如何知道你何时通过了拐点
The final stage of the inflection point process is acceptance. Acceptance that software development is a process of continuous learning. Acceptance that the feeling that you’ve successfully learned everything just means you should start thinking about solving more complicated problems.
拐点过程的最后阶段是承认。 承认软件开发是一个不断学习的过程。 承认，你成功地学习一切，只是意味着你应该开始考虑解决更复杂的问题。
Have you experienced the inflection point yet? Share this post and start a conversation with your friends– you would be surprised how many people have reached and surpassed this moment.
你已经越过拐点了吗？ 分享这篇文章并与你的朋友开始对话 - 你会惊讶于有多少人达到并超越了这个时刻。
扫一扫
1389
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
