The Key To Accelerating Your Coding Skills

原文連接：http://blog.thefirehoseproject.com/posts/learn-to-code-and-be-self-reliant/

附上我的認爲翻譯的比較好的一篇：https://www.jianshu.com/p/8806de7a7597建議看完英文版在看翻譯

accelerating : 加速

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：教授ruby語言的網站，做者的機構，
inflection：變音，轉調
inflection point：拐點
phase：相位，階段
operate：運轉，動手術；操做，經營
dramatically：戲劇性的，引人注目的
process：處理，過程
self-sufficient：自足；自負；傲慢
hand-holding：手把手的幫助
hold：持續；持有；保留；控制
frustrating：令人沮喪；使人泄氣
incredibly：難以置信的；很，極爲
empowering：受權
stuff：道具；材料
figure：圖形；任務；出現；描繪
steps to take：要採起的步驟

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.

goal：球門；進球得分；目標
application：申請表；實際應用；用途
although：儘管
primary：主要的
accelerate：使加快
gain：收穫；得到；獲利；利潤
ability：能力；力量
encounter：遇到
invaluable：沒法估計的，很是寶貴的
further：更遠的；增進

The Tutorial Phase (3-8 weeks of serious coding)

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.

tutorial ：adj家庭教師的；指導的；n.導師的我的指導
serious ：嚴肅的；認真的；莊重的；危急的；
domain-specific ：
domain ：領域
Examples include ：例如
extract ：摘錄
rails ：是一個用Ruby語言寫的開源Web開發框架
encompasses ：包括
protocol ：條約；協議；禮儀
unique ：惟一；獨特；獨一無二
certain ：無疑的；確定的；某一的
master ：vt控制；n主人；adj主要的；
broad ：adj寬的
strokes ：n一擊；vt輕撫
pieces ：n件；
apparent ：adj顯然的；表面上的
Over time ：隨着時間的過去
recognize ：認識
patterns : 模式
eventually ：終於；最後（側重動做和行爲的結果）
initially : 開始；最初
confusing ：莫名其妙的，難以理解
foreign ：外國的
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.

acquire : 得到vt；
attention ： 注意，專心，留意 n
detail ：細節，詳情
paying close attention ：關注
materials ：原料
tutorials ：指導
minor ：較小的adj；未成年人
typos ：打字稿
misspellings ：拼錯；拼錯的詞
crucial ：決定性的
dealing with ：處理
within ：在...以內；在內部；裏面
detail-oriented ：注重細節
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:

incredibly ：難以置信的；很；極爲
fact ：事實
matter ：物質；題材；困難；重要性 n；要緊，有關係 vi
inexperienceced ：經驗不足的，不熟練的
experienced ：有經驗的
alike ：一樣的，相像的

 

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

extract ：摘錄，提取
relevant : 有關的，切題的，有重大做用的
actually ：實際上
a while ：一下子
decode ：解碼
actually ：實際上
pinpoint : 精確查找
resolve ：是分解；解決
don`t just : 不僅是
frequently : 頻繁的
double-checking ：
conducting ：指揮家；組織

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.

instruction : 教授；操做指南；使用說明書
challenging : 富有挑戰性的
wrapping up ：結束
rapid ：急速的，快的
pace ： 踱步於，走動vt；步速；一步，步子
confident ：自信的
ditch : 在...上掘溝；開溝；溝壑
training ：培養；訓練
wheel ： 輪子
structured guidance : 結構化指導
dive into ：潛入
obtain ：得到
in search of : 尋求
full understanding : 充分理解
unfortunately : 不幸的
struggling ：奮鬥的
solution ： 解決 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.

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.

secret ： 祕密
journey ：旅程
envisioned ：envision 預想
eventually ：最後，終於
squared away ：Yep，got·em all squared away。（所有解決了-緋聞女孩第二季）
Experienced ：有經驗的
seek ：尋找
opportunity ：機會

The master has failed more times than the begginer has even tried.

 

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.

startle : 使嚇一跳
decipher : 破譯，辨認
pro ：同意者
feature ：特徵
confusing ：莫名其妙，難以理解的
reference ：參考，涉及，說起
patterns ：型，樣式，榜樣，典範，n；模仿，仿製vt
within ：在內部
seeking out ：
instruction ：

The Inflection Point (2-4 weeks with the right mentality)

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:

mentality ：心態，思想方法；智力，智能
frustrating ：
matters ：事項，事態
tutorials :
lined up : 排隊
tackle ：
outline : 輪廓；大綱
exactly ：精確的；準確的
prey ：捕食，掠奪，折磨
mentality ：心態；思想方法，智力，智能
frustrated ：挫敗的，失意的

During the inflection phase, you will be coding 10-20 times SLOWER than in the previous phase.

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.

mentality ：心態；思想方法，智力，智能
previous ：之前的；早先的
wonder ：對。。。感到疑惑vt；驚奇n
actually ：實際上
capable ：能幹的
insecurity ：不安全；危險
doubt ：懷疑
despite ：儘管，無論
accomplishing : 完成
rate : 比率，進度
reality ：現實；真實；實際
matter ： 要緊，有關係；重要性，物質，麻煩，困難，毛病
screeching ：尖叫，發動機嘯聲
putter ：置放者n；混過vt；閒蕩vi
procedural ：程序上的
about ：關於prep；附近的adj；大約adv；大體n

implement ：使生效vt；工具n
feature ：容貌n；起重要做用vi；以。。。爲特點vt
in time ：及時
accomplish ：完成，實現，作成功
critical ：批評的，愛挑剔的，決定性的，危險的，臨界的

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.

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.

footing ：立足處
known as ：被稱爲
maintenance ：維持；維護；報養；維修，贍養費
strive ：奮鬥，抗爭，努力
quit ：中止；放棄；離去
current ：如今的；最近的
expand ：擴張
upon ：在...之上；接近
capable ：能幹的；能勝任的；有才華的
database-driven application ：數據庫驅動的應用程序
stores ：儲存v；貯藏n；
retrieves ：檢索
mastering CRUD ：掌握 增刪改查
integrate ：使結合成爲總體
3rd party library ： 第三方庫
provided ：提供

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.

algorithm ：算法
data structures ：數據結構
superficial ：表面的；表皮的，膚淺的；缺少深度的
conquered ：征服
in addition ：另外
fundamental ：基本的adj；基本原則n
complex ：複雜的
challenge ：挑戰
implement ：使生效vt，執行；工具n
reverse ：使翻轉
linked ：連接
leverage ：力量，影響；促使...改變vt；槓桿做用，槓桿的力量n
recursive ：遞歸的
iterative ：迭代的
manipulaton ：操做
performance ：演出；執行；表現；性能
implication ：暗示；牽連；捲入；含義n
decision ：決定，決心，判斷；結果
traditional ：
exclusively ：專門地；專有的
universities ：
generally ：通常地, 一般, 大致上, 普遍地, 廣泛地adv
industry ：工業

 

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.

technical ：技術的；應用科學的；專業的adj
interviews ：面談，面試
assume ：假定，採起，承擔vt；裝腔做勢vi
given ：考慮到prep，假若，假定；規定的adj
evaluating ：評估
generally ：通常地, 一般, 大致上, 普遍地, 廣泛地
topic ：題目，論題，話題
mention ：提及；提到，談到；說起，討論

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.

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.

kingdom ：王國
intersect ：橫斷，橫切；相交
complex ：複雜的
context ：上下文；環境
advanced ：超前的，先進的adj
heart ：要點；心臟n；鼓勵vt
professional ：職業的adj，專業的

Consequences of the Inflection Point

The biggest consequence of the inflection point will sound a bit counterintuitive when you first hear it. Take a deep breath in:

When learning to code, domain-specific knowledge doesn’t matter in the grand scheme of things.

Yup. I’m not joking– it really doesn’t matter that much at all. Once you pass the inflection point, these concepts will fluidly translate with just a week or two of tutorials, maybe even days!

What ultimately really matters is:

• You have a solid grasp on a web development framework
• You have a solid grasp on writing algorithmically complex code in any programming language

consequence ：結果，後果n  /'kɒnsɪkw(ə)ns/
counterintuitive ：違反直覺的adj.
breath ：呼吸
grand ：宏偉的，豪華adj；大鋼琴n
scheme ：vt. & vi. 策劃; 圖謀；n. 陰謀, 詭計，計劃, 方案
Yup ：是的【俚】
joking ：開玩笑的
concept ：概念，觀念，想法
fluidly ：流暢的
translate ：vt. & vi. 翻譯; 解釋; 轉化
tutorial ：adj. 家庭教師的;指導教師的;家庭教師職責的，輔導的;指導的；n. 導師的個別指導
ultimately ：最後，最終
solid ：固體，實心，結實，穩定，可靠adj；固體n
grasp ：理解，控制，抓住n；抓住，領會vt
framework ：架構，結構n
algorithmically ：算法。在算法上
complex ：

 

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

While I was working at PayPal, my team hired a Senior Rails Developer who had no experience in Rails– he had been coding a lot in Python, LISP, and Perl. Within a couple of days, he was already making a big impact. And within weeks: a huge impact. He quickly rose to become the technical team lead and was one of the best hiring decisions I’ve ever been involved in.

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.

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.

hiring ：僱用，租用n&v
hired ：
senior ：年長的，資深的adj
rails ：是一個用Ruby語言寫的開源Web開發框架
couple ：一對 
a couple of days ：幾天，一兩天
impact ：效果，影響n；衝擊vi；撞擊vt
huge ：巨大的，龐大的
rose ：玫瑰；起立；增長；應付，勝任；起身
technical ：技術的
decision ：決定，果斷
be involved in ：涉及，與什麼有關聯

sweat ：流出，使出汗，使幹苦活
stack ：堆，使堆疊
rise ：上升
lastest ：最新，最近，最遲
fad ：一時的愛好；時尚
singular ：單數的；單一的，突出的，卓越的，非凡的
annihilate ：殲滅，消滅，完全擊潰；毀滅

self-reliant ：依靠本身的，獨立的
reliant ：依賴的，可靠的，
structure ：結構，構造n；組織，安排，構造，制定vt
guidance ：指導，引導n
majority ：多數n；成年【律】  /mə'dʒɒrɪtɪ/
internet ：
various ：各類各樣的；多方面的adj
meterial ：材料
immediately ：當即，立刻adv；直接的
figure ：圖形，數字體型，人物n；出現，計算vi；描繪，認爲，象徵vt
essence ：本質，實質
unstoppable ：沒法中止的，沒法阻止的adj

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.

during ：在...的時候
reference ：說起，涉及，參考，查閱n
meterial ：
simalar ：類似的，相似的
commit ：交付vt；犯罪，犯錯，承諾
details ：
feature ：
revisit ：
approach ：方法，方式；靠近，接近，通路，入口n；接洽，交涉，着手處理vt；接近，走進，靠近vt&vi
suck ：吸；吮vt&vi；舔vi
suck at ：爛，作的很差；Wow,You suck at this too；Girl，you suck at this game
視頻很難解釋特定領域的細節
darned ：可恨的，豈有此理的adj&adv；darn的過去式（織補）
integrate ：使結合成爲總體vt；使（融入）vt&vi
experienced ：
on the other hand ：在另外一方面

 

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.

strategy ：戰略
efficiently ：效率高地，有效的adv
set...up ：創建
smooth ：光滑的，順利的，平穩的adj；使優雅vt使光滑
preparing ：準備的，預備的adj
tutorial ：/tjuː'tɔːrɪəl/
maintain ：保持；繼續vt；報養，維護；供給贍養
mindset ：心態，傾向，習慣，精神狀態
period ：（一段）時間，時期；句號

 

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

break ：休息；中斷；突變
going over ：完全審查 
go over ：檢查，重作
structured ：
scope ：視野，眼界
go through ：完成，作完，檢查，經受，經過
provide ：規定，提供，撫養，做準備
self-directed ：自我導向
integrate ：/'ɪntɪgreɪt/
gem ：是ruby庫和程序的標準包
provided ：
geared ：面向；連接的的adj；geared motor減速電動機；
back-up ：備份
treat ：招待，對待，看待，款待  n&vt&vi
leg up ：聯繫上下文，這個話的意思，應該是「在你獨自開發的時候祝你一臂（腿）之力」
essentials ：概要
repetition ：重複，反覆，重複的事，副本
spinning-up ：
scratch ：抓痕，抓，  from scratch ：從頭作起，從頭開始
Heroku ：一個支持多種編程語言的雲平臺
migration ：遷移

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.

realistic ：現實的，實際可行的
expectation ：預料，指望
compare ：比較，對照
snail ：蝸牛，遲鈍的人；緩慢移動
keep in mind ：記住，牢記
plenty ：豐富，大量n；足夠的adj
brand ：商標，牌子n；打烙印vt
figuring ：
struggling ：掙扎，奮鬥 struggle
self-confidence ：自信
completely ：完整的
struggle ：
relate ：vt&vi （把...）聯繫起來；vt講述，敘述
assure ：保證，擔保vt；使確信，弄清楚
experience ：經驗
temporary ：臨時的
consistently ：一向的，堅持的，固守的adv
productive ：多產的，富饒的，富有成效的；有益的adj
exhausted ：/ɪgˈzɔ:stɪd/ 耗盡的，用完的，筋疲力盡的adj
prolong ：拖延，延長vt

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.

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.

gain ：收穫，增長
doubts ：懷疑
emotions ：情感，情緒n
roller ：滾壓機，巨浪
coaster ：沿岸貿易船；杯託，小托盤，雪橇
roller coaster ：過山車
struggling ：奮鬥，掙扎
polar : 兩極的
opposite :相反的

frustrating : 使人泄氣，令人沮喪，產生挫折
implement : 使生效，貫徹，執行vt；工具n
feature : 容貌，特徵n；其重要做用vi；以...爲特點vt
rush :匆促；急流；急需的adj；突襲，匆忙作的vt；衝；闖vi
addicted : 上了癮的，入了迷的，沉溺於某種（尤爲是不良的）嗜好

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.

final ：最後的
acceptance ：接受，承認，同意n
process ：處理，加工vt；過程n
continuous ：連續的adj
complicated ：結構複雜的adj
conversation ：交談，談話，回話n

 

 

AuthorKen Mazaika

Ken Mazaika is the CTO and co-founder at Firehose. Previously, he was a tech lead at WHERE.com (acquired by PayPal) and a member of the PayPal/eBay development team in Boston.

previously ：先前adv
tech ：技術
acquired ：後天的，已經得到的，已成習慣的，adj；取得，捕獲v

 

下一篇：Teach Yourself Programming in Ten Years