如何有效地快速提高自己編程能力？（中英）
The Key To Accelerating Your Coding Skills?
如何有效地快速提高自己編程能力的關(guān)鍵點(diǎn)
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.
當(dāng)你學(xué)習(xí)編碼時(shí)，有一個(gè)時(shí)刻，一切都開始改變。在Firehose中，我們喜歡把這稱為編碼的拐點(diǎn)。過(guò)了這個(gè)階段，你作為一個(gè)開發(fā)者的操作方式將發(fā)生巨大的變化。在建立拐點(diǎn)的這一過(guò)程中，其實(shí)就是在編程方面的自給自足過(guò)程，當(dāng)你達(dá)到不再需要任何手把手的幫助。這可能是一個(gè)令人難受的經(jīng)歷，但一旦它出現(xiàn)在你身上，它便是一種令人難以置信的。
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，我們的目標(biāo)不僅僅是教你Ruby，如何構(gòu)建Web應(yīng)用程序，或者如何編寫測(cè)試。雖然我們確實(shí)教授了這些技能和更多的技能，但我們的主要目標(biāo)是加速學(xué)生通過(guò)拐點(diǎn)，使他們獲得解決任何問(wèn)題的能力。我們相信，能夠使自己解決問(wèn)題是一種無(wú)價(jià)的技能，這種教學(xué)方法將使你比簡(jiǎn)單地學(xué)習(xí)如何構(gòu)建一套應(yīng)用程序更進(jìn)一步。
The Tutorial Phase (3-8 weeks of serious coding)
教程階段（認(rèn)真編碼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.
當(dāng)你開始學(xué)習(xí)代碼的時(shí)候，有很多信息你還不知道。這些信息被稱為特定領(lǐng)域知識(shí)。例如：知道如何用ruby/java寫一個(gè)循環(huán)，或者如何使用Ruby on Rails從數(shù)據(jù)庫(kù)中提取一些東西。特定領(lǐng)域知識(shí)包含了某個(gè)編程環(huán)境所特有的協(xié)議。
成為一個(gè)自給自足的開發(fā)人員的第一步是學(xué)習(xí)如何做特定的任務(wù)。一旦你掌握了某些任務(wù)，各部分如何結(jié)合在一起的大體思路將開始變得明顯。隨著時(shí)間的推移，你將開始認(rèn)識(shí)到模式，最終，這些剛開始看起來(lái)混亂和陌生的東西將成為第二天性。
For students starting out, the most important skill to acquire is attention to detail.
對(duì)于初入職場(chǎng)的學(xué)生來(lái)說(shuō)，最需要掌握的技能就是對(duì)細(xì)節(jié)的關(guān)注。
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.
在查閱文檔或教程等資料時(shí)，密切關(guān)注細(xì)節(jié)非常重要。即使是最微小的錯(cuò)字和拼寫錯(cuò)誤也會(huì)導(dǎo)致錯(cuò)誤信息或錯(cuò)誤。看到錯(cuò)誤信息一開始是一種令人沮喪的體驗(yàn)，但這是學(xué)習(xí)過(guò)程中至關(guān)重要的一步。在這個(gè)階段處理錯(cuò)誤信息和問(wèn)題，可以教會(huì)你在安全環(huán)境下編程的最重要技能之一：注重細(xì)節(jié)。
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:
調(diào)試錯(cuò)誤信息是（Debug）非常重要的。事實(shí)上，錯(cuò)誤消息只是編程的一部分：沒有經(jīng)驗(yàn)和非常有經(jīng)驗(yàn)的開發(fā)人員都會(huì)看到它們。唯一的區(qū)別是，你處理錯(cuò)誤消息的經(jīng)驗(yàn)越多，你需要花在修復(fù)錯(cuò)誤消息上的時(shí)間就越少。這就是為什么：
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.
隨著時(shí)間的推移，你將學(xué)會(huì)如何閱讀錯(cuò)誤信息并快速提取問(wèn)題的相關(guān)細(xì)節(jié)。第一次看到錯(cuò)誤信息時(shí)，你會(huì)花上一段時(shí)間來(lái)解讀它的實(shí)際含義。但當(dāng)你看到數(shù)百條錯(cuò)誤信息后（你會(huì)看到數(shù)百條?。?，你將能夠準(zhǔn)確地確定問(wèn)題的位置和相關(guān)細(xì)節(jié)，以便修復(fù)它。
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.
你應(yīng)該從你解決的每一條錯(cuò)誤信息中學(xué)習(xí)。不要只是修復(fù)錯(cuò)誤就完事了，要了解你所修復(fù)的代碼有什么問(wèn)題。通過(guò)從你的每一個(gè)錯(cuò)誤中學(xué)習(xí)，下次你犯同樣的錯(cuò)誤時(shí)，你就能更快地修復(fù)它。
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.
一開始，你可能會(huì)就你看到的每一條錯(cuò)誤信息尋求幫助。隨著時(shí)間的推移，你會(huì)學(xué)會(huì)通過(guò)仔細(xì)檢查你的代碼和進(jìn)行智能谷歌搜索來(lái)減少尋求幫助的頻率。
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.
在教程階段，你將按照指令文檔進(jìn)行操作。一開始，你會(huì)發(fā)現(xiàn)按照指令操作很有挑戰(zhàn)性，錯(cuò)誤信息會(huì)頻繁發(fā)生。隨著時(shí)間的推移，你將發(fā)展出調(diào)試錯(cuò)誤的技能，并更好地關(guān)注小細(xì)節(jié)，你將能夠更快地取得進(jìn)展。當(dāng)你在結(jié)束教程階段的時(shí)候，你會(huì)發(fā)現(xiàn)你能夠以更快的速度編寫代碼。
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.
在這一點(diǎn)上，有些人感到很自信–就像他們已經(jīng)準(zhǔn)備好拋棄訓(xùn)練輪子（基本功），在沒有結(jié)構(gòu)化指導(dǎo)的情況下開始構(gòu)建東西–他們會(huì)很高興地潛入深淵。另一些學(xué)生會(huì)伸手去看更多的教程，試圖獲得更多特定領(lǐng)域的知識(shí)，以尋求 “全面理解”。不幸的是，教程只能帶你走這么遠(yuǎn)，
真正的信心并不是在教程或指南中找到的。真正的自信來(lái)自于在你不知道如何解決的問(wèn)題中掙扎，并自己發(fā)現(xiàn)解決方案。
*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.
你永遠(yuǎn)不會(huì)知道你需要知道的一切，解決你所有的問(wèn)題。進(jìn)入這個(gè)旅程，你可能設(shè)想自己最終學(xué)會(huì)了所有你需要學(xué)習(xí)的東西，然后被發(fā)現(xiàn)。這一刻永遠(yuǎn)都不會(huì)發(fā)生（啊這？）。
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.
編程是一種終身學(xué)習(xí)的經(jīng)歷。有經(jīng)驗(yàn)的軟件工程師會(huì)尋求解決他們尚未解決的問(wèn)題，因?yàn)檫@給他們提供了學(xué)習(xí)更多知識(shí)的機(jī)會(huì)。如果你發(fā)現(xiàn)自己在等待一個(gè)時(shí)刻，當(dāng)你終于覺得自己知道了關(guān)于編碼的一切，要知道：你所等待的那一天永遠(yuǎn)不會(huì)到來(lái)。而這是一件很美妙的事情。
師夷長(zhǎng)技以制夷
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.
當(dāng)你準(zhǔn)備好進(jìn)入你旅程的下一個(gè)階段時(shí) :
你已經(jīng)看到了足夠多的錯(cuò)誤信息，它們不再讓你感到震驚。相反，您知道如何解讀它們的含義，以及在哪里尋找代碼中的問(wèn)題。
你是谷歌搜索解決方案的專家（或者是stackoverfolw）。當(dāng)你正在添加一個(gè)功能或看到一個(gè)令人困惑的錯(cuò)誤信息時(shí)，你知道該搜索什么來(lái)找到你需要的信息。
你能夠參考你在應(yīng)用程序的其他部分編寫的代碼，并在其中遵循模式，而不是總是尋找一步步的說(shuō)明。
The Inflection Point (2-4 weeks with the right mentality)
轉(zhuǎn)折點(diǎn)(保持好2-4周的心態(tài)正確)
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.
拐點(diǎn)的階段是學(xué)習(xí)代碼編程最令人沮喪的階段之一，但在很多方面，它也是唯一重要的階段。在這個(gè)階段，你將逐步放棄使用教程，開始解決那些沒有人為你提供解決方案的問(wèn)題。
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
在某些時(shí)候，你會(huì)覺得自己還沒有準(zhǔn)備好去解決這個(gè)階段的問(wèn)題，就像你想回到構(gòu)建東西的時(shí)候，有一個(gè)具體做什么的大綱。不要被這種心態(tài)所迷惑。你會(huì)感到沮喪的原因是
During the inflection phase, you will be coding 10-20 times SLOWER than in the previous phase.
在拐點(diǎn)階段，你的編碼速度將比前一階段慢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.
你可能會(huì)開始質(zhì)疑自己，懷疑自己是否真的有能力成為一名程序員。在這個(gè)階段，不安全感和懷疑的感覺很常見。
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.
盡管你會(huì)覺得自己學(xué)習(xí)和完成事情的速度慢了很多，但實(shí)際上，你實(shí)現(xiàn)的是最重要的事情。當(dāng)你的特定領(lǐng)域的知識(shí)在對(duì)著推桿尖叫的時(shí)候，你所學(xué)習(xí)的一切都將是關(guān)于程序性的知識(shí)。
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.
程序性知識(shí)就是把自己不知道的東西順勢(shì)教給自己。當(dāng)你需要實(shí)現(xiàn)一個(gè)新的功能時(shí)，你應(yīng)該進(jìn)行什么樣的谷歌搜索？在這個(gè)時(shí)候，當(dāng)涉及到很多你想要完成的事情時(shí)，你會(huì)覺得自己是 “在黑暗中”。學(xué)會(huì)如何自己尋找光明是至關(guān)重要的，因?yàn)槟阌肋h(yuǎn)不可能知道所有需要知道的事情，所以你需要能夠教會(huì)自己如何解決眼前的問(wèn)題。
Most people do not realize that in order to learn to code, you need to learn both domain-specific and procedural knowledge.
大多數(shù)人都沒有意識(shí)到，為了學(xué)習(xí)代碼，你需要學(xué)習(xí)特定領(lǐng)域和程序性知識(shí)。
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.”
有些軟件工程師一旦找到了自己的立足點(diǎn)，就會(huì)呆在舒適區(qū)里面。這些類型的程序員被稱為維護(hù)程序員–不是你應(yīng)該努力成為的。相反，你應(yīng)該每天都努力超越自己的極限。程序員辭職最常見的原因是 “既然我已經(jīng)解決了所有有趣的問(wèn)題，就不再有挑戰(zhàn)性了”。
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:
與其試圖將編碼項(xiàng)目拉入你的舒適區(qū)，不如尋找你當(dāng)前技能之外的問(wèn)題。這是建立和擴(kuò)展你的技能的唯一途徑。
用一位Firehose學(xué)生在度過(guò)拐點(diǎn)后的話來(lái)說(shuō)：
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!
我仍然感覺到我是在一個(gè)低谷里！ 只是我越來(lái)越自在，知道那是我必須要去的地方!
In web development, there are actually two inflection points that will come together.
在網(wǎng)站開發(fā)中，其實(shí)有兩個(gè)拐點(diǎn)會(huì)一起出現(xiàn)。
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.
網(wǎng)絡(luò)開發(fā)的拐點(diǎn)是指當(dāng)你有能力建立任何你想要的數(shù)據(jù)庫(kù)驅(qū)動(dòng)的應(yīng)用程序的時(shí)候。這意味著能夠建立一個(gè)有許多頁(yè)面的網(wǎng)絡(luò)應(yīng)用程序，從一個(gè)簡(jiǎn)單的數(shù)據(jù)庫(kù)中存儲(chǔ)和檢索信息。Web開發(fā)人員稱之為： “掌握CRUD” 在這個(gè)階段，你也應(yīng)該能夠與任何第三方庫(kù)（例如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.
算法和數(shù)據(jù)結(jié)構(gòu)的拐點(diǎn)是一個(gè)不那么淺顯的拐點(diǎn)，但其實(shí)它更重要。攻克了這個(gè)點(diǎn)的人，除了掌握編程的基礎(chǔ)知識(shí)，對(duì)解決復(fù)雜的編碼難題有了深入的了解外，還將掌握自己所從事的編程語(yǔ)言。
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
征服了算法和數(shù)據(jù)結(jié)構(gòu)拐點(diǎn)的人，就能：
編寫排序算法??
執(zhí)行和反向鏈接清單??
了解并編寫利用堆棧、隊(duì)列和樹的程序。??
使用遞歸或迭代解決方案編寫計(jì)算機(jī)程序。??
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.
簡(jiǎn)而言之，一旦你通過(guò)了這個(gè)拐點(diǎn)，你就掌握了數(shù)據(jù)操作，并將理解你的代碼決策對(duì)性能的影響。傳統(tǒng)的計(jì)算機(jī)科學(xué)學(xué)位只注重讓學(xué)生通過(guò)算法和數(shù)據(jù)結(jié)構(gòu)的拐點(diǎn)。很多大學(xué)都是用一般行業(yè)內(nèi)不使用的編程語(yǔ)言來(lái)進(jìn)行教學(xué)，比如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.
在大多數(shù)技術(shù)面試中，面試官會(huì)認(rèn)為你已經(jīng)過(guò)了web開發(fā)的拐點(diǎn)，因?yàn)檫@樣做比較容易，他們的問(wèn)題會(huì)集中在評(píng)估你在算法和數(shù)據(jù)結(jié)構(gòu)方面的技能上，這些問(wèn)題一般會(huì)集中在我們上面提到的主題上：排序算法，反向鏈接列表，以及使用堆棧、隊(duì)列和樹。
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.
開發(fā)者一旦通過(guò)了Web開發(fā)的拐點(diǎn)和算法與數(shù)據(jù)結(jié)構(gòu)的拐點(diǎn)，就掌握了通往王國(guó)的鑰匙。
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.
這些開發(fā)人員將能夠解決二者交叉的挑戰(zhàn)：需要在高級(jí)Web應(yīng)用的背景下構(gòu)建的復(fù)雜算法。這也是專業(yè)Web開發(fā)人員每天工作的核心。
Consequences of the Inflection Point
拐點(diǎn)所帶來(lái)的影響
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.
拐點(diǎn)最大的后果是，當(dāng)你第一次聽到拐點(diǎn)的時(shí)候，聽起來(lái)會(huì)有點(diǎn)反常。深深地吸一口氣吧：
在學(xué)習(xí)代碼的時(shí)候，特定領(lǐng)域的知識(shí)在大環(huán)境下并不重要。
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
嗯哼，我沒有開玩笑 其實(shí)根本就沒有那么重要。一旦你過(guò)了拐點(diǎn)，這些概念只需要一兩個(gè)星期的教程，甚至幾天的時(shí)間就能流暢地轉(zhuǎn)化為現(xiàn)實(shí)!
最終真正重要的是。
你已經(jīng)扎實(shí)的掌握了一個(gè)網(wǎng)絡(luò)開發(fā)框架。
你對(duì)用任何編程語(yǔ)言編寫算法復(fù)雜的代碼都有扎實(shí)的掌握。
Hiring managers want developers with solid web development and algorithm skills.
招聘經(jīng)理希望開發(fā)人員具有扎實(shí)的網(wǎng)絡(luò)開發(fā)和算法技能。
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.
當(dāng)我在PayPal工作時(shí)，我的團(tuán)隊(duì)雇傭了一位沒有任何Rails經(jīng)驗(yàn)的高級(jí)Rails開發(fā)人員–他一直在用Python、LISP和Perl進(jìn)行大量編碼。就在幾天之內(nèi)，他就已經(jīng)在Rails方面有了很大的改變。而在幾周之內(nèi)：產(chǎn)生了巨大的影響。他很快就晉升為技術(shù)團(tuán)隊(duì)的負(fù)責(zé)人，這是我參與過(guò)的最好的招聘決定之一。
*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.
不要放棄堆棧。很多人會(huì)說(shuō)：”AngularJS最近很火”、”JavaScript正在興起 “或 “最新的流行是…” 我的回答是： “那又怎樣？” 當(dāng)你在學(xué)習(xí)如何編程時(shí)，你的唯一目標(biāo)應(yīng)該是找到拐點(diǎn)并消滅它。一旦你這樣做了，學(xué)習(xí)那種新的、性感的時(shí)尚就根本不是什么難事了。
*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.
成為自食其力的人。有能力在沒有結(jié)構(gòu)化指導(dǎo)的情況下學(xué)習(xí)新的編碼技能（其實(shí)就是不看視頻教程），意味著你不再需要等待任何人來(lái)幫助你。這意味著，對(duì)于大部分你需要學(xué)習(xí)的內(nèi)容，你可以簡(jiǎn)單地在互聯(lián)網(wǎng)上搜索并閱讀關(guān)于你需要知道的各種材料。
This doesn’t mean you immediately “know” everything, but just that everything is now “figure-out-able,” so in essence, you are unstoppable.
這并不意味著你馬上就能 “知道 “一切，只是說(shuō)現(xiàn)在一切都 “可想而知”，所以從本質(zhì)上講，你是不可阻擋的。
The Skills You Will Develop During the Inflection Point
拐點(diǎn)期間你將要培養(yǎng)的技能
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?”
作為一個(gè)軟件開發(fā)人員，最好的參考資料是你已經(jīng)寫過(guò)的類似代碼。當(dāng)你完全理解你所寫的代碼時(shí)，你不需要將所有的細(xì)節(jié)都提交到內(nèi)存中。這意味著，在構(gòu)建一個(gè)新功能時(shí)，你應(yīng)該問(wèn)自己的第一個(gè)問(wèn)題是?！蔽乙郧笆欠褚沧鲞^(guò)類似的東西？” 如果答案是肯定的，就重新審視代碼，在腦海中逐行演練。重新向自己解釋它在做什么，然后問(wèn)自己：”我現(xiàn)在能不能用同樣的方法？”
*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.
視頻在解釋特定領(lǐng)域的細(xì)節(jié)方面很糟糕，因?yàn)樗鼈冃枰吹臅r(shí)間太長(zhǎng)了。比如說(shuō)你想整合谷歌地圖的API。一旦你有了這樣的經(jīng)驗(yàn)，在GitHub上打開代碼，復(fù)制代碼，然后粘貼到一個(gè)新的項(xiàng)目中，可能只需要不到一分鐘的時(shí)間。而視頻則往往需要10-30分鐘才能重新觀看。
Strategies for Passing the Inflection Point as Efficiently as Possible
盡可能高效地度過(guò)拐點(diǎn)的策略。
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.
因?yàn)橥ㄟ^(guò)拐點(diǎn)是學(xué)習(xí)代碼最重要的部分，你應(yīng)該給自己設(shè)定一個(gè)盡可能順利的過(guò)程。這意味著你應(yīng)該在教程階段就開始準(zhǔn)備，并在這段時(shí)間保持正確的心態(tài)。
在教程階段，要從復(fù)習(xí)結(jié)構(gòu)化的材料中抽出時(shí)間來(lái)休息，并順便給自己一些挑戰(zhàn)題。
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.
每上一些課，就試著做一些你所關(guān)注的教程范圍之外的事情。如果你要經(jīng)歷的教程提供了 “挑戰(zhàn) “或 “自我指導(dǎo) “的片段，那么就把它們?nèi)孔鐾辍＝鉀Q無(wú)指導(dǎo)的挑戰(zhàn)會(huì)讓你獲得在沒有結(jié)構(gòu)化指導(dǎo)下做事的重要經(jīng)驗(yàn)。
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，我們經(jīng)常指導(dǎo)學(xué)生如何整合某些gems或使用提供的文檔做事情。很多學(xué)生不會(huì)簡(jiǎn)單地按照面向剛?cè)腴T的人的教程中解釋的說(shuō)明去做，而是會(huì)按照文檔去做，把教程作為后備。注意，文檔會(huì)把你當(dāng)成一個(gè)已經(jīng)過(guò)了拐點(diǎn)的開發(fā)者。在GitHub上自如地閱讀和關(guān)注文檔，會(huì)讓你在自己的時(shí)候更有優(yōu)勢(shì)。
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.
專注于本質(zhì)和使用重復(fù)。學(xué)習(xí)如何做一些常見的事情，比如從零開始旋轉(zhuǎn)一個(gè)應(yīng)用程序，將一個(gè)新的應(yīng)用程序推送到GitHub和Heroku，并在早期建立一個(gè)數(shù)據(jù)庫(kù)遷移。
Pushing through the inflection point can be challenging. Here are some pointers to get you through it:沖過(guò)拐點(diǎn)是很有挑戰(zhàn)性的。以下是一些讓你度過(guò)拐點(diǎn)的要點(diǎn)。
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.
要明白這是一個(gè)艱難的過(guò)程，對(duì)自己放寬心。另外，要設(shè)定現(xiàn)實(shí)的期望值。你不能把你看教程的 “超人 “級(jí)速度和你自己學(xué)習(xí)東西的 “蝸牛 “級(jí)速度相提并論。請(qǐng)記住，你正在學(xué)習(xí)很多東西，但在這個(gè)階段，你正在學(xué)習(xí)一種全新的技能，即自己摸索新事物。
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.
如果你正在與自信作斗爭(zhēng)，要i知道你的感覺是完全正常的。繼續(xù)努力。如果你繼續(xù)掙扎，試著和最近通過(guò)拐點(diǎn)的人交談。他們能夠體會(huì)到你所處的位置，并會(huì)向你保證，你所經(jīng)歷的只是暫時(shí)的。持續(xù)工作，但不要讓自己過(guò)度勞累。在這個(gè)階段，要知道你每天最多只能有6小時(shí)左右的工作效率。在精疲力竭的狀態(tài)下工作，只會(huì)延長(zhǎng)你在建立拐點(diǎn)前的時(shí)間。
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.
在這個(gè)階段，獲得信心的最好方法是戰(zhàn)勝你的任何疑慮。你的情緒可能開始感覺像過(guò)山車一樣。有時(shí)，你會(huì)覺得自己如火如荼，但在同一個(gè)問(wèn)題上掙扎了15個(gè)小時(shí)后，你的感覺就會(huì)截然相反，這是非常常見的。
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.
如果不知道某件事情會(huì)花你5分鐘還是5小時(shí)，可能會(huì)令人沮喪，但每次你發(fā)力并成功實(shí)現(xiàn)一個(gè)新功能時(shí)，自信的沖動(dòng)將是你所需要的一切。在沒有任何幫助的情況下解決了少量的困難問(wèn)題之后，你會(huì)沉迷于在舒適區(qū)之外構(gòu)建事物的感覺。
How to know when you’ve passed the inflection point
如何知道自己已經(jīng)過(guò)了拐點(diǎn)？
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.
拐點(diǎn)過(guò)程的最后階段是接受。接受軟件開發(fā)是一個(gè)不斷學(xué)習(xí)的過(guò)程。接受你已經(jīng)成功學(xué)會(huì)了所有東西的感覺只是意味著你應(yīng)該開始考慮解決更復(fù)雜的問(wèn)題。
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.
