英文原文：The Key To Accelerating Your Coding Skills
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，我们喜欢将它称之为“Coding转折点”。迈过这个阶段之后你作为开发人员的成长之路将出现巨大的不同。循序渐进地修炼到转折点的过程，就是逐步建立“编程自信”，能够独立解决编程问题而再也不需要他人帮助的过程。经历这个过程可能会令人非常的沮丧和郁闷，但一旦修炼成功，编程功力将变得让人难以置信的强大！
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.
在Firehose，虽然我们也教授更多的包括Ruby、Web应用开发或者如何写测试用例这些知识，但我们的目标并不仅限于此。我们的首要目标是让学生们加速跨越Coding转折点，让他们掌握解决他们遇到的任何问题的能力。我们相信能够独立解决问题的技能是无价之宝，而且这样的教学方法能够比简单教你怎么写几个App带你走的更远。
The Tutorial Phase (3-8 weeks of serious coding)
教学辅导阶段（3-8周严肃的Coding训练）
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.
在你开始学习如何写代码的时候，有大量的信息是你还不知道的。这些信息被称为“领域特定知识”。比如知道如何写一个ruby语言的循环或者使用RoR框架从数据库中抽取一些数据。领域特定知识涵盖了特定于某个编程环境的相关规则。
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.
在浏览教程或者文档时，密切地关注细节尤为重要。即便是最微小的文字错误或者拼写错误都将导致报错或者bug的出现。刚开始时看到报错是一件让人郁闷的事情，但它是学习过程中至关重要的步骤。在这个阶段中，处理报错和问题教会你的是在安全环境中编程最重要的技能之一：一定要细心。
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.
一开始，你会在遇到每个报错信息时向别人求助。一段时间过后，你会学着反复检查你的代码并通过聪明地使用谷歌搜索解决报错，减少开口向别人求助的频率。
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.
编程是一种终身学习的经验。经验老到的软件工程师寻求解决那些他们还未解决的问题，因为这会给他们学习更多知识的机会。如果你发现自己总是一厢情愿地等待那个你感觉自己终于洞悉了关于编程一切知识的时刻，那么你需要知道：你等待的这一天永远不会到来。这真是一件奇妙的事。
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.
你已经是一个通过Google就能找到解决方案的小能手了。当你正在工作为程序增加新特性或遇到一个让人困惑的报错消息时，你知道要搜索什么才能找到你所需要的信息的时候。
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)
Coding转折点（在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倍的速度Coding
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:
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!
用一位通过了编程转折点的Firehose学生的话来说：
我虽仍然感觉到自己处于深渊之中！但我知道那是我的必经之路！我更加应付自如了！
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应用。Web开发者称其为“掌握了增删改查技能”。在这个阶段，你应该也能够根据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开发的转折点，他们会将面试提问的焦点放在评估你的算法和数据结构技能 上。这些面试问题会聚焦在上面我们提到的那些主题上：排序算法、反转链表和如何使用栈、队列和树。
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
Coding转折点的重要性
The biggest consequence of the inflection point will sound a bit counterintuitive when you first hear it. Take a deep breath in:
Coding转折点最重要的地方咋一听会有点反直觉。深呼吸，让我们来看看是啥：
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
你对Web开发框架有了扎实的掌握
You have a solid grasp on writing algorithmically complex code in any programming language
你对如何编写复杂算法的代码有了扎实的理解，无论使用什么样的编程语言
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开发经验的高级Rails开发——他对使用Python、LISP和Perl有着丰富的经验。他几天内就做出了很大贡献；几周内就做出了巨大贡献。他很快就被擢升为团队技术Leader，这也是我做出的最棒的招聘决定之一。
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.
用视频课程来诠释领域特定的细节真是糟透了，因为需要耗费大量的时间来观看这些视频。例如，你想集成谷歌地图API。如果你曾经做过，那么打开Github，复制相关代码再粘贴到新项目中花不了你一分钟时间。另一方面，如果重新看视频的话，得花10到30分钟不等的时间。
Strategies for Passing the Inflection Point as Efficiently as Possible
尽可能高效地跨越Coding转折点的策略
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.
尽可能少地依靠辅导材料。在Firehose，我们经常让学生通过阅读技术文档集成某些库或者做开发。不是让学生跟着与刚起步的初学者相配套的教程中给出的指示一步一步来，而是让学生跟着技术文档来做，教程只作为备用。既然技术文档会假定读者是已经跨越了转折点的开发人员，那么能够轻松愉快地阅读Github上的开发文档将在你独自解决问题时助你一臂之力。
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.
关注基本要素并重用它们。学习如何完成一些常见的工作，比如从零开始启动一个应用，将新应用推送到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.
如果你正在与自己的不自信作斗争，你要明白你现在所感受到的其实很正常。继续PK。如果你还是挣扎于不自信的泥潭，请试着与最近刚成功突破转折点的朋友交谈。他们会理解你现在的处境并向你保证你所经历的只是暂时的。持续地工作，但不要劳累过度。进入到了游戏的这个阶段，要知道你一天最多只能保持6个小时左右富有成效的工作时间。精疲力尽的工作状态只会延长你修炼Coding转折点所需要的时间。
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.
Coding转折点的最后一个阶段是一种观念认同。认同这样一种观念，即软件开发是一个持续学习的过程。认同这样一种观念，即如果自觉已成功学会了一切，那么这只不过意味着该思考如何解决一些更复杂的问题的开始。
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.
到目前为止你经历过Coding转折点了吗？分享这篇博客然后和你的朋友们聊聊吧——你会惊讶的发现有多少人达到并超越过这一刻。
