技能学习重要的古语

by Preethi Kasireddy

通过Preethi Kasireddy

学习方法：最重要的开发人员技能 (Learning How to Learn: The Most Important Developer Skill)

Being an efficient learner is at least as important as being an efficient coder.

成为高效的学习者至少与成为高效的编码者一样重要。

When you’re a developer, your job requires you to learn every single day — in spite of the constant lure of distractions like Hacker News, Twitter, Reddit, and Facebook.

当您是开发人员时，尽管不断吸引着诸如Hacker News，Twitter，Reddit和Facebook之类的干扰，您的工作仍需要每天学习。

You constantly encounter new code bases and new technical challenges at work. Home is no better, as you tackle open source repos and personal projects, each with their own processes and challenges to tackle.

您在工作中不断遇到新的代码库和新的技术挑战。当您处理开放源代码回购和个人项目(每个项目都有自己的流程和要解决的挑战)时，家就没有更好的选择。

The tech world changes fast, and it can feel like a full-time job just keeping up with the latest tools, languages and frameworks.

技术世界瞬息万变，只要跟上最新的工具，语言和框架，感觉就像是一份全职工作。

Long story short: learning is hard. Yet, we need to be able to learn quickly and effectively to thrive.

长话短说：学习很难。但是，我们需要能够快速有效地学习以蓬勃发展。

In the past year, I went from not knowing how to use the Chrome debugger to working as a software engineer for a leading cryptocurrency company. In the process, I rapidly learned a new skill (coding).

在过去的一年中，我从不知道如何使用Chrome调试器变成了一家领先的加密货币公司的软件工程师。在此过程中，我Swift学习了一项新技能(编码)。

That said, learning didn’t come easy for me.

也就是说，学习对我来说并不容易。

Honestly, every new concept was a struggle. There were too many unknowns, and too much uncertainty.

老实说，每个新概念都是一场斗争。未知数太多，不确定性也太多。

“How in the world is this sustainable?” I thought to myself.

“这在世界范围内可持续性如何？” 我心想。

“If this is what learning to code is supposed to feel like every day, I’ll be miserable. Is this really my passion?”

“如果这就是每天学习编码的感觉，那我将很痛苦。这真的是我的热情吗？”

“Wouldn’t this be easy for me if this was my passion? Do artists struggle to produce art? Do writers struggle to write a great book? Do athletes struggle to do well in a race? Are we supposed to struggle when we’re pursuing our passions?”

“如果这是我的热情，这对我来说难吗？艺术家会努力创作艺术吗？作家努力写一本好书吗？运动员在比赛中表现不好吗？我们追求激情时应该挣扎吗？”

“Shouldn’t I be finding pleasure in this?”

“我不应该为此感到高兴吗？”

它会变得更容易吗？ (Does it ever get easier?)

Yes, it does. A year later, tackling new programming concepts is still “difficult” in the sense that it requires discipline and hard work.

是的，它确实。一年后，从某种意义上说，要解决新的编程概念仍然“困难”，因为这需要纪律和艰苦的工作。

But it’s also become an enjoyable process, rather than an overwhelming one.

但这也已成为一个令人愉快的过程，而不是一个令人费解的过程。

What happened in the last year to make that shift possible?

去年发生了什么，使这种转变成为可能？

Simple: I changed my perspective on learning. What once struck me as “difficult” became “engaging.”

简单：我改变了对学习的看法。曾经让我感到“困难”的东西变成了“参与”。

In the rest of the post, I’ll explain how this transformation happened.

在文章的其余部分，我将解释这种转换是如何发生的。

刚刚开始 (Just getting started)

Learning to code is hardest at the beginning.

刚开始学习代码最困难。

For example, think about the first programming language you have to learn. You want to tackle the small things like syntax and style. But first, you have to comprehend difficult core concepts like values, types, operators, control flow, functions, higher order functions, scopes, closures, recursion, and so much more.

例如，考虑您必须学习的第一种编程语言。您想解决语法和样式之类的小问题。但是首先，您必须理解困难的核心概念，例如值，类型，运算符，控制流，函数，高阶函数，范围，闭包，递归等。

It feels like learning to juggle — but starting with eighteen pins instead of two.

感觉就像在学习杂耍一样，但是从18针而不是2针开始。

When I first learned about closures, it took me many weeks to truly understand the concept. I thought I understood it when I read about it. But when I tried to identify and use closures in practice, I’d find myself stumped.

当我第一次了解闭包时，我花了好几个星期才能真正理解这个概念。我以为我在读懂它的时候就明白了。但是，当我尝试在实践中识别并使用闭包时，我发现自己很沮丧。

That wasn’t unusual. I’ve observed this process as a teacher as well: new concepts don’t usually click the first time around. Or the second. Or even the tenth.

那并不稀奇。我也曾在老师那里观察过这个过程：新概念通常不会在第一次出现时就出现。还是第二个。甚至第十。

But for those who stick it out long enough, there will be a “breaking point” where things suddenly begin to make sense. In my example, I read literally every blog post, Stack Overflow post, and spec on the internet about closures.

但是对于那些坚持足够长的时间的人来说，会有一个“断点”，一切突然开始变得有意义。在我的示例中，我几乎阅读了每篇博客文章，Stack Overflow文章以及互联网上有关闭包的规范。

Everything I read and experimented with gave me a new perspective, until eventually, I had a 360-degree mental picture of how closures worked. Closures “clicked.”

我阅读和尝试过的所有内容都为我提供了新的视角，直到最终，我对关闭的工作原理有了360度的了解。闭包“被点击”。

Getting to a point where I felt this sense of understanding of closures was super important, because it was rewarding and encouraged me to go for more — including writing my own blog post that explained the concept.

达到一种让我感觉到这种对闭包的理解是非常重要的，因为这是有益的，并鼓励我去做更多的事情-包括撰写自己的博客文章来解释这个概念。

学习是一个过程，而不是目标 (Learning is a process, not a goal)

If we see learning as something we “have” to do, then we rush to get it done so that we can spend the rest of our time doing something more “fun” — something we “want” to do.

如果我们认为学习是我们“必须”要做的事情，那么我们会急于将其完成，以便我们可以将余下的时间花在做更多“有趣”的事情上-我们“想要”做的事情。

The problem is that it’s impossible to know everything about anything, so viewing learning as a race leads to burnout and disappointment.

问题在于不可能一无所知，因此将学习视为一场比赛会导致职业倦怠和失望。

Instead, if you see learning as a process, you’ll appreciate the small victories and insights along the way. This will drive you to constantly move forward.

相反，如果您将学习视为一个过程，那么您会欣赏到一路走来的小胜利和见解。这将使您不断前进。

You can compare it to exercise. Workouts hurt, and then the pain ends as soon as your workout ends. But it’s never gone. It’s waiting for you the next time you workout. Except each time, the pain becomes less piercing. You learn to cope with it. You become familiar with the pain, and it just becomes part of the routine. You are rewarded by better health and a better physique and are incentivized to keep going.

您可以将其与运动进行比较。锻炼会受伤，一旦锻炼结束，疼痛便会消失。但它永远不会消失。下次锻炼时，它在等您。除了每次，疼痛都不会刺痛。您学会应付。您会熟悉这种疼痛，而这只是日常工作的一部分。您会因身体健康和体质更好而得到奖励，并有动力继续前进。

Exercise creates a positive feedback loop:

练习会创建一个积极的反馈循环：

The same is true for learning.

学习也是如此。

将学习变成一个有趣的过程 (Turning learning into an engaging process)

Imagine building your very first web application.

想象一下构建您的第一个Web应用程序。

At first, all you’ve got is a daunting, blank text editor. The task of building the app seems almost insurmountable. You know nothing, and have so much to learn before you can make this happen.

首先，您所拥有的只是一个令人生畏的空白文本编辑器。构建应用程序的任务似乎几乎是无法克服的。您一无所知，在实现这一目标之前，还有很多东西要学习。

Thankfully, you decide to go for it anyway.

值得庆幸的是，您还是决定继续努力。

From then on, your main focus becomes to do one small step at a time.

从那时起，您的主要重点将变成每次只做一小步。

First, you create an idea. What will you build? Who’s the end user? What are the constraints?

首先，您创建一个想法。你会建造什么？谁是最终用户？有什么限制？

Second, you prototype or sketch out some rough designs for what you think it might look like. You ask your friends or the internet for feedback, and iterate to make it better.

其次，为您认为的外观设计原型或草绘一些粗略的设计。您要求您的朋友或互联网提供反馈，并不断进行改进。

Third, you research languages, tools, and frameworks that will work best with your requirements.

第三，您研究最适合您需求的语言，工具和框架。

Step by step you discipline your mind to channel all its energy towards this one goal.

您需要逐步训练自己的思想，以将所有精力用于这一目标。

Sometimes you’re writing code.

有时您正在编写代码。

More often than not you’re stalled at some bug or error.

通常，您会因某些错误或错误而停滞不前。

Sometimes you’re too tired to do any work, so you take a break.

有时您太累了无法做任何工作，因此请稍事休息。

Other times, you don’t feel like writing code. That’s okay. You spend your time researching or reading up on topics related to your project.

其他时候，您不想编写代码。没关系。您花时间研究或阅读与项目相关的主题。

Eventually, after a few weeks of hard work, you’ve built a foundation that can handle your big ideas. Suddenly, working on your app doesn’t feel as painful. You see the reward of the initial set of hard work, and now it’s just another piece of code you need to write or another bit of refactoring you need to do — which you’ve done 100s of times already, no problem.

最终，经过数周的努力，您已经建立了可以处理您的大创意的基础。突然之间，使用您的应用程序感觉并不那么痛苦。您会看到最初的辛苦工作所带来的回报，现在，这只是您需要编写的另一段代码或您需要执行的另一部分重构-您已经完成了100多次，没问题。

You turned what was once a daunting or dreadful activity into one that is complex and engaging.

您将曾经艰巨或可怕的活动变成了复杂而引人入胜的活动。

This is how we grow. This is how we get better. Whether it’s programming, dancing, running, or reading: it’s not easy, and there won’t ever be a time or place when you’re “done” learning.

这就是我们成长的方式。这就是我们变得更好的方式。无论是编程，跳舞，跑步还是读书：这都不容易，而且“完成”学习的时间或地点永远不会存在。

Instead, enjoy the process of investing your energy into something, and enjoy the pain that comes along with it. You’ll start to notice that you no longer describe it as “pain” — because what was once painful becomes a symbol for what’s next: a sense of personal accomplishment and self-satisfaction.

相反，请享受将精力投入到某物上的过程，并享受随之而来的痛苦。您将开始注意到，您不再将其描述为“痛苦”，因为曾经痛苦的事物变成了下一步的象征：个人成就感和自我满足感。

In other words, struggle and enjoyment will start to mean one and the same thing. Remember the cycle:

换句话说，奋斗和享受将开始意味着一回事。记住周期：

一种学习技术主题的方法 (One approach to learning technical topics)

Let me tell you a little about the learning process I follow. This isn’t the be-all-end-all of learning styles, so if something different works for you, please share it in the comments! In case you can’t tell, I’m a nerd about this stuff :)

让我告诉您一些我遵循的学习过程。这并不是学习风格的全部内容，因此，如果您有其他不同的选择，请在评论中分享！万一你不能告诉我，我很讨厌这个东西:)

Let’s use the process of learning the React.js library as an example.

让我们以学习React.js库的过程为例。

学习这个的动机是什么？ (What is the motivation for learning this?)

First step: I’d start with a Google search for the React.js documentation and read a bit about the background and motivation for the library.

第一步：首先从Google搜索React.js文档开始，然后阅读一些有关该库的背景和动机的信息。

Knowing the “why” behind any topic is incredibly helpful for framing the learning process. It answers questions like:

了解任何主题背后的“原因”对于框架学习过程非常有帮助。它回答如下问题：

How is this different from other solutions?这与其他解决方案有何不同？
How useful is this to me?这对我有多大用处？
What problems does this solution aim to solve?该解决方案旨在解决哪些问题？
Is this just a new shiny tool that’ll only be useful for a few months or will it fundamentally change the way I think and code?这只是一个仅会使用几个月的新工具，还是会从根本上改变我的思维方式和编码方式？

阅读和理解核心概念 (Reading and understanding core concepts)

Second, I’d read through any intro articles or examples provided in the docs.

其次，我会通读文档中提供的所有介绍性文章或示例。

Notice I’m not touching any code yet. Reading and sinking in the core concepts comes before hands-on experimentation. It’s incredibly important to do this because it lays the foundation for the rest of my learning.

注意，我还没有触摸任何代码。阅读和沉浸于核心概念之前，需要进行动手实验。这样做非常重要，因为它为我的其余学习奠定了基础。

Even though I might be able to get away with blindly using React.js without learning the core concepts, eventually it’ll catch up to me when I run into a bug.

即使我无需学习核心概念也可以盲目使用React.js，但最终当我遇到错误时，它将追上我。

第一次编码 (First time coding)

After spending some time on the above steps, I start to get the gist of what’s going on, or maybe even feel like I totally get it. Then it’s time to jump into some code.

花了一些时间完成上述步骤后，我开始了解正在发生的事情，甚至可能觉得自己完全明白了。然后是时候跳入一些代码了。

I typically try to build something really small with any new tool by following a video tutorial (e.g. on egghead.io) or a written tutorial before jumping into custom projects.

我通常会尝试使用视频教程(例如，在egghead.io上)或书面教程，然后再跳入自定义项目，使用任何新工具来构建很小的东西。

当你被卡住时 (When you get stuck)

…And then, inevitably, I get stuck.

…然后，不可避免地，我被卡住了。

Reading the docs seemed like a piece of cake, but actually using it in practice makes me realize I have no idea what’s going on.

阅读文档似乎简直是小菜一碟，但是实际上在实践中使用它使我意识到我不知道发生了什么。

This is when I start to feel that dreaded “just give up” feeling. But instead of giving in when the going gets tough, I remind myself that pain == gain. Turning back would be cowardly.

这是我开始感到恐惧的“只是放弃”的感觉。但是，我提醒自己，痛苦==收获，而不是在艰难时屈服。回头会很怯ward。

Here’s what I do instead:

这是我要做的：

I first narrow down and figure out what I’m actually stuck on — i.e. define the problem. Then I come up with a hypothesis for what I think could be the root cause or causes of the problem. Even if I have no idea, I just make a guess.我首先缩小范围，弄清楚我真正要坚持的目标，即定义问题。然后，我提出了一个假设，认为我可能是问题的根本原因。即使我不知道，我也只是猜测。
Then I step away from the problem and my computer and do something that relaxes me. This is incredibly hard to do when I’m so upset about the problem I’m stuck on, but letting go of the problem works wonders. (Ever notice how great ideas always strike in the shower?)然后，我离开问题和计算机，做些让我放松的事情。当我对遇到的问题感到非常沮丧时，这很难做到，但是放开这个问题会产生奇迹。 (您是否注意到总是有很多好主意？)
Now I try to debug with my hypothesis in mind. I get as far as I can on my hypothesis without looking for answers online — there’s something beautiful that happens when you try to solve problems by truly thinking deeply about them on your own first. Even if you’re going down the wrong path, the fact that you made the effort teaches you a lot and you remember the problem space much better next time you run into it.现在，我尝试着记住我的假设进行调试。在不在线寻找答案的情况下，我能尽我所能地提出假设-当您尝试通过真正地对问题进行深入思考来解决问题时，会发生一些美好的事情。即使您走错了道路，您所做的努力也会给您带来很多启发，并且下次您遇到问题时，您会更好地记住问题所在。
If my hypothesis leads to an answer, hooray! I’m done. If not, I Google search for documentation, blog posts, or Stack Overflow posts that could help me get closer to the answer.如果我的假设导致了答案，万岁！我受够了。如果没有，我会在Google上搜索文档，博客文章或Stack Overflow文章，以帮助我更接近答案。
While reading, I take notes on any and all pieces of information that could potentially be helpful.阅读时，我会记录所有可能有用的信息。
Still no solution? That’s fine. I’m sure I learned something valuable by reading through all that, even if it didn’t directly help me solve the problem at hand. Who knows when this knowledge might come in handy next time?还是没有解决办法？没关系。我确信通过阅读所有内容，我学到了一些有价值的东西，即使它并不能直接帮助我解决眼前的问题。谁知道下次该知识何时会派上用场？
At this point, if I’m truly stuck, I will either post a question on Stack Overflow or ask a co-worker or developer I know.在这一点上，如果我真的被卡住了，我会在Stack Overflow上发布问题，或者问一个我认识的同事或开发人员。
Otherwise, I rinse and repeat until I get closer to the final solution. At some point, the answer always comes.否则，我要冲洗并重复直到接近最终溶液。在某个时候，答案总是来的。

At times this process takes a few seconds, and other times it takes hours (or days). Either way, the process itself is incredibly beneficial to your skill set as a developer.

有时，此过程需要几秒钟，而其他时候则需要数小时(或几天)。无论哪种方式，该过程本身对您作为开发人员的技能都有极大的好处。

Getting stuck on a bug feels like stumbling in a dark tunnel looking for a ray of light. You eventually find it, but along the way you discover so much about the tunnel — and it’s knowledge about the “tunnel” that makes you strong as a coder.

卡在虫子上的感觉就像绊在一条黑暗的隧道里寻找一束光。您最终找到了它，但是一路上您发现了很多关于隧道的知识，而有关“隧道”的知识使您成为一名编码人员。

Think of debugging as a chance to explore rather than a detour from your goal, and it becomes much more fun.

将调试视为探索而不是偏离目标的机会，它会变得更加有趣。

冲洗并重复 (Rinse and repeat)

By this point in the learning process, I’ve built something small and tackled some small hurdles along the way. As you can see, it was a struggle — clearly, I need some more practice with the new tool.

至此，在学习过程中，我已经建立了一些小东西，并解决了一些小障碍。如您所见，这是一个挣扎-显然，我需要对新工具进行更多练习。

So, once again I try to build something on my own. Rather than jumping straight to a big custom project, I’ll look for a repo to base my application on.

因此，我再次尝试自行构建。与其直接跳到一个大型的自定义项目，不如寻找一个回购来构建我的应用程序。

For example, if there’s an online CRUD todos example (of course) using React.js, maybe I’ll build a different type of CRUD application. Just different enough to keep me engaged, but not so different as to make me discouraged if something goes wrong.

例如，如果有一个使用React.js的在线CRUD待办事项示例(当然)，也许我会构建另一种类型的CRUD应用程序。只是有所不同，足以让我参与其中，但又没有太大不同，以至于在出现问题时让我感到沮丧。

精通 (Mastery)

Mastery requires repetition, so I keep building more small projects until I feel like I’ve got the core concepts down.

精通需要重复，因此我会继续构建更多的小型项目，直到我觉得自己的核心概念有所欠缺。

Eventually, I begin to be able to piece things together on my own without constantly referencing documentation or examples. Only then do I finally adventure out and build something from scratch on my own.

最终，我开始能够自己将东西拼凑在一起，而无需不断引用文档或示例。只有到那时，我才最终冒险并自己从头开始构建一些东西。

Throughout this process, I aim to make the process fun and engaging. I’m constantly pushing myself to work on things that are harder than what I am capable of in the moment, but not throwing myself into the deep end so that I get discouraged and never finish.

在整个过程中，我的目标是使过程变得有趣且引人入胜。我一直在不断地努力去做那些比我目前所能做的事情更难的事情，但又不会使自己陷入困境，以至于我感到灰心和永不完结。

Finally, I make sure to step away as soon as I find myself getting too frustrated to enjoy the project.

最后，我确保一旦发现自己太沮丧而无法享受该项目，就一定要走开。

学习很有趣 (Learning is fun)

With some effort and structure, learning programming turns out to be incredibly fun. At first it’s incredibly complicated, and in my opinion that’s why so many people get scared away — not because it’s “boring,” but because it’s “hard.”

通过一些努力和结构，学习编程变得非常有趣。首先，它非常复杂，在我看来，这就是为什么这么多人被吓跑的原因-不是因为它“无聊”，而是因为它“艰巨”。

After you go through this learning process a few times, processing new information becomes a muscle memory. You don’t really think about it. You just learn to ride the pain wave and find joy in the reward.

在几次学习过程之后，处理新信息就成为一种肌肉记忆。你真的没有考虑过。您只需学会驾驭痛苦的浪潮，并从奖励中找到快乐。

Like magic, it becomes “easier” to learn.

就像魔术一样，学习变得“轻松”。

How do you tackle new subjects? Any insights or breakthrough moments you’d like to share? Please comment below. I love hearing new ideas :)

您如何应对新课题？您想分享什么见解或突破性的时刻？请在下面发表评论。我喜欢听到新的想法:)

翻译自: https://www.freecodecamp.org/news/learning-how-to-learn-the-most-important-developer-skill-7bf62dfaf67d/