加速你的编码技能的关键

文章来自：http://blog.thefirehoseproject.com/posts/learn-to-code-and-be-self-reliant/

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中，我们喜欢将此称为编码的拐点。在此阶段之后，作为开发人员的操作方式将会有很大的不同。构建到拐点是在编程中实现自给自足的过程，直到不再需要任何手工操作。这可能是一个令人沮丧的经历，但一旦它在你身后，它是令人难以置信的授权。

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. 当你开始学习编码时，有很多信息你还不知道。这些信息称为领域特定知识。示例包括:了解如何在ruby中编写循环，或如何使用ruby on Rails从数据库中提取内容。特定领域的知识包含特定编程环境特有的协议。

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. 最初，您可能会对看到的每个错误消息请求帮助。随着时间的推移，您将学会通过反复检查代码和进行智能谷歌搜索来减少请求帮助的次数。

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. 您可以参考在应用程序的其他部分中编写的代码，并遵循其中的模式，而不是总是寻找一步一步的指导。

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:用消防水带学生经过拐点时的话说:

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开发的转折点，因为这更容易做到，他们会把问题集中在评估你在算法和数据结构方面的技能上。这些问题通常集中在我们上面提到的主题上:排序算法，反向链表，以及使用堆栈、队列和树。

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 您对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. 当我在贝宝工作的时候，我的团队雇佣了一个没有Rails经验的高级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. 视频在解释特定领域的细节方面很糟糕因为它们要花很长时间才能观看。假设您想与谷歌映射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里，我们经常指导学生如何集成某些gem或使用提供的文档做一些事情。许多学生不会简单地按照教程中针对刚开始学习的人的说明学习，而是会按照文档学习，并将教程作为备份。请注意，文档会将您视为已经通过拐点的开发人员。在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. 如果你正与自信作斗争，要知道你的感受是完全正常的。继续工作。如果你还在挣扎，试着和那些刚过拐点的人谈谈。他们将能够与你所处的职位相关联，并向你保证你所经历的只是暂时的。持续工作，但不要过度工作。在游戏的这个阶段，你要知道你每天最多只能工作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. 你经历过拐点吗?和你的朋友分享这篇文章，开始一段对话——你会惊讶地发现有这么多人达到并超越了这一时刻

What do you mean there are TWO inflection points? Isn’t an inflection point where everything starts to make sense? If one part in the development starts to make sense, why then do you call it an inflection point? Is there no way to unify these “inflection points” into something more concrete? 你说有两个拐点是什么意思?难道不是一个转折点，一切都开始变得有意义吗?如果开发中的某个部分开始有意义，那么为什么要称之为拐点呢?难道没有办法把这些“拐点”统一成更具体的东西吗?

Great question! Basically there are two keys to being a solid web developer: 好问题!基本上有两个关键成为一个可靠的web开发人员:

Building a Database Driven application. Developers call this “building crud apps”. This will push data into a database, maybe integrate with a few gems, etc. Once you code enough web apps you’ll notice there is a pattern/formula that will get you through 90% of the stuff you build.
*建立一个数据库驱动的应用程序。开发人员称之为“构建crud应用程序”。一旦你编写了足够多的web应用程序，你就会注意到有一种模式/公式可以帮助你完成90%的构建工作。
Solving algorithms is a bit different. Basically instead of following a pattern, it usually involves a lot of trial-and-error before things work as you expect.
*解决算法有点不同。基本上，与遵循模式不同的是，它通常需要在事情如您所期望的那样工作之前进行大量的试错。

The two eventually intersect when building complex apps in the real world. 在现实世界中构建复杂的应用程序时，这两者最终会相交。

For example if you’re building a chess game, storing game information, user login, all standard stuff that is involved in building a CRUD app. But, there are more complicated algorithms you’ll need to also support. Think: determining if a user is in check, or checkmate. Or if a move is valid. 例如，如果您正在构建一款国际象棋游戏，存储游戏信息、用户登录，以及构建CRUD应用程序所涉及的所有标准内容。但是，您还需要支持更复杂的算法。考虑:确定用户是被检查，还是被检查。或者如果一个动作是有效的。

Solving algorithms don’t help you build a form and prompt the user for stuff. Prompting the user and storing things in a database doesn’t help you with algorithmically challenging things. When you are solid at the patterns you’ll use to do 90% of the time, and the algorithms that you need the 10% you can solve most challenges you’re faced. 解决算法并不能帮助您构建表单并提示用户输入内容。提示用户并将数据存储在数据库中并不能帮助您解决算法上的难题。当你掌握了90%的时间你会用到的模式，你需要的算法你可以解决你面临的大多数挑战。

I never seem to get past the domain specific and procedural knowledge stage. Why? 我似乎从未越过领域特定知识和过程知识阶段。为什么?

Getting past the domain specific and procedural stage is a bit hard. First you need to be comfortable reading and understanding things like documentation and things that are intended for “intermediate” programmers rather than “beginners”. Once you can read and use the documentation you’ll have a good way to teach yourself new topics. 通过特定领域和过程阶段有点困难。首先，您需要轻松地阅读和理解文档等面向“中级”程序员而不是“初学者”的内容。一旦你可以阅读和使用这些文档，你就有了一个很好的方法来自学新的主题。

Then you need to be willing to go outside your comfort-zone and be ok spending time working through things on your own. Find a problem that excites you and go for it! 然后你需要愿意走出你的舒适区，自己花时间解决问题。找到一个让你兴奋的问题并去做!

Keep coding, Chris! 🙂

I really don’t know what to say about this article or this one “How You’ll Know You’re Ready to Start Working as a Web Developer” 我真的不知道该怎么说这篇文章或者这篇“你如何知道你已经准备好开始作为一个Web开发人员工作” It went straight to my brain as if while reading I was watching my self in a mirror. 它直接进入了我的大脑，就好像我在阅读的时候在镜子里看着我自己。 What an excellent and brilliant article. You can probably call this Psychology for developers. 多么精彩的一篇文章啊。你可以把这种心理称为开发者。 I still feel weird after reading this ( in a good manner). why? 读了这篇文章后，我仍然觉得很奇怪。为什么? I am currently a biochemist with some years in the field. Yes I do DNA ,RNA molecular biology, is fun and everything but.. it does not pay well.( currently bellow and close to 40 000) 我目前是一名生物化学家，在该领域工作了几年。是的，我做DNA,RNA分子生物学，很有趣，但…工资不高。(现时约有40000人) This year I decided to completely change my carrier from that to a developer which I really love. In 11-12 month ( I actually started seriously in jan-feb 2015) I started from 0, (zero, nada) and learned HTML, css ,JS , some jQuery, some C#, some android. Now I know how to make a website( responsive of course) and I am developing my own ASP.Net MVC web app. 今年我决定彻底改变我的载体从那变成一个我真正喜欢的开发者。在11-12个月的时间里(实际上我是在2015年1- 2月认真开始的)，我从0开始学习HTML, css,JS, jQuery, c#， android。现在我知道如何制作一个网站(当然是响应)，我正在开发我自己的ASP。Net MVC web应用程序。

Some of You will say a year and still not in the field? well I have 3 children and ..40 years old. Some have told me I am late to this. but still I think I can make it but it is hard (but still I dont fill safe and actually if were to apply for a job I will feel like an impostor) 你们中的一些人会说一年还没开始工作?我有三个孩子…40岁。有些人告诉我我来晚了。但我仍然认为我能做到，但这很难(但我仍然不能胜任，事实上，如果我申请一份工作，我会觉得自己像个骗子)

This article really describe some of the points where I feel now or the sensation that I am not ready when probably I already am Thanks for this

这篇文章真的描述了我现在的一些感觉，或者我可能已经准备好了，但我还没有准备好感谢

You’re probably more ready than you think, Ernest! Keep up the awesome work on your coding journey! Go outside your comfort-zone! 你可能比你想象的更有准备，欧内斯特!在你的编码之旅中，继续努力吧!走出你的舒适区!

加速你的编码技能的关键

The Key To Accelerating Your Coding Skills