9 Hard Lessons I Struggled to Learn During My 18 Years as a Software Developer

Here are nine of the best lessons I’ve picked up during my time as a developer

我从 14 岁就开始在父母的卧室里写代码。我通过非常慢的网络阅读任何我能够获得的东西。20 岁时，作为一名 Web 开发人员，我签了人生中的第一份劳动合同，我当时学的是 PHP 和 JavaScript。

我在这个领域花了 18 年时间，才发现编程只是职业的一小部分。即使是空闲时间出于兴趣，我也不会停止编码，但工作中还有很多其它事情。有些事情，开发者往往很晚才能领悟到，这也是为什么我想和大家分享我的经历，以及我觉得很重要的 9 个经验教训。

I started writing code in my bedroom at my parents’ house when I was 14 years old. I remember reading everything I could get my hands on via my very slow internet connection. Then when I was 20, I signed my first contract as a web developer, learning PHP and JavaScript at the time.

And it’s taken me over 18 years in this field to figure out that coding is just a fraction of our profession. I still enjoy it, mind you. I don’t think I’ll ever stop coding — even if it is for fun in my spare time — but there is so much more.

That is why I want to share with you my experience and what I think are nine lessons that developers tend to learn a bit too late in some situations.

1. 放下自负

开发者通常很自负。这是事实。

为什么呢？我认为，任何认真对待自己职业的人都会认为自己有点儿像艺术家。我们虽然不会在数百万人面前唱歌或者作画，但我们有时候在以一种非常优雅高效的方式编写代码、解决非常复杂的问题，我们同样为自己的工作感到自豪。

开发者和数学家一样，解决问题的方式都有点儿像艺术家。

正因如此，我们很维护自己的代码——就像熊妈妈照顾她的后代那样。亲手写下这些代码的我们，无法忍受别人对他指指点点。

但这对任何人都没有帮助。我们热爱自己的工作，但更重要的是我们正在解决问题。通过与其他人讨论我们的想法和方案，可能会出现更好的替代方案。这没有什么不对的。事实上，合作通常会产生最佳解决方案。

我见过各种各样自负的开发者，但没有见过哪种自负对开发者会有所帮助。

因此我的建议是：当你开始作为一名开发者工作时，请把你的自负抛掉，多听听其他人对你工作的看法。学会接受这样一个事实：更好的想法可能来自你的头脑之外，它们只会帮你提高自己的技能。只有倾听反馈，你才能赢。

1. Leave the Ego at the Door

Developers have huge egos. That’s a fact.

Why, though? I would argue that anyone who takes our profession seriously would consider themselves to be somewhat of an artist. Yes, we might not be singing in front of millions of people or painting the Mona Lisa, but we’re sometimes writing code that solves very complex problems in such an elegant and efficient way that we can’t help but be proud of our work.

I would argue that a developer is just as much of an artist as a mathematician is through the way they solve their problems.

Because of this, we tend to crawl around our code — just like a mama bear looking after her offspring. We made it, we love it, and we can’t stand when people start arguing about how wrong it may or may not be.

Then again, this is not helping anyone. We love our work, but we need to understand that we’re solving problems. By discussing our ideas and our solutions with others, better alternatives might arise. There is nothing wrong with that. In fact, cooperation is normally what yields the best solutions.

I’ve seen all kinds of egos in my time, and I’ve never seen a case where that ego worked in the developer’s favor.

So my advice here? Leave the ego at the door the minute you start working as a dev. Just swallow it and hear what others have to say about your work. Accept that better ideas might come from outside your head and that they will only help you improve your skills. You can only win if you listen to feedback.

2. 语言只是工具

如果你只懂 JavaScript，所有的问题都会像钉子一样。不要再称自己是一名 Java 开发者或 JavaScript 开发者。

由于某些语言的特性或语法，你可能会偏爱一些语言，这很正常。然而，如果你能学点别的东西，就会受益匪浅。学习新语言，尤其与你日常工作所用的范式不同的语言，会帮助你打开思路，发现解决问题的不同办法。

这一点我怎么强调也不过分：学习多种语言并使用一段时间，你会从中受益。

我几年前读过一本书《七周七语言》，展示了各种可用的选项，这让我思路大开。很多选择是我从来没有想到过的，因为我太专注于自己的日常任务和日常工具，从来没有停下来看看其它东西。

我们是开发者，知道如何通过代码来解决问题，但不要把自己放到一个盒子中，你会被那个盒子的大小所限制。看看那个盒子外面的东西，跳出那个盒子思考，试试其它选项、其它语言、其它解决问题的方法。即使只是一会儿，你也会带着新的想法和更大的心态做出更好的抉择。

2. Languages Are Tools. If You Only Know JavaScript, All Problems Will Look Like Nails

Stop calling yourself a Java developer or JavaScript developer. Yes, there might be languages that you favor because you like their features or syntax. That’s perfectly normal.

However, you’d benefit hugely if you were to learn something else for a while. Learning new languages — especially if they follow a different paradigm than the one you’re used to working with — will help you open up your mind to different ways of solving problems.

I can’t stress this enough: Learning multiple languages and using them for a while is going to benefit your skills. I read this book called Seven Languages in Seven Weeks several years ago and it opened up my mind to so many options just because it showed me the types of options available out there. Options I had never even considered because I was so focused on my daily tasks and daily tools that I never stopped to look anywhere else.

We’re developers. We know how to solve problems through code. Don’t put yourself inside a box. You’ll be limited by the size of that box. Look outside of it, think outside that box, check out other options, other languages, other ways of solving problems. Even if it’s for a little while, you’ll come back to your weapon of choice with fresh ideas and a bigger mindset.

3. 编程不需要记下所有的东西

有时候，开发新手认为他们需要把所有事情都记在心里，因此当他们意识到自己开始忘记如何写一个简单的for语句时，就会感到很糟糕。

这不仅是正常的，而且我认为这也是健康的。

有太多东西需要记忆了，但我们其实不需要记忆，我们只需要拥抱这样一个事实：互联网是另一个有力的工具。就像我们需要 IDE 一样，我们需要互联网来寻找答案。

我们都这样做，如果你一开始就感觉不好，就不要在这种感觉上浪费时间。只需要寻找你的答案并解决你的问题。

这样想一想：每一种语言都有一种类似但又稍有不同的观察者（Observer）模式的实现方式。你认为什么更现实？理解观察者模式有什么好处以及它能解决什么问题，还是记住你所使用的每一种语言如何实现它？

如果你知道它能解决你的问题，那么你就真的解决了你的问题。剩下的只是搜索实现它的最佳方法。

其它搜索也是一样。只专注于我们职业中重要的解决问题的方面，让谷歌帮你慢慢回忆。这才是正确的方式。

3. It’s Not About Memorizing Algorithms, It’s About Knowing How to Google Them Fast Enough

Sometimes new developers think they need to know everything by heart, so they start feeling bad the minute they realize they start forgetting how to write a simple for statement.

This is not only normal, but I would argue it’s also healthy.

There is simply too much out there to have it memorized. We don’t need to either. We need to embrace the fact that the internet is just another tool in our arsenal. Just like we need our IDE, we need internet access to look for answers.

We all do it, and if you’re just starting out and feeling bad about it, don’t waste time on that feeling. Just search for your answer and figure out your problem.

Think about it this way: Every language will have a similar yet slightly different way of implementing the Observer pattern. What do you think is more realistic? Understanding what the Observer pattern is good for and what kind of problems it solves or remembering how to implement it in every language you work with?

If you know it’ll solve your problem, then you literally solved your problem. The rest is just a matter of Googling the best way to implement it. That is not taking any credit away from your work or from your experience.

And the same goes for every other search you do. Just focus on the important, problem-solving side of our profession and let Google jog your memory. That’s what it’s there for.

4. 你将终身学习

或者说，“你应该终身学习”，这完全取决于你自己是否要跟上行业的最新发展。如果你想要保持相关性，那么你就必须一直学习。

技术在发展，语言在变化，这都很正常。诚然，有些生态系统比其它生态系统变化得更快，跟上他们的步伐似乎是一项艰巨的任务。但是，记住你只是一个人，不可能无所不知，只需专注于重要的事情。如果你必须学会一件事情，那么我的建议是学会如何学习。

这听起来很傻，但这可能是一名开发人员需要的首要技能。我们必须在快速学习新技能方面表现得更好。否则，你将陷入被标记为“过时”的风险。

同时，这也是本文提到的其它经验发挥作用的地方。变化、改变、新的挑战、没有自负——所有这些都会帮助你学习并拓展技能范围。你做的越多，效果就会越好。最终，你会发现所有的语言都是类似的。你将开始看到它们公共的根本，你将能够用其中任何一种语言工作。你所要做的就是阅读一些关键的东西。

你的整个职业生涯都要学习：

• 新语言

• 新（老）编程范式

• 新工作方法

• 解决问题的新方法

• 与团队互动的新方法

• 检查和测试代码的新方法

如果你还没有准备好永远当一名学生，那你需要考虑下这个职业是否适合你。请注意，我不是说“立刻辞职”，而是考虑下是否愿意开放思维来持续学习。

4. You’ll Be Learning Your Entire Career

Or rather “You should be learning your entire career.” It’s really up to you to decide whether or not you stay up to date with the latest developments in our industry. But if you want to stay relevant, then you’ll have to do it.

Technology evolves, languages evolve, and that’s completely normal. Granted, some ecosystems change faster than others and keeping up with them might seem like a titanic task. But focus on the important things, remember that you’re just a person and you can’t know everything. So if you have to learn one thing, my suggestion would be to learn how to learn.

I know it sounds silly, but that’s probably the #1 skill a developer needs. We have to get better at learning new skills fast. Otherwise, you run into the risk of being labeled as obsolete.

And here is where some of the other lessons in this article come into play. Variation, change, new challenges, no egos — those are all things that will help you learn and broaden the spectrum of your skillset. The more you do it, the better you’ll get at it. Eventually, you’ll realize all languages are similar. You’ll start seeing their common roots and you’ll be able to work with any of them. All you’ll have to do is read up on a few key things.

You’ll be learning your entire career about:

• New languages

• New (and old) programming paradigms

• New ways of working

• New ways of solving problems

• New ways of interacting with your teammates

• New ways of reviewing and testing your code

If you’re not ready to be the eternal student, consider if this is the career for you. Mind you, I don’t mean “Quit right now,” but rather consider if you’d be willing to open up your mind to be always learning.

5. 代码要解决问题，而非完美

这个问题我说过很多次，但是作为开发者，我们倾向于认为自己的代码在发布之前需要是完美的。虽然这并没有什么不对，但也可能是一个潜在的问题。

早期优化是一个问题，因为你可能在某件可能并不需要优化的事上花费大量时间，而且在某些情况下执行优化时，你会做出破坏功能的假设。

所以，把注意力集中在需要做的工作和你正在尝试解决的问题上，一旦问题修复，立马测试、迭代结果，看看团队对你的解决方案有什么想法——即使你已经看到了改进的方法。如果你需要花费两天以上的时间来让它完美，但它现在就可以投入生产，很有可能现在就应该投入生产。

归根结底，你是在解决问题。解决问题越快，对你的用户就越好。

5. Working Is Better Than Perfect

As a manager, I’ve heard myself say this too many times. But as developers, we tend to think our code needs to be perfect before release. And that’s not only untrue but potentially a problem.

Early optimization is an issue because you end up spending a lot of time and effort on something that perhaps doesn’t need to be optimized. And in some situations, when performing that optimization, you make assumptions that break the feature.

So focus on the work it needs to do and the problem you’re trying to solve. Once it’s fixed, test it out, iterate over the results, and see what your team thinks about your solution — even if you can already see ways to improve it. If you’re going to take two more days just to have it perfect, but it could go to production right now, chances are it should be in production right now.

At the end of the day, you’re solving a problem. The faster you solve it, the better it’ll be for your users.

6. 先让代码起作用，然后再优化

跟上面提到的观点一样，不要陷入早期优化的黑洞。

即使你认为你可以快速优化，但一旦你开始做，你就会发现时间膨胀效应是真的。

作为软件开发人员的首要任务是写一个功能或修复一个 bug 来让它起作用——无论代码看起来多丑或者你的方案可能多么低效。如果它起作用了，你就证明了它是可行的。这就成功了一半。

第二步是优化它。这是可选的一步。一些人容易忘记的细节，你可以用来优化代码的时间取决于很多变量，这些变量有时候不受你的控制。因此，集中精力让它起作用，然后再看看你是否真有时间来优化它。

早期优化意味着要边写代码边优化，这是一种危险的方式，因为优化时，我们都是在对执行时间、数据要求、内存需求以及其它我们尚未看到的因素进行假设，任何这样的假设都可能是错误的，最终会在你的逻辑中引入 bug。

想想 TDD 工作流：

1. 编写测试来理解你的功能需要做的所有事情（它将失败）。

2. 编写代码来通过测试。

3. 现在考虑优化你的代码。

步骤 2 是必需的。你首先需要考虑通过测试，也就是说让功能起作用。测试不关心你使用的算法或者你是否使用了三层嵌套的if语句。稍后才会做那些，可能是代码评审过程中的一部分。

6. Make It Work, Then Optimize

In line with some of the previous points, don’t fall into the early optimization black hole.

Even if you think you’ll do it quickly, once you come out of it — if ever — you’ll realize the time dilation effect is real.

Your first task as a software developer writing a new feature or fixing a bug is to make it work — no matter how ugly the code might look or how inefficient your solution might be. If it works, you’ve just proven it can be done. That’s half the battle right there.

The second step is to optimize it. This is an optional step. A detail that some people tend to forget. The time you have available to optimize your code depends on a lot of variables that sometimes are not under your control. So focus on making it work, then figure out if you actually have the time to optimize it.

Early optimization means optimizing your code while writing it. This is a dangerous practice because when we’re optimizing, we’re making assumptions about execution time, data requirements, memory needs, and other factors that we haven’t yet seen in action. Any such assumption might be wrong and you’ll end up introducing bugs into your logic.

Think about the TDD workflow:

1. Write your test to understand everything your feature needs to do (it’ll fail).

2. Write your code to have the test pass.

3. Worry about optimizing your code now.

Step 2 is a must. You first need to worry about passing the test, which translates to having the feature working. The test doesn’t care about the algorithm you used or if you used three nested if statements. That comes later, probably as part of a code review process.

7. 项目最后的 10%往往要花费 90%的时间

如果你一个人独自工作，这一点尤其重要，但是团队也会有这种细节计算失误的问题。

任何一个做完项目的人都会告诉你同样的事情（这不仅仅适用于我们行业）：你一开始会略过很多细节，最后才不得不考虑它们。

这很正常。我们都倾向于一开始专注于重大的功能，将比较小的细节或已知的 bug 留到最后。但是它们仍然需要解决，这就是额外 90%的工作。精细的工作比较花时间。你需要测试、修复、重新测试、写文档、执行用户培训、展示最终方案等等。

当然，这取决于你的环境、客户以及很多其它因素，但总会有一些东西。所以记住：当你认为你已经写完代码的时候，你很可能忘记了一些东西。

7. The Last 10% of a Project Takes 90% of the Time

This is especially important if you’re working alone, but teams also suffer from not having this little math detail correct.

Anyone who has finished a project will tell you the same thing (and honestly, this doesn’t just apply to our industry): You first rush through a lot of details just to have to take care of them at the end.

And it’s completely normal. We tend to focus on the big features first, leaving out smaller details or even known bugs to the end. But they need to be tackled nonetheless, which is where the extra 90% comes in. The fine work takes time. You need to test, fix, re-test, write documentation, perform user training, present the final solution, and more.

Of course, it’ll depend on your context, who your client is, and on a lot of other factors, but there is always something. So remember: When you think you’re almost done with your code, you’re probably forgetting about something.

8. 写过一次以上的代码，需要进行抽象

编码是关于抽象的行为。通过抽象通用逻辑，我们可以在其它地方复用它，但是一开始的时候，我们有时会注意不到抽象的重要性。

这是我个人的经验法则：如果我在两个地方写了相同的代码，那么就将它们放到一个函数中（或者一个方法，一个模块等等...你懂的）。

即使数字二对你来说很低，但是要考虑到将来你可能在其它地方使用抽象后的代码。而且通过把它放到一个常用的地方，你现在就可以使用它了。

抽象和规模有关。一段抽象的逻辑可以用很少的精力就被复用很多次，而到处复制粘贴代码虽然很容易，但用的越多需要的精力就越多。想想，如果你因为一个 bug 不得不改变一段逻辑，而它在你的项目中被重复了 5 次，会发生什么？你在修复这个 bug 时，会有 5 次机会犯错。

同样的逻辑也适用于你的日常任务。如果你发现自己做某件事一次以上，那么它可能就可以用某种方式自动化。这是效率的关键，因此不要仅仅在代码中寻找重复模式，在你的动作中也可以寻找重复模式。如果你能自动化完成一项每天需要 10 分钟的任务，你一个月就能节省 5 个小时。

8. If You’re Doing It More Than Once, It Needs to Be Abstracted

Coding is about abstracting behavior. By abstracting common logic, we can reuse it in other places, but in the beginning, we sometimes fail to notice the importance of abstraction.

This is my personal rule of thumb: If I have code repeated in two places, then it’s going into a function (or a method, a module… you get the idea).

Even if the number two seems low for you, consider that in the future you might find other places to use that abstracted code. And by moving it into a commonplace right then, you now have access to it.

Abstraction is about scale. A piece of abstracted logic can be used many times with minimum effort, while copy-pasting code all over the place — although easy to do — will require a lot more effort the more you use it. Consider what would happen if you had to change a piece of logic that was repeated five times across your project due to a bug. You’d literally have five chances to make a mistake while fixing it.

The same logic can be applied to your day-to-day tasks. If you find yourself doing something more than once, then it probably can be automated somehow. This is key to efficiency, so don’t only look for repeating patterns in your code but also in your actions. If you can automate a task that only takes you ten minutes a day, you’re saving five hours a month.

9. 副业项目不是必需的，但它们确实有帮助

有人说，如果你想要成为一名成功的开发人员，你需要创建副业项目。我并不认同这一点。我个人认识很多优秀的开发者，他们只在朝九晚五工作时写代码。

老实说，我很钦佩他们。他们能够在做好工作的同时，享受他们的空闲时间做其它事情。这绝对没有什么问题。

然而，有时候你需要一些额外的练习。有时候你觉得自己落后于其它同事。而这时，副业项目就会有所帮助。

我不是说构建一个新项目，让数以百万计的人使用，或者对产业进行革命性改变，当然如果你喜欢的话，就去做。但是我讨论的是拷贝其他人的项目，以便从中学习。我说的是通过解决 bug 或者增加额外功能来向其他人的项目做贡献。

你可以用副业项目来体验你不经常看到的地方。如果你每天写 8 小时的单元测试，也许可以考虑从头创建一些东西并且开发一些功能。如果你厌倦了独自工作，可以考虑为现有的项目做贡献，体验一下如何与其他人协调工作。

你可以使用副业项目来强化自己的薄弱环节，从而帮助你提高自己的技能。但同样，不要为了被认为是一名严肃的开发人员，而认为你需要为他们工作或者拥有一个绿色的 GitHub 活动图。那太傻了。

9. Side Projects Aren’t a Must, but They Do Help

Some people say that if you want to be a successful developer, you need to create side projects. I don’t think that’s true. I personally know a lot of great developers who only code when they’re working on their 9-5.

And honestly, I admire them. They’re able to be great at what they do while also enjoying their free time doing other things. There is absolutely nothing wrong with that.

However, sometimes you need the extra practice. Sometimes you feel like you’re falling behind other colleagues. And that is where side projects can help.

I’m not saying to build a new framework that gets used by millions and revolutionizes the industry. Go for it if you like, but I’m talking about copying others’ projects in order to learn from them. I’m talking about contributing to other people’s projects by solving bugs or adding extra features.

You can use side projects to experience aspects of development that you don’t get to see often. If you’re writing unit tests eight hours a day, maybe consider creating something from scratch and developing some features. If you’re tired of working alone, consider contributing to an existing project and experience what’s like to coordinate your work with others.

You can use side projects to strengthen whatever areas you identify as weak to help you improve your skills. But again, don’t think you need to work on them or have a green GitHub activity chart in order to be considered a serious developer. That’s just silly.

结论

这是我作为一名开发者在过去 18 年中学到的最难的 9 个经验教训，希望通过我的分享，能对你的新（或者已经从事的）职业有所启示。

你有想要分享的其它经验吗？请在下方留言。我很乐意向你学习。

Conclusion

Those are nine of the hardest lessons I’ve learned as a developer over the last 18 years. I hope that by sharing my experience, I was able to shed some light on your new (or already existing) career.

Do you have any other lessons you’ve learned that you’d like to share? Leave a comment below. I’d love to learn from you.

作者介绍

Fernando Doglio 在 Globant 担任技术经理，撰写关于技术、生活方式和个人事业等方面的文章。热爱学习，自认为是个永远的学生。在过去 14 年一直从事软件行业，因此对于其运作方式和技术变迁有比较好的理解。

学习一门新编程语言的6步

6 Stages of Learning a New Programming Language

Learning a new programming language is a process that allows you to learn critical life lessons.

文化 & 方法语言 & 开发编程语言方法论

有些人学习编程刚开始头脑发热，买了很多书，下载很多视频，收藏上百 G 的资料，没过几天，热情就褪去了，最后完成了从入门到放弃的全过程，究其原因主要是缺乏清晰的目标，没有方向，或者方向不明确。那么，我们应该要怎么学习才能掌握新的编程语言呢？让我们来看看 Jun Wu 是怎么做的。

学习一门新编程语言是一个让你能学到重要人生经验的过程。

我们要求程序员学习很多东西。随着大数据、人工智能、机器学习和云计算的普及，开发人员正努力克服系统开发中的大量挑战。我们所有的开发人员都不再仅仅是程序员了。藉由新的体系结构，我们可以熟练地学习我们系统的新基础设施设计。通过新的人工智能机器学习算法，我们在学习数学、统计学和函数式编程方面很熟练。有了大数据，我们就能擅长学习所有可用于分析数据的不同 API。

在某种程度上，我们作为开发人员的工作，正日益趋向多学科化。在这个蓬勃发展的多学科世界里，我们面临的最大挑战就是学习。

快速学习编程语言和深入了解不同学科是一项挑战。但这是一个非常有趣的过程。对我来说，正是学习，让我一次又一次地回到编程上来。

通过不断学习，你可以通过以下几种方式为你的生活增添光彩：

• 拜见该领域的新专家

• 在思考你的项目时，引入新的创造力

• 拓展你的职业前景

• 当你对目前工作变得自满时，克服无聊

• 在技术领域中保持领先地位

• 发现生活中的新激情

在我上一篇文章《如何快速学习一门新的编程语言》（How To Learn a New Programming Language Fast）中，我曾介绍了一个秘诀，如何能够以快速和敏捷的方式掌握许多编程语言。

在本文中，我将对学习过程进行拆分，这样你就可以对学习新的语言和概念有一个大致了解。有时候，学习一门新语言需要十年时间，就像徒步攀登高山一样。当你认为自己是 Python 大师的时候，你就会发现，你可以做更多其他种类的项目，这些项目将提高你对 Python 在特定目的上的使用水平，这些都是你以前从未想过的。

最终，一切都在掌控中。

一旦你成为专家，你就可以像体操运动员那样敏捷地编程，你的手指将会引路，而你的大脑是一个富有效率、充满创造性的司机。

你得到的回报并不是工作保障，而是生活上的安全感。

这是一种安全感，知道自己可以学到任何复杂的东西，可以克服解决问题的任何障碍。

在心理学中，知识的内化也包括行为的内化。通过知识的内化，你就创造了新的思维路径，这将得到以下结果：

1. 将知识从短期记忆转移到长期记忆。

2. 创建能够吸收新知识的知识路径。

3. 能够创建新的知识获取、知识保留和知识创建的行为。

We ask our programmers to learn a lot. With big data, AI-machine learning, and cloud computing, developers are trying to overcome a mountain of challenges in systems development. All of us who are developers are not just programmers anymore. With a new architecture, we are skilled in learning about new infrastructure designs for our systems. With new AI-machine learning algorithms, we are skilled in learning mathematics, statistics, and functional programming. With big data, we are skilled at learning all the different APIs available for analyzing our data.

In a way, our jobs as developers are becoming multidisciplinary. The biggest challenge that we have in thriving in this multidisciplinary world is learning.

It’s a challenge to learn programming languages fast and learn about different subjects deeply. But it’s such a fun process. For me, it is learning that keeps me coming back to programming again and again.

By learning all the time, you add to your life in the following ways:

• meeting new experts in the subject area

• bringing new creativity into thinking about your projects

• expanding your career prospects

• overcoming boredom when you become complacent at your current job

• staying current in the technology arena

• finding new passions in life

In my last article, I let you in on the secret that allowed me to learn many programming languages with speed and agility.

In this article, I want to break down the learning process so that you can have the big picture of learning new languages and concepts. Sometimes, it is a ten-year hike up the mountain of learning new languages. Just when you think you are a Python guru, you find out you can do even more projects in other varieties that will sharpen your usage of Python for specific purposes that you never thought of before.

In the end, it’s all in the fingers.

Once you are an expert, you will program with the agility of a gymnast, and your fingers will lead the way while your brain is an efficient and creative driver.

The reward is not job security, but life security.

It’s the security of knowing that you can learn anything complex. It’s the security of knowing that you can overcome any hurdles in problem-solving.

In psychology, internalizing knowledge also involves internalizing behaviors. By internalizing knowledge, you create new paths of thinking that will lead to the following:

1. transferring knowledge from short-term memory to long-term memory.

2. creating knowledge paths that will enable the absorption of new knowledge.

3. enabling the creation of new knowledge acquisition, knowledge retention, and knowledge creation behaviors.

一、先从关键要素和概念开始

最初，当你学习一门新的编程语言时，你想将学习重点放在那门编程语言的关键要素和概念上。列出一份这门编程语言的“核心”学习清单，然后一步一步地进行学习，这才是正确的方法。

知所知，知弗知

如果你想学习 Python，可以请 Python 专家或老师为你画一张“核心”学习的清单。你还可以通过学习一门课程来逐步了解 Python 编程的基础。搜索该编程语言的面试问题清单。

Starting With Key Elements and Concepts

Initially, when you learn a new programming language, you want to focus your study on the key elements and concepts of that programming language. Making a list of the “core” learnings for a programming language and going through them step by step is the way to go.

You don’t know what you don’t know

If you want to learn Python, ask an expert Python programmer or a teacher of Python to draw you a list of “core” learnings. You can also go through a course that will step you through the foundations of programming in Python. Search for a list of interview questions for that programming language.

二、进行发散，提出足够多的问题，找出正确答案

当你在学习编程语言中的“核心”概念时，你是否经常列出要提问的问题清单？我经常发现自己离题十万八千里。也就是说，我倾向于沿着我的思路，打破砂锅问到底。

所以我从关于 Python 的概念 A 开始，然后在 Google 上搜索一大堆关于 Python 中面向对象编程的内容，这就发现了一个以后可能要做的项目。

通过这一过程，我将语法约定、面向对象的编程概念和一系列常用的数据结构加入了书签。要问的正确问题可能就隐藏在我刚刚加入书签的其中一个网页中。通过浏览这些网站，我就将能够编制出一份关键问题的清单。

你要学会提出正确的问题来掌握核心技能。

Branching Out to Ask Enough Questions to Hit the Right Ones

When you are learning “core” concepts in a programming language, do you frequently make a list of questions to ask? I usually find that I digress a lot. That is, I tend to follow my train of thought down the line until the very end.

So I started with concept A about Python, then ended up googling a whole lot about object-oriented programming in Python, which led me to scope out a potential project to do later. Through this process, I bookmarked syntax conventions, object-oriented programming concepts, and a list of frequently used data structures. The right questions to ask are probably buried in one of these webpages that I just bookmarked. By reading through these websites, I will be able to compile a list of critical questions.

You learn to ask the right questions to learn the core skills.

三、养成每天学习的习惯

在我的职业生涯中，从学习许多编程语言中得到的一些最好的收获就是，我在生活中养成提高效率的习惯。我每天至少要花两个小时学习，这一习惯贯穿了我的职业生涯中。

每天两个小时看似不多，但一年下来，并坚持 15 年呢？那将是一个可观的数字：2x365x15=10950 小时！工作之余，就像健身训练一样，我还有一个长达 10950 小时的健脑训练，已持续 15 年，让我能够  得以学习到新的东西。

大部分时间，我只是在早上 5 点起床而不是早上 7 点，或者晚上 11 点而不是 9 点睡觉，这样我就有更多的时间用来学习。

你终将知晓，学习是有趣的，学习是在你自己的时间，学习是一种激情。

Building Habits to Learn Daily

Some of the best takeaways from learning many programming languages in my career are the habits of productivity that I’ve built into my life. Throughout my career, I dedicated at least two hours to learning every day. That is a lot of time: 2*365*15=10950 hours. Outside of work, just like a physical fitness routine, I have a mental fitness routine that spanned 10,950 hours over 15 years to allow me to learn new things. Most of the time, I just woke up at 5 a.m. instead of 7 a.m. or went to sleep at 11 p.m. instead of at 9 p.m. to give myself that added amount of time for learning.

You learn that learning is fun, learning is on your own time, and learning is a passion.

四、雪球效应

当你克服学习复杂概念和项目的复杂障碍后，你的信心就会像滚雪球那样越滚越大。我在工作中也目睹过。这并不完全是“流”的状态。它更像是一种激励你的能量，让你整个人都充满活力。这与喝咖啡、果汁或过健康的生活方式一样。汝欲乘长风，破万里浪兮。

这种激励能量转化为想要学习所有关于基础设施、设计和存储的知识之动力。这种动力转化为想要尝试不同的方式进行编程：命令性、事件驱动、流程驱动等。

这种激励能量转化为提出一些问题，比如“为什么我们要这样设计系统的这一部分？为什么我们要在这个项目使用这种编程语言？为什么我们要选择这种基础设施技术来扩展项目？为什么我们要用这种方式来对项目的这部分进行编码？为什么我们要这样设计错误处理？为什么我们要这样设计消息处理？”

问这些问题会让你找到解决问题的方法。在项目上工作，会让你不断学习如何正确回答“为什么……”这一系列问题，可以让你更快地变得精通起来。

你要有动力去问为什么，这样你才能找出答案。

The Snowball Effect

When you overcome the difficulty of learning complex concepts and complex hurdles of your projects, it has a snowball effect on your confidence. I’ve seen that with my work. It’s not exactly the state of “flow”. It’s more of a kind of motivational energy that perpetuates your entire life. It’s the same effect as drinking coffee, going on a juice cleanse or living a healthy lifestyle. You ride a kind of energy wave of learning.

This motivational energy translates to wanting to learn all about infrastructure, design, and storage. This motivational energy translates to wanting to try programming in different ways: functional, imperative, procedural, event-driven, flow-driven, etc.

This motivational energy translates to asking why questions such as “Why are we designing this part of the system this way? Why do we use this programming language for this project? Why do we select this infrastructure technology to scale up our project? Why are we coding this part of the project in this way? Why are we designing the error handling this way? Why are we designing the messaging handling this way?”

Asking these questions will lead you to find out the how. Working on projects that will consistently allow you to learn the how to the right questions of why will allow you to become proficient much faster.

You are motivated to ask the why that allows you to find out how.

五、养成反复实践的习惯，敢于冒险，勇于创新

你是自己编程生涯的主人。每个人对风险的接受程度并不一样。是编程，让我学会了在职业生涯中承担一定的风险。是编程，让我对自己解决问题的能力有了信心。是编程，让我学会了要对自己的创造力充满信心。

这一切都是因为我反复练习编程语言，而这些语言是我最熟悉的编程语言。反复练习未必枯燥乏味。事实上，要想真正精通一门编程语言，参加能让你学习编程语言不同部分的项目是必不可少的。

只有学会了不同解决问题的方法，你才能学会在解决问题的过程中发挥创造性。只有在考虑编写代码的最佳方式时，你才能提高代码的效率。只有通过反复的练习，你才能对代码片段产生“啊哈”的感觉，让你编写出最有效的代码。

通过学习来提高效率和创造性，你学会了精通。

Building a Habit of Repeated Practice With Risk-Taking and Creativity

You are the owner of your programming career. Everyone’s different in the amount of risk they are comfortable with. Programming allowed me to learn to take measured risks in my career. It taught me confidence in my problem-solving abilities. It taught me to be confident in my creativity.

This is all due to my repeated practice of the programming languages that I’m most comfortable programming in. Repeated practice does not have to be boring. In fact, to be truly proficient in a programming language, taking projects that will allow you to learn different parts of the programming language is essential.

You can only learn to be creative in problem-solving if you learn different ways to problem-solve. You can only be efficient with your code when you think about the best ways to write your code. Only through repeated practice can you have “ah-ha” moments about pieces of code that will allow you to come up with the most efficient and effective code.

You learn to be proficient by learning to be efficient and creative.

六、依靠你所知道的来实现跨越

最后，当你已经学会并练习了你所熟悉的编程语言时，你现在就可以在职业生涯中实现跨越了。这通常就是当你从初级开发人员晋升到高级开发人员的时候。

你将凭藉掌握“原因和做法”的知识在面试中取得了优秀的成绩，进入你的编程生涯的下一阶段。你可以用自己所熟悉的语言以一定的灵活性来编写代码。

你不再长时间进行工作了。你终于有时间和你朋友出游。你完成你的工作然后去休假。你开始指导初级程序员，你在工作中示范并使用最佳实践。你在架构会议上踊跃发言，并发表自己的观点。你在团队中是出了名的专家。

恭喜你！你已经将你所学的编程语言内化成了长期记忆。现在，它就像你的母语一样。

现在，你已经知道学习任何一门新的编程语言的过程了。你知道，在学习之旅中不能半途而废。花在编程上的每两个小时，就是你离开所爱的人的两个小时。因此，要让这两个小时变得有意义。让每一个两小时，每天成倍增长，直到你学会并内化了这些概念。

一旦你在完成足够多的项目之后变得精通了，你要知道，这远非结束。这是一个新的开始。从零开始，再次学习并内化新的编程语言和新的编程概念。一旦你在整个编程栈中增加了新的知识广度和深度，学习就会自然而然地流动起来，成为你生活的一部分。

你还在等什么呢？

Relying on What You Know to Leap Forward

Finally, as you have learned and practiced programming languages that you are comfortable with, you can now leap forward in your career. This is usually when you progress from a junior developer to a senior developer.

You will rely on all your knowledge of the why and how to ace those interviews to move to the next stage of your programming career. By now, some of this is already in your fingers. You can code with a certain agility in the languages that you are comfortable with.

You don’t work long hours anymore. You have time to go out with your friends. You finish your workday and take vacations. You mentor junior programmers. You set examples and use best practices at work. You speak up at architecture meetings and put in your two cents. You are known for being a certain kind of an expert on your team.

Congratulations, you have internalized the programming language that you’ve learned into long-term memory. It is now in your fingers.

Now you know the process of learning any new programming language. You know that you can’t quit in the middle. Every two hours spent programming are two hours you spent away from your loved ones. So make those two hours count. Allow those two hours to multiply each day until you’ve learned and internalized the concepts.

Once you are proficient after working on enough projects, know that this is not the end. It’s a new beginning. Start from zero to learn and internalize new programming languages and new programming concepts again. Once you increase new breadths and depths of your knowledge throughout your programming stack, learning will flow naturally and become a part of your life.

What are you waiting for?

作者介绍：

Jun Wu，是单亲妈妈，也是作家、技术专家和诗人。爱好广泛，涵盖了技术、人工智能、数据科学、领导力、心理学、育儿、教育、生活、工作和诗歌等等。

原文链接：

6 Stages of Learning a New Programming Language

Starting With Key Elements and Concepts

Initially, when you learn a new programming language, you want to focus your study on the key elements and concepts of that programming language. Making a list of the “core” learnings for a programming language and going through them step by step is the way to go.

You don’t know what you don’t know

If you want to learn Python, ask an expert Python programmer or a teacher of Python to draw you a list of “core” learnings. You can also go through a course that will step you through the foundations of programming in Python. Search for a list of interview questions for that programming language.

Branching Out to Ask Enough Questions to Hit the Right Ones

When you are learning “core” concepts in a programming language, do you frequently make a list of questions to ask? I usually find that I digress a lot. That is, I tend to follow my train of thought down the line until the very end.

So I started with concept A about Python, then ended up googling a whole lot about object-oriented programming in Python, which led me to scope out a potential project to do later. Through this process, I bookmarked syntax conventions, object-oriented programming concepts, and a list of frequently used data structures. The right questions to ask are probably buried in one of these webpages that I just bookmarked. By reading through these websites, I will be able to compile a list of critical questions.

You learn to ask the right questions to learn the core skills.

Building Habits to Learn Daily

Some of the best takeaways from learning many programming languages in my career are the habits of productivity that I’ve built into my life. Throughout my career, I dedicated at least two hours to learning every day. That is a lot of time: 2*365*15=10950 hours. Outside of work, just like a physical fitness routine, I have a mental fitness routine that spanned 10,950 hours over 15 years to allow me to learn new things. Most of the time, I just woke up at 5 a.m. instead of 7 a.m. or went to sleep at 11 p.m. instead of at 9 p.m. to give myself that added amount of time for learning.

You learn that learning is fun, learning is on your own time, and learning is a passion.

The Snowball Effect

When you overcome the difficulty of learning complex concepts and complex hurdles of your projects, it has a snowball effect on your confidence. I’ve seen that with my work. It’s not exactly the state of “flow”. It’s more of a kind of motivational energy that perpetuates your entire life. It’s the same effect as drinking coffee, going on a juice cleanse or living a healthy lifestyle. You ride a kind of energy wave of learning.

This motivational energy translates to wanting to learn all about infrastructure, design, and storage. This motivational energy translates to wanting to try programming in different ways: functional, imperative, procedural, event-driven, flow-driven, etc.

This motivational energy translates to asking why questions such as “Why are we designing this part of the system this way? Why do we use this programming language for this project? Why do we select this infrastructure technology to scale up our project? Why are we coding this part of the project in this way? Why are we designing the error handling this way? Why are we designing the messaging handling this way?”

Asking these questions will lead you to find out the how. Working on projects that will consistently allow you to learn the how to the right questions of why will allow you to become proficient much faster.

You are motivated to ask the why that allows you to find out how.

Building a Habit of Repeated Practice With Risk-Taking and Creativity

You are the owner of your programming career. Everyone’s different in the amount of risk they are comfortable with. Programming allowed me to learn to take measured risks in my career. It taught me confidence in my problem-solving abilities. It taught me to be confident in my creativity.

This is all due to my repeated practice of the programming languages that I’m most comfortable programming in. Repeated practice does not have to be boring. In fact, to be truly proficient in a programming language, taking projects that will allow you to learn different parts of the programming language is essential.

You can only learn to be creative in problem-solving if you learn different ways to problem-solve. You can only be efficient with your code when you think about the best ways to write your code. Only through repeated practice can you have “ah-ha” moments about pieces of code that will allow you to come up with the most efficient and effective code.

You learn to be proficient by learning to be efficient and creative.

Relying on What You Know to Leap Forward

Finally, as you have learned and practiced programming languages that you are comfortable with, you can now leap forward in your career. This is usually when you progress from a junior developer to a senior developer.

You will rely on all your knowledge of the why and how to ace those interviews to move to the next stage of your programming career. By now, some of this is already in your fingers. You can code with a certain agility in the languages that you are comfortable with.

You don’t work long hours anymore. You have time to go out with your friends. You finish your workday and take vacations. You mentor junior programmers. You set examples and use best practices at work. You speak up at architecture meetings and put in your two cents. You are known for being a certain kind of an expert on your team.

Congratulations, you have internalized the programming language that you’ve learned into long-term memory. It is now in your fingers.

Now you know the process of learning any new programming language. You know that you can’t quit in the middle. Every two hours spent programming are two hours you spent away from your loved ones. So make those two hours count. Allow those two hours to multiply each day until you’ve learned and internalized the concepts.

Once you are proficient after working on enough projects, know that this is not the end. It’s a new beginning. Start from zero to learn and internalize new programming languages and new programming concepts again. Once you increase new breadths and depths of your knowledge throughout your programming stack, learning will flow naturally and become a part of your life.

What are you waiting for?

原文链接：

https://medium.com/better-programming/6-stages-of-learning-a-new-programming-language-64b7e5335fb5