Why Learning to Code is So Damn Hard
为什么学习编程如此艰难
Quincy Larson was just a “guy in a suit in an office” and decided he wanted to learn how to code. So he asked around. He started by picking up a bit of Ruby then found himself skimming through other languages like Scala, Clojure and Go. He learned Emacs then Vim and even the Dvorak keyboard layout. He picked up Linux, dabbled in Lisp and coded in Python while living on the command line for more than half a year.
Quincy Larson 只是一个 "在办公室里穿着西装的人"，他决定学习如何编码。于是他四处打听。他先是学了一点 Ruby，然后又粗略地学习了 Scala、Clojure 和 Go 等其他语言。他学会了 Emacs，然后是 Vim，甚至是 Dvorak 键盘布局。他学习了 Linux，涉猎了 Lisp，并用 Python 编写代码，在命令行上生活了大半年。
Like a leaf in a tornado, the advice Quincy received jerked him first one way and then another and then another until he’d finally taken “every online course program imaginable”. By the end of it all, despite having ultimately landed a software development job, Quincy:
就像龙卷风中的一片树叶，Quincy 收到的建议让他先是这样，然后又是那样，直到最后他参加了 "所有能想到的在线课程项目"。到最后，尽管昆西最终找到了一份软件开发的工作，但他还是 "一无所获"：
… was convinced that the seemingly normal programmers I ran into were actually sociopaths who had experienced, then repressed, the trauma of learning to code.
......我确信，我遇到的那些看似正常的程序员实际上都是反社会者，他们经历过学习编程的创伤，然后又压抑了这种创伤。
Ouch. Does that sound familiar?
哎哟听起来熟悉吗？
Phase I: The Hand-Holding Honeymoon
第一阶段：牵手蜜月
It’s really hard to blame anyone for coming into the programming industry with outrageous expectations.
如果有人带着过高的期望进入编程行业，那就真的很难责怪他了。
On the one hand, you’ve heard rumors of how difficult programming is since you were young, like old wives tales meant to scare children into studying social sciences instead.
一方面，你从小就听过编程有多难的传言，就像老太太的故事，目的是吓唬孩子去学习社会科学。
On the other, the “Learn to Code” movement has done a fantastic job of breaking down barriers and showing people that code is actually quite harmless. Tools like Codecademy and Treehouse and Code School reach out with the gentlest of touches to assure you that you too (nay, anyone!) can not just learn to code but become a full-fledged developer as well.
另一方面，"学习代码 "运动在打破障碍方面做得非常出色，它向人们展示了代码其实是无害的。Codecademy、Treehouse 和 Code School 等工具以最温和的方式向你保证，你（不，任何人！）不仅可以学习代码，还可以成为一名成熟的开发人员。
Suddenly the problem isn’t fear, it’s an overabundance of hopes and high expectations.
突然间，问题不在于恐惧，而在于过多的希望和过高的期望。
And, for the most part, these introductory tools do a great job of guiding you like a child in a crosswalk past the big scary variables and conditional statements and through the early phases of programming syntax. As you conquer one after another of their gamified challenges, your confidence rises. Maybe you can do this after all! How hard can it be? You’re basically a developer already!
而且，在大多数情况下，这些入门工具都能很好地引导你，就像在人行横道上引导孩子一样，让你穿过那些可怕的变量和条件语句，完成编程语法的初级阶段。当你征服一个又一个游戏化的挑战时，你的信心也会随之上升。也许你终究能做到！这有什么难的？你基本上已经是一名开发人员了！
The Hand-Holding Honeymoon
牵手蜜月
Here’s the problem — you’re in what I like to call the “Hand Holding Honeymoon” phase. Though you may feel like the end is around the corner, you’re only a fraction of the way there. This is just the beginning…
问题就在这里--你们正处于我称之为 "牵手蜜月 "的阶段。虽然你可能觉得终点就在拐角处，但其实你只走了一小段路。这仅仅是个开始...
Charting The Path Ahead 规划未来之路
Before we dive into Phase II, let’s look at the bigger picture.
在进入第二阶段之前，我们先来看看全局。
In this post, I’ll walk you through the four phases of the typical journey into coding and what you’ll need to do to survive each of them. You’ll also see how two key factors — the density of resources and scope of required knowledge — define this journey.
在本篇文章中，我将向您介绍典型的编码之旅的四个阶段，以及在每个阶段中您需要做些什么。您还将看到资源密度和所需知识范围这两个关键因素是如何定义这段旅程的。
The trek towards job-readiness can be plotted in terms of how your confidence level changes as your capability increases:
您可以根据自己能力的提高而改变自己的信心水平，以此来描绘自己的求职之路：
The Learn-to-Code Journey — Click to Enlarge
学习编码之旅 - 点击放大
This is a relevant relationship because your confidence is highly correlated with your happiness and because the point where your confidence and capabilities match is the best proxy I have for the sweet spot when you’re officially “job ready”.
这是一种相关的关系，因为你的自信心与你的幸福感高度相关，而且你的自信心与能力的匹配点是我所掌握的你正式 "准备好工作 "的最佳代表点。
We’ll look into the unique challenges of the remaining 3 phases in a moment, but this is what each of them essentially involves:
我们稍后将探讨其余三个阶段的独特挑战，但这是每个阶段的基本内容：
- The Hand Holding Honeymoon is the joy-filled romp through highly polished resources teaching you things that seem tricky but are totally do-able with their intensive support. You will primarily learn basic syntax but feel great about your accomplishments.
牵手蜜月 "是一个充满欢乐的旅程，通过高度精良的资源，教你一些看似棘手，但在他们的大力支持下完全可以做到的事情。您将主要学习基本的语法，但会为自己的成就感到自豪。 - The Cliff of Confusion is the painful realization that it’s a lot harder when the hand-holding ends and it feels like you can’t actually do anything on your own yet. Your primary challenges are constant debugging and not quite knowing how to ask the right questions as you fight your way towards any kind of momentum.
困惑之崖是一种痛苦的领悟，当手把手的指导结束，感觉自己还不能独立完成任何事情的时候，就会觉得困难重重。你所面临的主要挑战是不断调试，以及在努力获得任何动力的过程中不知道如何提出正确的问题。 - The Desert of Despair is the long and lonely journey through a pathless landscape where every new direction seems correct but you’re frequently going in circles and you’re starving for the resources to get you through it. Beware the “Mirages of Mania”, like sirens of the desert, which will lead you astray.
绝望沙漠 "是一段漫长而孤独的旅程，在这片无路可走的土地上，每一个新的方向似乎都是正确的，但你却经常在原地打转，你渴望获得资源来度过难关。小心 "狂热的幻象"，就像沙漠中的海妖，会把你引入歧途。 - The Upswing of Awesome is when you’ve finally found a path through the desert and pulled together an understanding of how to build applications. But your code is still siloed and brittle like a house of cards. You gain confidence because your sites appear to run, you’ve mastered a few useful patterns, and your friends think your interfaces are cool but you’re terrified to look under the hood and you ultimately don’t know how to get to “production ready” code. How do you bridge the gap to a real job?
当你终于找到了穿越沙漠的道路，并对如何构建应用程序有了一定的了解时，你就会感到 "真棒"。但是，你的代码仍然像纸牌搭的房子一样孤立而脆弱。你获得了自信，因为你的网站似乎可以运行了，你掌握了一些有用的模式，你的朋友也觉得你的界面很酷，但你却害怕查看引擎盖下的代码，最终你不知道如何获得 "可投入生产 "的代码。如何弥补与真正工作之间的差距？
I’ve interviewed hundreds of aspiring developers over the past several years and heard echoes of the same story again and again. My goal for this post is that you approach the learner’s journey with both eyes open and enough of a plan that you can avoid the common pitfalls of those who have come before you.
在过去的几年里，我采访了数百名有抱负的开发人员，听到的都是同样的故事。我写这篇文章的目的是希望你能睁大眼睛，在学习的过程中制定足够的计划，避免陷入前人常见的误区。
Let’s get back into Phase II…
让我们回到第二阶段...
Phase II: The Cliff of Confusion
第二阶段：混乱的悬崖
So, you’re in Phase I — the “Hand-Holding Honeymoon” — checking off badges and completing coding challenges while your confidence and capabilities grow. This isn’t so bad… what’s all the fuss about? You’ve arrived at the “Peak of Irrational Exuberance”…
所以，你正处于第一阶段--"牵手蜜月"--检查徽章和完成编码挑战，同时你的信心和能力也在增长。这还不算太糟......有什么好大惊小怪的呢？您已经到达了 "非理性繁荣的顶峰"...
Be careful! You’re about to overstep a precipice that’s broken many strong aspiring learners and relegated them to the “coding is too hard” camp. The precise moment this leap occurs is the first time you sit down at your keyboard, open up your text editor, and try to build a project from scratch without any of the fancy in-browser editors, scaffolded code or helpful hints.
小心点！你即将跨过一道悬崖，这道悬崖曾击垮过许多有抱负的学习者，并将他们打入 "编码太难 "的阵营。当你第一次坐在键盘前，打开文本编辑器，在没有任何花哨的浏览器内编辑器、脚手架式代码或帮助提示的情况下，尝试从头开始构建一个项目时，就是发生这种飞跃的确切时刻。
Crap. 废话。
You might stretch this out a bit by following tutorials, but no one has ever reached the skies without leaving the ground, and, at some point, you’re going to have to create magic from a blank text file. You’ve just entered the second phase of learning, where confidence comes crashing down to earth — the “Cliff of Confusion”:
你可以通过学习教程来延长这个阶段，但没有人能够不离开地面就到达天空，在某些时候，你必须从一个空白的文本文件中创造奇迹。你刚刚进入了学习的第二阶段，在这一阶段，你的信心会跌落到地面--"迷茫的悬崖"：
The Cliff of Confusion 混乱之崖
So you build. You fight and scratch your way to a barely-functional solution but there’s something missing. You’re at a war with bugs that makes Starship Troopers look benign. It feels like each victory was gained only by a stroke of lucky Googling and your confidence that you can ever figure this stuff out plummets.
于是，你开始建造。你拼死拼活，终于找到了一个勉强能用的解决方案，但还是少了点什么。你与 Bug 的战争让《星际战舰》看起来很友好。感觉每一次胜利都是通过幸运的谷歌搜索获得的，你对自己能解决这些问题的信心直线下降。
Buuuuuuuuuuuuuuuuuuuuug!!!
噗噗噗噗噗噗噗噗噗噗
This is a particularly frustrating phase to see as an educator and to all participants in our industry. Programming may not be perfect for everyone, but we want you to make progress because sometimes the unlikeliest of stories become the grandest successes.
作为一名教育工作者和我们行业的所有参与者，这是一个特别令人沮丧的阶段。也许编程并不适合每一个人，但我们希望你们取得进步，因为有时最不可能的故事也会成为最伟大的成功。
When the hand-holding ends and students are pushed off the cliff and told to fly, too many potentially awesome people are spiraling onto the rocks of frustration without learning how to flap their wings.
当手把手的教育结束，学生们被推下悬崖，被告知要飞翔时，太多潜在的优秀人才没有学会如何扇动翅膀，就在挫折的礁石上盘旋。
The scary part is that you haven’t even gotten to the meaty stuff yet. This second phase, the Cliff of Confusion, is still very early. Once you’ve finally squashed enough bugs to end the eighth plague of Egypt and actually finished a couple of projects — thus marking the end of Phase II — you’re still just getting started.
可怕的是，你还没有进入最重要的阶段。第二阶段，即 "混乱之崖"，仍处于初期阶段。一旦你终于解决了足以终结埃及第八次瘟疫的 bug，并真正完成了几个项目--从而标志着第二阶段的结束--你仍然只是刚刚起步。
For those who are truly ready to make a career out of this, surviving the Cliff of Confusion is often the point where you decide to go all-in with your new life. But too many are left behind. And, unfortunately, you’re just about to enter the “Desert of Despair”.
对于那些真正准备好以此为职业的人来说，熬过 "迷茫之崖 "往往就是你决定全身心投入新生活的时刻。但有太多的人被甩在了后面。不幸的是，你即将进入 "绝望沙漠"。
The Two Key Factors at Play
起作用的两个关键因素
So what really marks the difference between one phase and the next? Why was Phase II (the Cliff of Confusion) so awful compared to Phase I (the Hand-Holding Honeymoon)? Understanding this will help you realize that it’s not your fault at all if your journey looks like what we’ve just described.
那么，一个阶段和下一个阶段之间的真正区别是什么？为什么与第一阶段（牵手蜜月）相比，第二阶段（困惑悬崖）如此糟糕？理解了这一点，你就会明白，如果你的旅程看起来就像我们刚才描述的那样，那根本就不是你的错。
Basically, there are two key forces at work in every phase — Resource Density and Scope of Knowledge. Let’s see what these are before exploring how they define Phase III.
基本上，每个阶段都有两股关键的力量在起作用--资源密度和知识范围。在探讨它们如何定义第三阶段之前，让我们先来了解一下它们是什么。
Factor 1: Resource Density
因素 1：资源密度
As I said above, when you first start out, it feels like there are a million resources out there trying to hold your hand and pull you into coding. That’s because there are!
正如我上面所说，当你刚刚开始工作时，你会感觉有无数的资源想要牵着你的手，把你拉进编码的行列。因为确实有！
Search for “Learn to Code” and you’ll be hit with a wall of helpful and useful tools, texts, videos and tutorials. And, frankly, they’re great! Never before have there been so many ways to start learning to code.
搜索 "学习编程"，你会看到大量有用的工具、文本、视频和教程。老实说，它们都很棒！以前从未有过如此多的方法来开始学习代码。
Unfortunately, in later phases the density of resources drops off fast. Anyone who’s made the jump from beginner to intermediate can attest that there is a BIG difference between the amount of resources available when you first start out versus when you’re first looking for help building things on your own without too much hand-holding.
不幸的是，到了后期，资源的密度会迅速下降。任何一个从初级跳到中级的人都可以证明，当你刚开始学习时，与当你刚开始在没有太多指导的情况下自己寻求帮助时，所能获得的资源量是有很大差别的。
This problem exacerbates as the amount of knowledge increases rapidly entering Phase III, and is one reason why we call that phase the “Desert of Despair”. Once you get past this and start to become comfortable with what exactly you need to search for, the resources return and you’re able to work with more technical tools like industry blogs and screencasts. Part of this is just understanding which questions to ask.
进入第三阶段后，随着知识量的迅速增加，这个问题会变得更加严重，这也是我们将该阶段称为 "绝望沙漠 "的原因之一。一旦你克服了这个问题，并开始熟悉自己到底需要搜索什么，资源就会回来，你就可以使用行业博客和截屏等技术性更强的工具。这其中的一部分就是了解应该问哪些问题。
Here’s what the Resource Density looks like in each phase (greater line density indicates more resources):
以下是每个阶段的资源密度（线条密度越大，表示资源越多）：
Density of Resources in Each Phase — Click to Enlarge
各阶段的资源密度 - 点击放大
Factor 2: Scope of Knowledge
因素 2：知识范围
Now let’s talk about a related issue — the Scope of Knowledge. This represents the total breadth of new topics you need to learn in each phase. Here’s what it looks like:
现在我们来谈谈一个相关的问题--知识范围。这表示你在每个阶段需要学习的新主题的总广度。它是这样的
The Scope of Knowledge that’s Required in Each Phase — Click to Enlarge
每个阶段所需的知识范围 - 点击放大
When you first start learning, the set of things you need to understand is narrow. Everyone, regardless of goals or language or background, needs to figure out what a for loop is, how to build conditional logic, and other basic structures of programming syntax. There ultimately aren’t even that many of these fundamental concepts so the Scope of Knowledge during that phase is very narrow.
刚开始学习时，需要了解的东西范围很窄。无论目标、语言或背景如何，每个人都需要弄清楚什么是 for 循环、如何构建条件逻辑以及其他基本的编程语法结构。归根结底，这些基本概念并不多，因此在这一阶段的知识范围非常狭窄。
As soon as you get away from the basics, you see a rapid broadening of the Scope of Knowledge as you need to begin picking up things that are more difficult like understanding errors and when to use the code you know know how to use. This is different because there is no “correct” answer to a clear question… things get fuzzy.
一旦脱离了基础知识，你就会发现知识范围迅速扩大，因为你需要开始学习更难的东西，比如理解错误以及何时使用你知道如何使用的代码。这是不同的，因为一个明确的问题没有 "正确 "的答案......事情变得模糊起来。
When you progress into the third phase, the scope of knowledge balloons wider. You now need to understand what tools to use, what languages to learn, underlying CS fundamentals, how to write modular code, object-orientation, good style, and how to ask for help (to name just a few). Every trip to Google or Hacker News takes you down another set of rabbit holes and overwhelms you with more things you don’t know but feel like you should.
当您进入第三阶段时，知识的范围会更广。你现在需要了解使用什么工具、学习什么语言、基本的 CS 基础知识、如何编写模块化代码、面向对象、良好的风格以及如何寻求帮助（仅举几例）。每次访问 Google 或 Hacker News 都会带你进入另一个兔子洞，让你不知所云，但又觉得自己应该知道。
You don’t know what you don’t know.
你不知道自己不知道什么。
Only when you’ve finally found some traction and left the desert does the scope again begin to narrow. By that point, you’ve found your chosen technology and its place in the ecosystem. You finally (pretty much) know what you don’t know and can plot a path through it. You will continue to increase focus as you push onward and into the beginning of your career.
只有当你终于找到了一些牵引力并离开沙漠时，范围才会再次开始缩小。这时，您已经找到了自己选择的技术及其在生态系统中的位置。您终于（基本）知道了您不知道的东西，并能在其中规划出一条道路。当您继续向前迈进，进入职业生涯的初期时，您将继续提高关注度。
Phase III: The Desert of Despair
第三阶段：绝望沙漠
With an understanding of these factors, you can see that the Cliff of Confusion is really just a turning point. The pain caused by the toxic combination of a rapidly increasing Scope of Knowledge and a falling Resource Density results in what I call the “Desert of Despair”.
了解了这些因素，你就会明白，"混乱之崖 "其实只是一个转折点。知识范围迅速扩大，而资源密度却在下降，这种有毒的组合所造成的痛苦，就是我所说的 "绝望沙漠"。
In essence, this desert is where you know there’s an end somewhere but you don’t know how to get there:
从本质上说，这片沙漠就是你知道某处有尽头，却不知道如何到达的地方：
The Desert of Despair 绝望沙漠
The desert is long and fraught with dangers. You’ll find yourself drawn to “Mirages of Mania” along the way — dozens of tempting resources which appear to hold the solutions you’re looking for but which will deposit you, once again, in a place where lonely sand extends to each horizon line.
沙漠漫长而充满危险。你会发现自己被沿途的 "狂热海市蜃楼 "所吸引--数十种诱人的资源看似拥有你正在寻找的解决方案，但却会让你再次置身于一个孤寂的地方，沙子延伸到每一条地平线。
Maybe you sign up for a couple MOOC courses from Coursera or Udacity or edX. Or you find a tutorial which purports to take you all the way. You thought you learned the lessons of the Hand Holding Honeymoon — that there are no easy answers — but the temptation to seek salvation is too great and you fall for the promise that this one will get you to the finish where the others did not.
也许你从 Coursera、Udacity 或 edX 注册了几门 MOOC 课程。或者你找到了一个教程，声称可以带你走完全程。你以为自己已经吸取了 "牵手蜜月 "的教训--没有简单的答案--但寻求救赎的诱惑太大了，你相信这门课能让你到达终点，而其他课程却不能。
You can’t learn this stuff in a week or a month or a single college class no matter what anyone says so stop falling for that!
不管别人怎么说，你都不可能在一周、一个月或一堂大学课上学会这些东西，所以别再上当了！
There is a LOT more to learn than you probably expected. Even if you’re able to get some apps running, it’s hard not to feel lost in the greater scheme of becoming a true professional. It’s difficult to measure your progress. How do you know what you need to learn or if you’re even learning the right things?
要学的东西可能比你预想的要多得多。即使你能够运行一些应用程序，也很难不在成为真正专业人士的大计划中感到迷茫。很难衡量自己的进步。你怎么知道自己需要学什么，或者是否学对了东西？
Even if you’re pointing the right direction, it’s hard to measure your progress. You might feel totally lost until the very moment when you’re finally able to build something that looks and acts the way you expected it to. But, with enough perseverance and a good compass, you’ll eventually get your first few “real” projects launched and you’ll realize that you’re finally starting to get it.
即使你的方向是正确的，也很难衡量你的进展。你可能会感到完全迷失方向，直到你终于能够按照自己的预期构建出一个外观和功能都符合要求的东西。但是，只要有足够的毅力和一个好的指南针，你最终会启动你的第一个 "真正 "的项目，你会意识到你终于开始明白了。
Sure it’s been hard up until now, but maybe this web dev stuff isn’t so bad after all… Everything’s coming up Milhouse!
当然，到现在为止一切都很艰难，但也许网络开发工作并没有那么糟糕......一切都会好起来的，米尔豪斯！
Phase IV: The Upswing of Awesome
第四阶段：威风八面
You’ve made it through the desert and your confidence is growing. Your Google-fu is excellent and you’re finally able to understand those detailed industry blog posts and screencasts. Maybe you’ve gone deep into a particular language or framework and you have confidence that you can build and launch a functioning application.
你已经熬过了沙漠，信心也在不断增强。你的谷歌功夫了得，终于能够理解那些详细的行业博文和截屏。也许你已经深入研究了某种特定的语言或框架，你有信心可以构建并启动一个正常运行的应用程序。
This is the “Upswing of Awesome”:
这就是 "威风上扬"：
The Upswing of Awesome 令人敬畏的上升
All may seem well to the outside but you know deep down that you’re not there yet.
外表看似一切顺利，但你内心深处知道，你还没有达到那个境界。
You can make that application work but what’s happening beneath the surface? Your code is duct tape and string and, worst of all, you don’t even know which parts are terrible and which are actually just fine. Your periodic flashes of brilliance are countered by noob mistakes and, worse, a creeping suspicion that you still don’t have a damn clue what you’re doing.
你可以让应用程序正常运行，但表面之下发生了什么？你的代码就是胶带和绳子，最糟糕的是，你甚至不知道哪些部分很糟糕，哪些部分其实很好。你时不时闪现的聪明才智被新手的错误所抵消，更糟糕的是，你还会渐渐怀疑自己根本不知道自己在做什么。
This is a bipolar phase. You feel like half of you is a bulletproof developer and the other half is a thin veneer of effectiveness covering a wild-eyed newbie who is in way too deep. The further you progress, the more a gnawing sense of uncertainty grows that someone is going to “out” you as a fraud.
这是一个两极分化的阶段。你会觉得自己有一半是刀枪不入的开发人员，而另一半则是披着一层薄薄的有效外衣、深陷其中无法自拔的新手。你的进步越大，就越会产生一种不确定感，担心有人会 "揭穿 "你是个骗子。
You feel like you should be a developer already but the distance between the code you’re writing and a “professional” work environment couldn’t feel further away…
你觉得自己应该已经是一名开发人员了，但你所编写的代码与 "专业 "的工作环境之间的距离却遥不可及...
Eventually, though, you’ll make it. There’s too much momentum not to! The Desert of Despair is behind you and the Cliff of Confusion is a distant memory. You’re finally, truly, on the upswing. You’re learning faster and more intelligently than ever before and, eventually, you will have absorbed enough best practices that your swiss cheese knowledge coalesces into a production-grade skill set.
不过，你最终会成功的。动力太足了绝望的沙漠已经过去，迷茫的悬崖也已成为遥远的记忆。你终于，真正，走上了人生的巅峰。你比以往任何时候都学得更快、更聪明，最终，你将吸收到足够多的最佳实践，使你的瑞士奶酪知识凝聚成一套生产级技能。
The Upswing of Awesome always takes longer than you expect it to and it feels interminable because you’re so close… but you will get there. If you’re persistent enough in the right ways (the topic of a future post for sure), you will convince someone to pay you to keep learning. The job is yours.
令人敬畏的上升期总是比你预期的时间要长，而且因为你离成功如此之近，所以感觉无休无止......但你会成功的。如果你以正确的方式坚持不懈（这肯定是未来文章的主题），你就会说服别人付钱让你继续学习。工作就是你的了。
What it All Looks Like
一切看起来像什么
So now you’ve seen the road ahead and the reasons why it can be difficult. When you combine all four phases we just covered with the factors that define them, it looks something like the following chart:
现在，你已经看到了前方的道路以及困难重重的原因。如果把我们刚才介绍的四个阶段和决定这些阶段的因素结合起来，就会出现类似下图的情况：
The Whole Shebang — Click to Enlarge
整体 - 点击放大
It’s one thing to know the path and another to walk it. Let’s get you started on the right foot.
知道道路是一回事，走好道路又是另一回事。让我们带您踏上正确的道路。
How to Make it Through Alive
如何活下来
The journey seems intense and, frankly, it often is. It’s important that you understand what you’re in for, particularly if you go it alone. But you don’t have to. There are ways to short-circuit most of these problems. Learning to code is rarely as easy as people make it out to be but it’s also rarely as difficult as it seems in the depths of your despair.
这段旅程看似紧张，坦率地说，通常也是如此。重要的是，你要了解自己将面临什么，尤其是如果你独自行动的话。但你不必这样做。有很多方法可以解决大部分问题。学习代码很少像人们说的那样简单，但也很少像你绝望时看起来那样困难。
In this section, I’ll introduce the key tactics you can use to keep yourself pointed in the right direction.
在本节中，我将为您介绍一些关键策略，让您保持正确的方向。
Your Progression Through the Phases — Click to Enlarge
您的阶段进展 - 点击放大
I: Surviving the Hand-Holding Honeymoon
I：度过牵手蜜月
The plethora of available resources in the Hand-Holding Honeymoon make it a lot of fun. They do a great job easing you into the kind of logical thinking you’ll need to cultivate over the coming phases. It’s a great time to start learning to code so try to enjoy it and keep these two tips in mind:
牵手蜜月》中的大量可用资源让它充满乐趣。它们能让你轻松掌握在未来阶段需要培养的逻辑思维。现在正是开始学习代码的大好时机，请尽情享受并牢记这两条提示：
- Start by trying out different resources to find how you learn best and what sorts of projects are the most interesting to you. Maybe it’s Khan Academy’s quick challenges, Codecademy’s in-browser exercises, Chris Pine’s Learn to Program book or Code School’s wacky try Ruby experience. Be open minded at the start and ignore anything about what you should learn… all code is the same at this phase.
从尝试不同的资源开始，找到你最擅长的学习方式，以及你最感兴趣的项目类型。也许是可汗学院的快速挑战、Codecademy 的浏览器内练习、Chris Pine 的《Learn to Program》一书或 Code School 的古怪尝试 Ruby 体验。在开始阶段要保持开放的心态，不要理会任何关于你应该学习什么的说法......在这个阶段，所有的代码都是一样的。 - Then pick one resource and stick with it once you’ve found your fit. Work through to the end of their introductory course arc, which should give you all the foundational knowledge you need to write basic scripts and apps. Then get ready to start building on your own.
找到适合自己的资源后，选择一个资源并坚持下去。在他们的入门课程结束后，您就可以掌握编写基本脚本和应用程序所需的所有基础知识。然后准备开始自己的构建工作。
II: Surviving the Cliff of Confusion
二：在混乱的悬崖上生存
Almost everyone will experience the Cliff of Confusion because the only way to become a developer is to, well, develop. You can pretend to be building by signing up for tutorials (or tutorials which masquerade as “complete” courses), but you’re just putting off the inevitable. Tutorials are a good way to bridge from more high-touch introductory offerings but you’ll need to wean yourself off the pacifier and face the real world at some point.
几乎每个人都会经历 "困惑之崖"，因为成为开发人员的唯一途径就是，嗯，开发。你可以通过注册教程（或伪装成 "完整 "课程的教程）来假装进行开发，但这只是在拖延时间。教程是一种很好的衔接方式，可以让你从接触更多的入门课程中脱身，但你终究需要让自己脱离奶嘴，面对真实的世界。
Three tips for making the transition to building on your own:
过渡到独立建房的三个技巧：
- Work with someone else, even another beginner. You’ll be surprised how much easier it is to debug an impossible error when sharing two pairs of eyes.
与他人合作，哪怕是另一位初学者。你会惊讶地发现，如果有两双眼睛，调试一个不可能的错误会容易得多。 - Read other people’s code to get comfortable with good patterns. Try to understand why the author did what they did. You wouldn’t try to become a novelist without reading books as well, would you? We’ll focus on this in an upcoming post but, for now, keep your eyes open for any small problems or projects that other people have written solutions for.
阅读其他人的代码，熟悉好的模式。试着理解作者为什么这样做。如果你不看书，就不可能成为小说家，不是吗？我们将在下一篇文章中重点讨论这个问题，但现在，请睁大眼睛，留意别人已经写出解决方案的小问题或项目。 - Start small and build constantly. You should have interesting big projects in mind for the future, but you’ll need to get comfortable debugging and searching for resources with bite-sized challenges. There’s really no substitute for experience.
从小做起，不断积累。你应该为未来设想一些有趣的大项目，但你需要适应调试和搜索资源的工作。经验真的无可替代。
III: Surviving the Desert of Despair
三：在绝望的沙漠中生存
Once you’ve become comfortable debugging, your biggest problem becomes the fire hose of required knowledge and a total loss for how to learn it all… the Desert of Despair. In this case, what you really need is a strong path forward. The Mirages of Mania represent all the interesting side paths and rabbit holes and get-skilled-quick schemes which ultimately waste your time.
一旦调试得心应手，你最大的问题就变成了所需知识的 "水龙头"，以及完全不知道如何学习这些知识......绝望的沙漠。在这种情况下，你真正需要的是一条强有力的前进道路。躁狂症的幻影代表了所有有趣的旁门左道、兔子洞和急功近利的计划，这些最终都会浪费你的时间。
So the keys to getting out of the Desert of Despair are:
因此，走出绝望沙漠的关键在于：
- Have a strong goal for what you want to accomplish because otherwise you will end up chasing your tail learning all kinds of interesting but ultimately unproductive things. If you have the time to spare, by all means skip this…
对自己想要实现的目标要有一个坚定的目标，否则，你最终会追着自己的尾巴学习各种有趣但最终无益的东西。如果您有时间，请跳过这部分内容... - Find a strong path which leads directly to the goal you’ve set and verify that it will actually get you there. This is where you need to dig deeper than the marketing slogans and smiling faces on course websites or book jackets to ask “will this help me accomplish the goal I’ve set or not?”
找到一条直接通往你所设定目标的强有力的道路，并验证它是否真的能帮你实现目标。这时，你需要比课程网站或书籍封套上的营销口号和笑脸更深入地挖掘，问一问 "这到底能不能帮助我完成既定目标？" - Focus and avoid distractions because, if you’re the kind of person who’s interested in learning to code, you’re also the kind of person who gets interested by learning all kinds of other awesome things. When coding gets difficult, you need to be able to push forward instead of just trying out the next cool-looking thing.
集中精力，避免分心，因为如果你是那种对学习编码感兴趣的人，那么你也是那种对学习其他各种很棒的东西感兴趣的人。当编码遇到困难时，你需要能够勇往直前，而不仅仅是尝试下一个看起来很酷的东西。
If you’re able to identify a path and stick with it, you’ll eventually push forward to the next phase instead of spending months or years chasing mirages across the shifting sands of the this desert.
如果你能确定一条道路并坚持走下去，你最终会进入下一个阶段，而不是花费数月或数年的时间，在这片沙漠中不断变幻的沙地上追逐海市蜃楼。
IV: Surviving the Upswing of Awesome
四：在威风凛凛的浪潮中求生存
The Upswing of Awesome is one of the trickiest transitions. You can develop applications but you really want to become a web developer. Getting past this phase and into a job requires you to do three things:
令人敬畏的上扬是最棘手的过渡之一。你可以开发应用程序，但你真的想成为一名网络开发人员。要度过这个阶段，找到一份工作，你需要做三件事：
- Seek and follow best practices for programming. You need to understand the difference between a solution and the best solution. Best practices are a major difference between hacking on your own and building production quality code in a real job setting.
寻求并遵循编程的最佳实践。你需要了解解决方案与最佳解决方案之间的区别。最佳实践是自行编程与在实际工作中编写高质量代码之间的主要区别。 - Check your assumptions because you’ve probably skated by with some gaping holes in your knowledge that you didn’t even know you had. You need to diagnose and fix these holes.
检查一下你的假设，因为你的知识中可能存在一些你自己都不知道的漏洞。你需要诊断并修补这些漏洞。 - Tackle the unsexy skills that are rarely addressed but highly important for transitioning into a professional setting. This includes things like testing, data modeling, architecture and deployment which are really easy to breeze past but which are totally fundamental to good development.
解决那些很少涉及但对过渡到专业环境非常重要的非专业技能。这包括测试、数据建模、架构和部署等内容，这些内容很容易被忽略，但却是良好开发的基础。
The key to accomplishing these things and pushing through the Upswing of Awesome is to get feedback. Students who have learned entirely on their own may be productive but rarely have the kind of legible, modular, and maintainable code that makes them attractive in a professional setting. You need to work with other humans who will challenge your assumptions, ask piercing followup questions, and force you to fix the leaks in your bucket of knowledge.
要完成这些任务并突破 "令人敬畏的上升期"，关键在于获得反馈。完全靠自学成才的学生可能很有成就感，但他们很少能写出清晰易懂、模块化和可维护的代码，而这正是他们在专业环境中吸引人的地方。你需要与其他人一起工作，他们会质疑你的假设，提出尖锐的后续问题，并迫使你修补知识桶中的漏洞。
So… Can it be Done?
那么......能做到吗？
This all may sound overwhelming but I promise that many others have persevered and survived this journey before you. By understanding the road ahead, you’re already in a good spot to take it on with a focused plan and access to the right kind of help.
这一切可能听起来令人不知所措，但我保证，在你之前，已经有许多人坚持不懈地走过了这段旅程。了解了前方的道路，你就已经有了一个很好的计划，并能获得正确的帮助。
Obviously there isn’t space in this particular post to dig as deeply into each phase of the journey as we’d like or to provide the kind of granular how-to advice you deserve. That said, this is a journey with which we’re quite familiar and about which we’re highly passionate so we want to help in any way we can.
显然，这篇文章没有足够的篇幅来深入探讨旅程的每一个阶段，也无法提供您应得的详细建议。尽管如此，这是我们非常熟悉的旅程，我们对此充满热情，因此我们希望尽我们所能提供帮助。
Our core program is specifically designed to bridge this whole process but, if you’re interested in following along on your own, we’ll be addressing it publicly and in depth during future blog posts as well.
我们的核心课程就是专门为衔接这整个过程而设计的，但如果你有兴趣自己跟进，我们也会在今后的博文中公开、深入地讨论这个问题。
Sign up below if you’d like to come along for the ride as we dig deeper into everything here — from finding a mentor to bridging the gap to a fulltime job in web development. Because, though it’s a challenging road ahead, you don’t have to walk it alone.
如果您想参与我们的讨论，请在下方注册，我们将在这里深入探讨从寻找导师到弥补差距，再到全职从事网络开发工作的方方面面。因为，虽然前路充满挑战，但你不必独自前行。
Good luck! 祝你好运
Special thanks to Peter DePaulo, Javier Noris, Michael Alexander, Andy Brown, Saul Costa, Phil Nachum and Quincy Larson for sharing your experiences and for helping to debug these thoughts.
特别感谢 Peter DePaulo、Javier Noris、Michael Alexander、Andy Brown、Saul Costa、Phil Nachum 和 Quincy Larson 分享你们的经验并帮助调试这些想法。
If this was helpful, spread the love ☺
如果这对您有帮助，请传播爱 ☺
Originally published at www.vikingcodeschool.com.
原文发表于 www.vikingcodeschool.com。
