技能學習重要的古語

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/

技能學習重要的古語

總結

以上是生活随笔為你收集整理的技能学习重要的古语_学习方法：最重要的开发人员技能的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。