本文主要是介绍The Key To Accelerating Your Coding Skills（加快你编码能力的关键），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
The Key To Accelerating Your Coding Skills（加快你编码能力的关键）
作者 CodeAllen ，转载请注明出处
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.
当你学习编码时就会发生改变。在Firehost（培训机构），我喜欢称之为编码的拐点（inflection point）。在这个阶段后，作为一个开发者的行为会截然不同。创造拐点是一段编程中自给自足的过程，到了某一点到时候你不在需要任何手把手的帮助。这会是一个令人泄气的体验，但是一旦你超过了它，你就会感觉一切尽在掌握。
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.
当查看资料比如文件或教程时密切注意细节是很重要的。甚至许多语法错误和拼写错误会导致错误消息和bugs。开始看错误消息是很让人郁闷的体验，但是这是学习过程的关键。在查看错误消息和问题这段教会你一个很重要的技能：以细节为导向
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:
调试错误信息令人难以置信的重要。事实上，错误信息是编码的一部分：他们被缺乏经验和经验丰富的开发人员看到。不同的是当你有越多的解决错误消息的经验，你就花费越少的时间解决他们。原因是：
l 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.
随着时间的推移，你将血海怎样读错误消息并从中提取能快速解决问题的那部分信息。你第一次看到的错误消息，它可能让你解读真正的意思。但是当你看过了成数百条错误消息后，你将可以定位到问题的位置并且解决它的具体方案了。
l 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.
你应该学习你每次解决的错误消息，不要只是解决错误然后不了了之；需要明白你修复代码的地方为什么错了。通过学习你的错误，下次碰到通用的错误，你就能很快的修复了。
l 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.
编程是一个终身学习的体验。经验丰富的程序员寻找他们从未解决过的问题的答案用来提高他们的技能。当你感觉到那么一刻你知道了关于编码的一切，事实是：那一天永远都不会来到。并且这是一个多么完美的事情啊。
You will be ready to jump into the next phase of your journey when:
当你进入进入下一阶段的旅程，你会：
l 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.
你会看到很多错误信息，以至于不会让你感到害怕。相反，你会指定怎样解析知道他们代表什么意思，以及出现问题代码的位置。
l 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解决问题的专业人士。当你看到令你迷惑的错误时，你知道搜索什么样的信息是你需要的。
l 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.
程序性知识是一项能教会自己的能力，当你想要实现一个新功能，在google搜索怎样的信息？这么多信息需要整合的时候你会感觉两眼一抹黑。学会怎样基于自己的原则找到思路至关重要，因为你不可能知道所有的事情。所以你需要有能力自学怎样自己解决问题。
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上或者博客上的文档就可以集成任何第三方库。
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:
掌握了数据结构和算法的人将能够：
l Write sorting algorithms
写排序算法
l Implement and reverse linked lists
实现和反转链表
l Understand and write programs leveraging stacks, queues, and trees
知道并且能写出堆，栈，队列，和树结构
l 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，Racke 或者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程序。这是专业的开发这每天做的核心的事情。
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:
最重要的是：
l You have a solid grasp on a web development framework
你的web开发框架能力很扎实
l 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的代码。在几天后，他已经做出了很大的影响。接着几周后：有一个重大影响。他很快的升职为一个技术小组的领导，他是我面试过最好的员工了。
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.
尝试尽可能的少使用教程。在Firehost，我们经常让学生了解如何整合某些功能或使用提供的文档做事。而不是简单的遵从教程的指令这些这适合刚开始接触编程的人，请注意文件将会视你为已经经过拐点的开发人员，当你阅读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.
关注必需品并且使用重复。学习怎样提交从头开始编写应用程序，上传一个新的app到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.
拐点过程的最后阶段过程是接受。软件开发是一个持续学习的过程。接受了你解决所有的问题需要思考更多复杂的问题
这篇关于The Key To Accelerating Your Coding Skills（加快你编码能力的关键）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
