The Key To Accelerating Your Coding Skills

link

如何有效地快速提高自己编程能力的关键点

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.

在Firehose，我们的目标不仅仅是教你Ruby，如何构建Web应用程序，或者如何编写测试。虽然我们确实教授了这些技能和更多的技能，但我们的主要目标是加速学生通过拐点，使他们获得解决任何问题的能力。我们相信，能够使自己解决问题是一种无价的技能，这种教学方法将使你比简单地学习如何构建一套应用程序更进一步。

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.

当你开始学习代码的时候，有很多信息你还不知道。这些信息被称为特定领域知识。例如：知道如何用ruby/java写一个循环，或者如何使用Ruby on Rails从数据库中提取一些东西。特定领域知识包含了某个编程环境所特有的协议。

成为一个自给自足的开发人员的第一步是学习如何做特定的任务。一旦你掌握了某些任务，各部分如何结合在一起的大体思路将开始变得明显。随着时间的推移，你将开始认识到模式，最终，这些刚开始看起来混乱和陌生的东西将成为第二天性。

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:

调试错误信息是（Debug）非常重要的。事实上，错误消息只是编程的一部分：没有经验和非常有经验的开发人员都会看到它们。唯一的区别是，你处理错误消息的经验越多，你需要花在修复错误消息上的时间就越少。这就是为什么：

• 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.
• 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.

当你准备好进入你旅程的下一个阶段时 :

• 你已经看到了足够多的错误信息，它们不再让你感到震惊。相反，您知道如何解读它们的含义，以及在哪里寻找代码中的问题。
• 你是谷歌搜索解决方案的专家（或者是stackoverfolw）。当你正在添加一个功能或看到一个令人困惑的错误信息时，你知道该搜索什么来找到你需要的信息。
• 你能够参考你在应用程序的其他部分编写的代码，并在其中遵循模式，而不是总是寻找一步步的说明。

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.

在网站开发中，其实有两个拐点会一起出现。

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开发人员称之为： “掌握CRUD” 在这个阶段，你也应该能够与任何第三方库（例如ruby gem）集成，只需遵循GitHub上提供的文档或博客文章即可。

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

拐点所带来的影响

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

嗯哼，我没有开玩笑 其实根本就没有那么重要。一旦你过了拐点，这些概念只需要一两个星期的教程，甚至几天的时间就能流畅地转化为现实!

最终真正重要的是。

• 你已经扎实的掌握了一个网络开发框架。
• 你对用任何编程语言编写算法复杂的代码都有扎实的掌握。

Hiring managers want developers with solid web development and algorithm skills.

招聘经理希望开发人员具有扎实的网络开发和算法技能。

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进行大量编码。就在几天之内，他就已经在Rails方面有了很大的改变。而在几周之内：产生了巨大的影响。他很快就晋升为技术团队的负责人，这是我参与过的最好的招聘决定之一。

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

尽可能高效地度过拐点的策略。

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，我们经常指导学生如何整合某些gems或使用提供的文档做事情。很多学生不会简单地按照面向刚入门的人的教程中解释的说明去做，而是会按照文档去做，把教程作为后备。注意，文档会把你当成一个已经过了拐点的开发者。在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.

  如果你正在与自信作斗争，要i知道你的感觉是完全正常的。继续努力。如果你继续挣扎，试着和最近通过拐点的人交谈。他们能够体会到你所处的位置，并会向你保证，你所经历的只是暂时的。持续工作，但不要让自己过度劳累。在这个阶段，要知道你每天最多只能有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.

你经历过拐点了吗？分享这篇文章，并与你的朋友展开对话–你会惊讶于有多少人已经达到并超越了这个时刻。