成为杰出人物的路线图_如何成为杰出的初级开发人员

成为杰出人物的路线图

If you're reading this, you probably just got your first tech job — so congratulations! Getting the first job is one of the hardest things you'll do in tech. There's so much work and effort already behind you.

如果您正在阅读本文，那么您可能刚刚获得了第一份技术工作-恭喜！ 获得第一份工作是您在技术领域最难的事情之一。 您背后已经有很多工作和努力。

Or maybe you don't have your first job yet, but you want to know what you should expect.

也许您还没有第一份工作，但是您想知道您应该期待什么。

Either way, in this post I will address the common worries and questions about what to expect on the job, and how to succeed in a career as a developer.

无论哪种方式，在这篇文章中，我都将解决一些常见的忧虑和疑问，包括对工作的期望以及如何在开发人员的职业生涯中取得成功。

Here's what we'll cover:

这是我们要介绍的内容：

1. What to expect on the job (early days/weeks)
   对工作的期望(前几天/周)
2. Your short to medium-term plan
   您的短期到中期计划
3. The mindset for success
   成功的心态
4. How to be an outstanding new developer
   如何成为杰出的新开发者

对工作的期望 (What to expect on the job)

The day finally arrives. You walk into the office (or join the morning team standup remotely) for the first time as a new developer. Even if you're nervous, try to remember and take in your first day. It's an exciting time!

天终于到了。 您第一次以新开发人员的身份走进办公室(或远程加入上午小组的代表)。 即使您感到紧张，也请记住并度过第一天。 这是一个令人兴奋的时刻！

Your first day will likely be logistical things: setting up your computer, orientations or trainings, and HR logistics (banking information, insurance, and so on).

您的第一天可能是后勤工作：设置计算机，入职培训或培训以及人力资源后勤(银行信息，保险等)。

However, it is becoming a common practice to have new developers do a push to production on your first day. It's usually something very small—like adding your name and photo or fixing a typo on the company website. This tests that your computer setup is good to go, and it also gives you a very quick win and lets you join the rest of the team shipping software.

但是，让新开发人员在第一天开始进行生产就成为一种常见的做法。 它通常很小，例如在公司网站上添加您的姓名和照片或修正错字。 这可以测试您的计算机设置是否合适，还可以使您快速获胜，并让您加入团队运输软件的其余部分。

贵公司希望您成功 (Your company wants you to succeed)

As a new developer, the company that hired you knows the limitations of your current knowledge and skills. They understand they'll need to invest significant time into your growth to teach and train you.

作为新开发人员，雇用您的公司知道您当前知识和技能的局限性。 他们了解他们将需要花费大量时间来促进您的成长，以教导和培训您。

Remember, this company wants you to succeed! They're on your side. This company went through enormous effort to find, interview, and hire you. It's a costly process from both a time and money perspective for the company. They're not going to hang you out to dry—that would be a poor way to treat their investment in you.

请记住，这家公司希望您成功！ 他们在你身边。 该公司付出了巨大的努力来寻找，采访和雇用您。 从时间和金钱的角度来看，这对于公司来说都是一个昂贵的过程。 他们不会让您干dry的，这是对待他们对您的投资的糟糕方法。

There are some skills that you bring to the table at the start, but there are some skills that are difficult (though not impossible) to acquire outside of a professional work environment.

首先，您需要掌握一些技能，但是有些技能在专业工作环境之外很难(虽然不是不可能)掌握。

Since this is your first job, it's likely you've never collaborated with a large team using source control or maintained production applications—and that's ok! These skills are easier to pick up in a production environment.

由于这是您的第一份工作，因此您可能从未与使用源代码控制或维护的生产应用程序的大型团队合作过-没关系！ 这些技能在生产环境中更容易掌握。

您的头几天/周 (Your first days/weeks)

Once your computer is setup and you have access to all of the tools that you need, your first tasks will likely be small feature improvements or fixing small bugs—just things to get your wet feet across the various projects.

设置好计算机并可以使用所需的所有工具后，您的首要任务可能是小功能改进或修复小错误-只是使您在各种项目中步履蹒跚而已。

Outside of pure technical knowledge, in every company there is domain knowledge or "business logic" (what the company's products or services do and how they do it) that you'll need to pick up.

除了纯粹的技术知识，在每家公司中，您都需要掌握领域知识或“业务逻辑”(公司产品或服务的功能以及它们的工作方式)。

If the company has multiple products, they may give you small tasks in each codebase to begin exploring those products. It's also likely that they will assign another person on the team to pair up with you—or at least be available for questions you have throughout the early weeks.

如果公司有多个产品，他们可能会在每个代码库中给您一些小任务，以开始探索这些产品。 他们也有可能会指派团队中的另一个人与您配对-或至少在整个星期的初期都可以解决您的问题。

In these early days and weeks you only have one goal: learn, learn, learn.

在这些早期和几周中，您只有一个目标： 学习，学习，学习。

Learn about the technology you're using, learn about the company and how it works, and learn how to work with your teammates. Your work output is not important at this point—your rate of growth is.

了解您正在使用的技术，了解公司及其运作方式，并了解如何与队友一起工作。 此时的工作成果并不重要，您的增长率才是重要的。

深入生产代码库 (Diving into a production codebase)

As you begin working your way through the various codebases at your company, you'll likely feel a like a fish out of water. This is totally normal—it's much easier to write code than it is to read it.

当您开始研究公司的各种代码库时，您可能会像鱼在水里。 这是完全正常的-编写代码比阅读代码要容易得多。

A production codebase is very different from the tutorials you've been working through or the toy projects you've been learning with.

生产代码库与您正在研究的教程或您正在学习的玩具项目完全不同。

For one, this codebase has likely existed for many years, and been worked on by many different people—each with their own style and each of them making their own mistakes.

一方面，这个代码库可能已经存在了很多年，并且由许多不同的人进行了研究-每个人都有自己的风格，每个人都犯错。

It's also likely there are many more software packages or plugins injected into this application than you have come across before. All of the convenient shortcuts or edge cases that were ignored in a tutorial (like error handling) have to be handled here—this is a real app.

还可能有比以前遇到的更多的软件包或插件注入到此应用程序中。 必须在此处处理在教程中忽略的所有便捷快捷方式或极端情况(例如错误处理)，这是一个真实的应用程序。

This can be overwhelming at first, but reading other people's code is a skill you have to develop, and it's one you'll use your entire career (and at the end of this post I'll give you some tips to help with that).

起初这可能会让人不知所措，但是阅读别人的代码是您必须发展的一项技能，这是您将整个职业生涯都投入的一种技能(在本文的结尾，我将为您提供一些技巧来帮助您) 。

In the end, don't be afraid to ask for help! Your teammates are there to support you, and at some point in the past they had to ask the same exact questions.

最后，不要害怕寻求帮助！ 您的队友在那里为您提供支持，而在过去的某个时候，他们不得不问同样的问题。

新的开发者期望 (New developer expectations)

First things first: this company is not expecting you to jump in and start knocking out features. They know you'll need time to develop skills you don't have yet, understand the codebases, and learn how to work with the team effectively.

首先，这家公司不希望您加入并开始淘汰功能。 他们知道您将需要时间来开发尚未具备的技能，了解代码库并学习如何与团队有效地合作。

It's likely your boss will meet with you and create a 30/60/90 day plan. If they don't do this—ask! Any supervisor will appreciate you owning your job and job expectations.

您的老板很可能会与您会面并制定30/60/90天计划。 如果他们不这样做，请询问！ 任何主管都会感谢您拥有自己的工作和期望。

In the first 30 days, you'll likely just be doing small feature improvements and small bug fixes—just things to get to know the company's products and codebases. At 60 days, it's likely you'll be doing slightly larger features and bug fixes. By 90 days, the scope will have grown a little more, but they still won't expect you to own and drive large features forward yourself.

在最初的30天里，您可能只会做一些小的功能改进和小的错误修复，而这只是了解公司产品和代码库的事情。 60天后，您可能会做一些更大的功能和错误修复。 到90天时，范围将进一步扩大，但是他们仍然不会期望您拥有并推动自己的大型功能。

Ultimately, the company just wants you to continue to learn and absorb the information around you. You're not going to know everything going in, or after 90 days, and that's ok! Take it a day at a time.

最终，公司只希望您继续学习并吸收周围的信息。 您将不会知道一切都在进行中，或者90天之后，这没关系！ 一次服用一天。

新的开发人员心态 (The new developer mindset)

Walking into a new company, there are many things you can't control, but there is one very important thing you can: your mindset. Your daily thoughts, practices, and how you internalize what happens around you will determine your success.

走进一家新公司，有很多事情是您无法控制的，但是有一件非常重要的事情：您的心态。 您的日常思想，实践以及如何内部化周围发生的事情将决定您的成功。

At times you'll be confused, at times you'll feel overwhelmed, and at times you'll even doubt if you can do this (I did). How you internalize these thoughts matters. Remember, this isn't unique to you—every new developer has faced this. Keep your mind in check and you'll push through.

有时您会感到困惑，有时会感到不知所措，有时甚至会怀疑是否可以这样做(我做到了)。 您如何内部化这些想法很重要。 请记住，这并不是您独有的-每个新开发人员都面临过这一问题。 随时检查，您将继续努力。

When you run into something confusing or frustrating, re-position your mind: this obstacle is a learning opportunity.

当您遇到令人困惑或沮丧的事情时，请重新定位您的思想： 这个障碍是学习的机会。

It's an opportunity to understand something new and grow. It sucks, it feels bad, but soon after this you will be a better developer. And this will happen a lot—that's just the reality of being new to something.

这是一个了解新事物并不断发展的机会。 很烂，感觉很糟糕，但是此后不久，您将成为更好的开发人员。 这将发生很多，这仅仅是成为新事物的现实。

Instead of internalizing:

而不是内部化：

"I got stuck 10 times today."

“我今天被卡住了十次。”

Try instead:

请尝试：

"I had 10 opportunities to learn today."

“我今天有10个学习的机会。”

It's a powerful shift, and it will be obvious to your teammates and in your job performance.

这是一次强有力的转变，这对于您的队友和您的工作表现将是显而易见的。

Staying on top of your mind and not allowing the feeling of defeat to creep in will not only help you perform better in the situation, but it also increases the knowledge and skill you leave the situation with. Take a deep breath, take a break, ask for help—but keep pushing through.

保持头脑清醒，不让失败感蔓延，不仅会帮助您在这种情况下表现更好，而且还会增加您随处所处的知识和技能。 深吸一口气，休息一下，寻求帮助，但要继续努力。

And then at the end of the day: shrug it all off. Drop it on the ground when you leave the office or close your computer for the day. Start the next day fresh and ready for its own adventures.

然后在一天结束时：全部摆脱。 离开办公室或一天中关闭计算机时，将其放在地面上。 第二天重新开始，为自己的冒险做好准备。

Also, remember to celebrate the little wins along the way! Those small wins will stack up and become a large mountain of success over time.

另外，请记住要庆祝一路上的小胜利！ 随着时间的流逝，那些小的胜利将堆积起来，成为成功的大山。

Here's another important thing to remember: give yourself the freedom to make mistakes. You're going to break production, you're going to make some bad database updates (I definitely have)—it's recoverable, it's not the end of the world or your job, and any experienced developer has done it. It's just a part of the process.

这里要记住的另一件事是： 给自己自由犯错。 您将要中断生产，将进行一些错误的数据库更新(我肯定有)—它可以恢复，不是世界末日或您的工作，而且任何有经验的开发人员都可以做到。 这只是过程的一部分。

作为新开发人员的最大技能 (Your greatest skill as a new developer)

You may not realize it, but your greatest skill as a new developer is that you've learned how to learn.

您可能没有意识到，但是作为一名新开发人员，您最大的技能就是您已经学会了学习。

You've learned how to take something hard, complex, obscure, and break it into pieces—work through it step by step.

您已经学会了如何处理困难，复杂，晦涩的事物，并将其分解成碎片-逐步进行操作。

More than learning JavaScript, React, Ruby, or anything else, the best thing you've learned is how to teach yourself. Take this practiced skill you have and show up with it every single day.

除了学习JavaScript，React，Ruby或其他以外，您所学到的最好的东西就是如何自学。 掌握您已掌握的这项技能，并每天展示。

拥有自己的成长-没有人会。 (Own your growth—no one else will.)

This might be the most important statement for a developer at any stage of their career: your career is your own. You have to own it, and you have to own your growth.

对于开发人员在其职业生涯的任何阶段，这可能都是最重要的声明： 您的职业属于您自己。 您必须拥有它，并且必须拥有自己的成长。

Sometimes the your company, job position, or boss will help facilitate your growth, but in the end, it's up to you.

有时候，您的公司，职位或老板将有助于促进您的成长，但最终取决于您。

Most companies have some kind of scheduled review process—possibly quarterly or yearly. If they do, great, but if they don't, own your growth! Ask your supervisor regularly for feedback, and do what they say. If someone mentions something you've never heard of, ask them about it or go do your own research it!

大多数公司都有某种计划的审查流程-可能每季度或每年。 如果他们做到了，那就太好了，但如果没有，那就拥有自己的成长！ 定期询问您的主管以获取反馈，并按他们说的做。 如果有人提到您从未听说过的内容，请向他们询问或自行进行研究！

“微小收益的力量” ("The Power of Tiny Gains")

One of my favorite books, Atomic Habits by James Clear, has a great diagram titled "The Power of Tiny Gains." It's a simple diagram. It shows the difference between a 1% improvement and 1% decline every day.

我最喜欢的一本书， 詹姆斯· 克莱尔 (James Clear)的《 原子习惯》 ( Atomic Habits)中有一张题为“微小收益的力量”的精美图表。 这是一个简单的图。 它显示了每天1％的改善和1％的减少之间的差异。

If you get 1% better every day, after a year you'll be almost 38 times better than you were at the start of the year! That's the power of "tiny gains," and it's just as true for becoming a great software developer.

如果您每天进步1％，那么一年之后，您的状况将比年初提高近38倍！ 这就是“微不足道的收获”的力量，对于成为一名出色的软件开发人员而言也是如此。

Every day you have an opportunity to learn something new—no matter how tiny it is. Maybe it's a new function on arrays you didn't know about, a different method for structuring CSS, a new text editor shortcut, or something new entirely like learning SQL and how data is stored at the database level.

每天，您都有机会学习新事物，无论它多么微小。 也许这是您不知道的数组上的新功能，构造CSS的另一种方法，新的文本编辑器快捷方式或全新的学习方式，例如学习SQL以及如何在数据库级别存储数据。

Regardless, aim to be 1% better every day (most days you'll end up doing much more) and the growth from the first few years of your career will be astounding.

无论如何，都希望每天提高1％(大多数情况下您会做得更多)，而且职业生涯最初几年的增长将是惊人的。

每天一页 (One page per day)

I heard a story on a developer podcast once about the guy who maintains the

pg

gem for Ruby. This is the gem that is the interface between your Ruby code and the Postgresql database. It's some pretty serious stuff, and it's used by most Ruby developers every single day.

我曾经在开发者播客上听到一个有关为Ruby维护

pg

gem的家伙的故事。 这就是Ruby代码和Postgresql数据库之间的接口。 这是相当严肃的东西，大多数Ruby开发人员每天都在使用它。

The story of how he became the maintainer of this gem was interesting. He said that when he was first getting started, he would open up the Postgresql documentation and read one page—just one page each and every day.

关于他如何成为这颗宝石的维护者的故事很有趣。 他说，当他刚开始时，他将打开Postgresql文档并阅读一页-每天仅一页。

Over time, he grew an extensive knowledge of Postgresql and was able to start contributing to the

pg

gem. After a little while longer, he became the maintainer of that gem.

随着时间的流逝，他对Postgresql有了广泛的了解，并能够开始为

pg

gem做出贡献。 再过一会儿，他成为了那颗宝石的维护者。

It's the perfect example of tiny gains stacking up—just one page per day. Any of us can do that, and I encourage you to take the same philosophy and apply it to whatever language or system you're working with!

这是微小收益堆积如山的完美典范-每天只有一页。 我们每个人都可以做到这一点，我鼓励您采用相同的哲学，并将其应用于您使用的任何语言或系统！

“实践使完美” ("Practice make perfect")

You've probably heard this phase before: "practice makes perfect."

您可能之前已经听说过这一阶段： “实践使之完美”。

My piano teacher growing up used a different phrase: "perfect practice makes perfect."

我长大的钢琴老师用了一个不同的词： “ 完美的练习才是完美的”。

I think he was right. I could practice the piano in the wrong way—with bad technique, sloppy, without a steady rhythm—and that's the result I would get: sloppy piano playing.

我认为他是对的。 我可能会以错误的方式练习钢琴-技巧不熟练，马虎，没有稳定的节奏-这就是我要得到的结果：马虎的钢琴演奏。

It's not just practice, but how you practice that matters. I could practice the first measure of a song over and over and get it down perfectly, but if I never pushed beyond the first measure I would never learn the song. I could play that first measure of the song at the level of a world-class pianist, but I wanted to play the piano, so I had to learn the whole song.

这不仅是练习，而且如何练习也很重要。 我可以一遍又一遍地练习一首歌的首小节，然后完美地放下来，但是如果我从不超出首首小节，我将永远不会学这首歌。 我可以用世界一流的钢琴家的水平来弹奏这首歌，但是我想弹钢琴，所以我必须学习整首歌。

This is a perfect parallel for development. The way you "practice" development (your daily habits, methods and routines for development) determines the type of developer you will become.

这是开发的完美并行。 您“实践”开发的方式(您的日常习惯，开发方法和例程)确定您将成为开发人员的类型。

In the beginning you'll make lots of mistakes (everyone does), but if you're conscious of your work, you'll notice areas you can improve. These are perfect practice moments: the opportunity to learn something new or do something in a better way.

在开始时，您会犯很多错误(每个人都会犯错)，但是如果您意识到自己的工作，就会发现可以改进的地方。 这些都是完美的练习时刻：学习新事物或以更好的方式做某事的机会。

When you look back on your career ten years from now, you will want to have had ten years of growth, practice, and learning—not one year of growth, practice, and learning ten times.

当您从现在开始十年回顾自己的职业时，您将希望拥有十年的成长，实践和学习，而不是十年的成长，实践和学习。

So ask those dumb questions. Ask the obvious questions. When someone mentions something you don't know anything about, boldly ask, "What's that?" My hope is that they respond in a kind and teaching manner, but regardless, be ready to learn.

所以问那些愚蠢的问题。 提出明显的问题。 当有人提到您不知道的事情时，大胆地问：“那是什么？” 我希望他们以一种善于教导的方式做出回应，但无论如何，都要做好学习的准备。

It all comes back to owning your growth.

一切归结于拥有您的成长。

T型人 (T-shaped people)

In the beginning of your development career, there are so many topics that you can benefit from knowing, so you want to spread your effort and knowledge across a wide range of subjects.

在您的职业生涯开始之初，有太多的主题可以从中受益，因此您希望将自己的努力和知识分散到广泛的主题中。

If you're aiming at becoming a full-stack developer, that list might include things like HTML, CSS, JS, a backend language of your choice, SQL, Git, etc. There's so much easily attainable knowledge and benefit right on the surface of each of those topics that can be acquired by casting a wide net and taking it all in.

如果您打算成为一名全栈开发人员，那么该列表可能包括诸如HTML，CSS，JS，您选择的后端语言，SQL，Git等之类的东西。表面上有那么容易获得的知识和收益可以通过铸造一个广泛的网络并将其全部吸收而获得的每个主题。

Over time, you'll find what type of development you enjoy most. Maybe it's frontend, backend, database work, ops, design—or some combination of those and more.

随着时间的流逝，您会发现自己最喜欢的开发类型。 也许是前端，后端，数据库工作，操作，设计，或者这些的组合等等。

As your career progresses, you'll start to become a "T-shaped person." A T-shaped person is someone who, like the letter "T" is visualized, has a wide but shallow knowledge and experience about a lot of things, and a couple areas with a deep amount of knowledge and experience.

随着职业的发展，您将开始成为“ T形人”。 T形的人是像可视化的字母“ T”那样的人，对许多事物具有广泛但浅薄的知识和经验，并且在两个领域具有丰富的知识和经验。

This deep knowledge takes a while to build up, and each step down is increasingly more effort than the previous—that's just the reality as you approach mastery of a subject. In the beginning, scoop up all of those easier beginner gains across a wide field of subjects.

积累了如此深的知识需要一段时间，并且比以往更需要付出更多的努力—这就是您掌握某个主题的现实。 首先，从广泛的主题中挖掘所有这些较容易的初学者收获。

Having this T-shape ability will help you become a better developer as a whole. Frontend developers who understand the database schema or backend developers who understand how those database tables are going to be used as models in the frontend will be more knowledgeable and better teammates than those who are siloed in their own area.

具有T形能力将帮助您整体上成为一名更好的开发人员。 那些了解数据库架构的前端开发人员或了解这些数据库表将如何在前端用作模型的后端开发人员，将比那些在各自领域孤零零的人更具知识和更好的团队伙伴。

In the beginning this little foray into all of the aspects of development is also useful to find what you're drawn to, and to give you the bigger picture of all of the moving pieces in the software world.

在开始时，对开发的所有方面进行的一点点尝试也很有用，可以找到您所吸引的对象，并为您提供软件世界中所有动静部件的全景。

Follow your interests and stay hungry to learn!

跟随您的兴趣，并渴望学习！

成为优秀新开发者的提示 (Tips for being a great new developer)

Now that we've covered your expectations and how to think about them, here's some practical tips to make you a great new developer—one your teammates love to work with.

既然我们已经介绍了您的期望以及如何考虑它们，下面是一些实用技巧，这些技巧可以使您成为一名出色的新开发人员—队友喜欢与之一起工作。

1沟通真的真的真的真的真的真的很好 (1 Communicate really really really really really really well)

You may not have incredible development knowledge and skill walking into your first day, but you can have incredible communication skills.

在开始的第一天，您可能没有令人难以置信的开发知识和技能，但是您可以拥有令人难以置信的沟通技巧。

As a new developer, you're going to ask for help and guidance—a lot. And that's ok! Here's a tip for how to ask for help effectively.

作为一名新开发人员，您将需要很多帮助和指导。 没关系！ 这是有关如何有效寻求帮助的提示。

Getting stuck is frustrating (it was for me). In these moments, it's easy to let that frustration overwhelm you and fire off questions to your teammate next to you (or maybe via email or a chat app).

卡住令人沮丧(这对我来说)。 在这些时刻，很容易让这种挫败感淹没您，并向您旁边的队友提出问题(或者通过电子邮件或聊天应用程序)。

Things like:

像：

"im stuck"

我卡住了

"it errored"

“它出错了”

Now take a step back and view this from the perspective of the person you're asking help from. A message like "the page won't load" doesn't help this person help you at all. There's no context. There's no information for them to go on. In fact, they have to ask for more information from you. This is incredibly inefficient and very frustrating for the person that is trying to help you.

现在退后一步，从您正在寻求帮助的人员的角度进行查看。 诸如“页面无法加载”之类的信息根本无法帮助此人帮助您。 没有上下文。 没有可供他们继续的信息。 实际上，他们必须要求您提供更多信息。 对于试图帮助您的人来说，这是非常低效的，并且非常令人沮丧。

A better way to ask for help is to think of it like a Mad Lib™ (if you remember those):

寻求帮助的更好方法是将其视为Mad Lib ™(如果您还记得的话)：

I am working on _____,

我正在研究_____，

but when I try _____,

但是当我尝试_____时，

_____ happens instead.

_____发生了。

_____ happens instead.

_____发生了。

I've tried _____, _____, and _____.

我已经尝试过_____，_____和_____。

An example of this message might be something like this:

此消息的示例可能是这样的：

I am working on the user password reset bug,

我正在处理用户密码重置错误 ，

but when I try to generate a password reset link,

但是当我尝试生成密码重置链接时 ，

but when I try to generate a password reset link,the user's token is already empty.

但是当我尝试生成密码重置链接时 ， 用户的令牌已经为空 。

but when I try to generate a password reset link,the user's token is already empty.

但是当我尝试生成密码重置链接时 ， 用户的令牌已经为空 。

I've looked at where the token is set, and I can see the token in the database,

我已经看过令牌的设置位置 ，并且可以在数据库中看到令牌 ，

but the token is missing on line X of File Y.

但是令牌在文件Y的第X行上丢失。

If you sent someone the message above, they can understand:

如果您将上面的消息发送给某人，他们可以理解：

• What you're working on
  你在做什么
• What the problem is
  问题是什么

• What you've tried already

  您已经尝试过的

• Where the problem is
  问题出在哪里

This is a wealth of information for the person you're asking help from. They will greatly appreciate that you gave them that information so clearly—and that you've already tried to fix it yourself. This shows them that you respect their time, and you're not just looking for an easy handout.

对于您正在寻求帮助的人，这是很多信息。 他们将非常感谢您为他们提供了如此清晰的信息，并且您已经尝试过自己进行修复。 这向他们表明您尊重他们的时间，而不仅仅是在寻找简单的讲义。

There's nothing wrong with getting help, but if someone just fixes the problem for you they've really robbed you of the opportunity to learn and grow yourself.

获得帮助没有错，但是，如果有人只是为您解决问题，那么他们确实剥夺了您学习和成长的机会。

It's not like there's ten problems you have to work through and you're done for the rest of your life—you'll face problems every single day as a developer. So the best outcome is if they give you enough help to get you unstuck but allow you to solve the problem yourself.

并不是说您必须解决十个问题，并且在余生中都已经完成了，所以作为开发人员，您每天都会面临问题。 因此，最好的结果是，如果他们给您足够的帮助，以使您摆脱困境，但让您自己解决问题。

2磨练您的Google Fu (2 Hone your Google Fu)

Just like developing skill in the physical martial art of Kung Fu, over time as a developer you will develop skill in the art of Google Fu—that is the art of finding answers by Googling them. This is a real skill that every experienced developer has and it is developed over time.

就像在功夫武术中发展技能一样，随着时间的推移，作为开发人员，您将在Google Fu技术中发展技能，即通过谷歌搜索答案来寻找答案的艺术。 这是每位经验丰富的开发人员都具备的一项真正技能，并且会随着时间的推移而发展。

Sometimes, you just need to google the exact problem you have (this works great with error messages):

有时，您只需要在Google上找到您遇到的确切问题即可(这对错误消息很有用)：

Sometimes googling the exact error message will produce the correct result, as it did above. You ran into a technical problem, and someone else ran into the exact same problem.

有时，像上面一样，搜索确切的错误消息将产生正确的结果。 您遇到了技术问题，而其他人也遇到了完全相同的问题。

But sometimes, you need to edit the search query a little bit to remove project-specific info:

但有时，您需要稍微编辑搜索查询以删除特定于项目的信息：

In the image above, Google has never seen the function

whos_that_pokemon_its_pikachu()

in the file

gotta_catchem_all.rb

(except now it has since I searched it :)). Removing that project-specific info and adding generic info returns better results.

在上图中，Google从未在文件

gotta_catchem_all.rb

看到过

whos_that_pokemon_its_pikachu()

函数(除非自从我搜索它以来，现在是它)：)。 删除该特定于项目的信息并添加常规信息将获得更好的结果。

3使用“尝试计时器” (3 Use a "try timer")

As a new developer you're going to get stuck a lot. There will be error messages you haven't seen before, and how you handle these situations will determine how quickly you grow as a developer.

作为一个新开发人员，您将陷入很多困境。 将会出现您以前从未见过的错误消息，如何处理这些情况将决定您成为开发人员的速度。

Although these can be terribly frustrating moments, these are the moments where you will learn and you will grow. You don't learn by doing the same kind of work over and over again—it's by journeying through these bumps in the road that growth takes place.

尽管这些时刻可能是令人沮丧的时刻，但这些时刻将是您学习和成长的时刻。 您不会通过一遍又一遍地进行相同的工作来学习，而只是通过经历成长道路上的这些颠簸而学习。

When you run into one of these problems, take some time to try and figure it out yourself. Some companies will tell you this as a part of onboarding—something like "try for 30min before asking for help." In other companies it's not as clearly defined, but the message is still there: do your best and then if you're still stuck ask for help.

当您遇到这些问题之一时，请花一些时间尝试自己解决问题。 一些公司会在入职过程中告诉您这一点，例如“在寻求帮助之前先尝试30分钟”。 在其他公司中，它的定义还不明确，但信息仍然存在：尽力而为，然后如果您仍然遇到困难，请寻求帮助。

This not only allows you the opportunity to figure it out and learn for yourself, but it also respects the time of your teammates who are focused on their own work. Interrupting someone for something you could have quickly figured out yourself is a net loss for the team.

这不仅使您有机会自己弄清楚并学习，而且还尊重了专注于自己工作的队友的时间。 为某人打扰您可能很快就会发现自己的事情，对于团队来说是一笔净损失。

So give it a good try, and then of course ask for help!

因此，请尝试一下，然后寻求帮助！

Here's the secret to being a great new developer though: always reset the timer.

这是成为一名出色的新开发人员的秘诀： 始终重置计时器。

Let's say you get stuck, try for 30min, and then ask for help. The next time you get stuck try again for another 30min before asking for help.

假设您被卡住，尝试30分钟，然后寻求帮助。 下次您遇到麻烦时，请再次尝试30分钟，然后再寻求帮助。

This may seem obvious, but on those days where it feels like you hit nothing but problem after problem, you're going to get frustrated and you're going to want to start asking for help as soon as the next problem arrives—it's just natural.

这看起来似乎很明显，但是在那些日子里，您却一无所获，仿佛一无所获，您会感到沮丧，一旦下一个问题到来，您将想开始寻求帮助-只是自然。

Take a deep breath, go for a quick walk, and approach each problem with a fresh perspective.

深呼吸，快速散步，以崭新的眼光看待每个问题。

(This is, of course, easier said than done!)

(当然，说起来容易做起来难！)

4记住放松并休息一下！ (4 Remember to relax and take breaks!)

Remember to take breaks when things start to feel overwhelming.

当事情开始变得压倒性时，请记住休息一下。

Go for a walk. Go get a glass of water. Sleep on it if you can. Sometimes just getting up and moving for a minute can help you re-center yourself.

出去走走。 去拿一杯水。 如果可以的话，睡在上面。 有时只是起身移动一分钟可以帮助您重新定位自己。

Remember that every developer was once in your place, and you will get through it.

请记住，每个开发人员都曾经在您的位置上，您将一路过关斩将。

Development will always be frustrating to some extent—you never stop making mistakes or running into problems. But over time you just get better at dealing with them, and your confidence to fix those problems increases so it bothers you less and less.

开发在某种程度上总是令人沮丧的-您永远不会停止犯错误或遇到问题。 但是随着时间的流逝，您会变得更加擅长与他们打交道，而您解决这些问题的信心也会增加，因此越来越困扰您。

5问鸭子 (5 Ask the duck)

Have you ever written an email or a text message describing a problem you have to someone, and right before you hit send you realize the solution? In the software world there's a phrase for this—rubber duck debugging:

您是否曾经写过一封电子邮件或短信给某人描述您所遇到的问题，并且在您按下该键之前就意识到了解决方案？ 在软件世界中，有这样的说法- 橡皮鸭调试 ：

The name is a reference to a story in the book The Pragmatic Programmer in which a programmer would carry around a rubber duck and debug their code by forcing themselves to explain it, line-by-line, to the duck.

该名称是对《实用程序员》一书中一个故事的引用，该书中的程序员会带着橡皮鸭，并强迫他们自己逐只向鸭子解释，从而调试代码。

You see, by writing an email or talking to another person, you're forced to explain the entire context in a logical way in order for the other person to understand what's going on.

您会看到，通过写电子邮件或与其他人交谈，您被迫以逻辑方式解释整个上下文，以便其他人了解正在发生的事情。

To explain the problem in this way, you yourself have to be able to think about and order it logically. Just the act of trying to prepare this context for someone else can cause you to think about the problem in a different light, and many times you'll find the solution yourself.

要以这种方式解释问题， 您自己必须能够逻辑地思考和排序。 只是尝试为其他人准备此上下文的行为可能会使您从不同的角度考虑问题，很多时候您会自己找到解决方案。

So relating back to using a try timer, before you ask for help, try explaining (or typing) up the summary of the problem in an email that you don't send. The chances are you'll gain new insight about the problem without having to interrupt another person, and worst case, you've got a great email or chat message to send them.

因此，与使用尝试计时器相关联，在寻求帮助之前，请尝试在未发送的电子邮件中解释(或键入)问题的摘要。 很有可能您无需打扰其他人就能获得有关该问题的新见解，更糟糕的是，您会收到一封很棒的电子邮件或聊天消息来发送给他们。

(I've seen many people put actual rubber ducks on their desk too!)

(我也看到很多人也把橡皮鸭放在他们的桌子上！)

6做笔记 (6 Take notes)

This tip may seem obvious...but take notes!

这个技巧似乎很明显...但是要注意！

You will be introduced to many different things when you first join a company: codebases, products, people, business logic, and it will be impossible to remember it all. Write this stuff down.

初次加入公司时，您将了解许多不同的事物：代码库，产品，人员，业务逻辑，并且不可能记住所有这一切。 把这些东西写下来。

When I started my first job, my boss told me he had no problem explaining anything to me, but he didn't want to have to do it twice. I understood then, but now eight years later I really understand—it's all about respecting your teammates and their time.

当我开始第一份工作时，老板告诉我他对我解释什么都没问题，但他不想重复两次。 那时我明白了，但是八年后的今天，我真的明白了-这全是在尊重您的队友和他们的时间。

If he explains something to me and I forget it, we've wasted both of our time—and I'll have to ask him again. At his recommendation I even started putting physical sticky notes on my monitor of things I wanted to see often and remember. Things like:

如果他向我解释了一些事情，但我忘记了，那我们就浪费了我们的全部时间，我不得不再次问他。 在他的建议下，我什至开始在我想要经常看到和记住的事物的监视器上贴上手写便笺。 像：

- TRY FOR 30MIN

-尝试30分钟

- CHECK THE BUILD PASSES BEFORE ASKING FOR PR REVIEW

-在进行公关审查之前，请检查内置管道

7每天与冒名顶替综合症作斗争 (7 Fight against imposter syndrome daily)

If you don't know what imposter syndrome is, it sounds like this in your head:

如果您不知道什么是冒名顶替综合症，您的脑中听起来像是这样：

I don't belong. I'm a fraud. Everyone else understands this but me.

我不属于 我是骗子 除了我，其他所有人都明白。

This is a mindset you have to fight on a daily basis. There will be frustrating times as a developer, but you've faced frustration already and pushed through it. Every developer has felt this, and this too will pass.

这是您每天都要打架的心态。 作为开发人员，这将是令人沮丧的时期，但是您已经面对挫败感并克服了它。 每个开发人员都已经感受到了这一点，这也将过去。

In reality, imposter syndrome looks more like this:

实际上，冒名顶替者综合征看起来更像是这样：

“高级”和“初级”开发人员之间的一个关键区别 (The one key difference between a "senior" and "junior" developer)

Sure, a senior developer has more knowledge and experience than a new developer, but that isn't what sets them apart. A senior developer has a problem solving system.

当然，高级开发人员比新开发人员拥有更多的知识和经验，但这并不是他们与众不同的地方。 高级开发人员具有问题解决系统。

When I first started in development I thought eventually I would stop making mistakes—that I would stop running into errors.

当我刚开始开发时，我以为最终我会停止犯错误-不再遇到错误。

The opposite happened. I still make an incredible number of mistakes every day. Wrong syntax, wrong file, wrong function.

相反的事情发生了。 我每天仍会犯很多错误。 语法错误，文件错误，功能错误。

I didn't stop making mistakes—I just got incredibly fast at fixing them.

我没有停止犯错误，只是很快地纠正了错误。

This is a skill that is developed over time, and it requires intentional problem solving.

这是一项随着时间而发展的技能，需要有意识地解决问题。

Here's some tips on how to build this system.

以下是有关如何构建此系统的一些技巧。

5调试技巧 (5 Debugging tips)

1不要破坏您的代码！ (1 Don't thrash your code!)

One of the things I did as a new developer—and something I see many other new developers do when they run into a problem—is they start wildly changing things in their code. Instead of having a systematic evaluation process, they just make a ton of quick changes trying to see if that fixes the problem.

作为新开发人员，我做的一件事情(当我遇到问题时，我看到许多其他新开发人员所做的事情)是，他们开始疯狂地更改代码中的内容。 他们没有进行系统的评估过程，而是做出了大量快速更改，试图查看是否可以解决问题。

This is a very bad habit. You will only create more mistakes doing this. What you should do is:

这是一个非常不好的习惯。 这样做只会造成更多错误。 您应该做的是：

2阅读错误消息！ (2 Read the error message!)

This tip may seem obvious, but actually read the message. What is the error? What is the file where this error is occurring? What line is this error coming from? This is all vital information.

这个技巧似乎很明显，但是实际上已经阅读了该消息。 有什么错误？ 发生此错误的文件是什么？ 此错误来自何行 ？ 这些都是至关重要的信息。

If you resist just changing your code rapidly, you can jump straight to the exact place the error is happening.

如果您拒绝只是快速更改代码，则可以直接跳到发生错误的确切位置。

This is what the experienced developer does. Read the message—go straight to the problem.

这就是经验丰富的开发人员所做的。 阅读消息-直接解决问题。

Doing this will save you an incredible amount of wasted time and mental effort.

这样做可以节省大量的时间和精力。

3不要将时间浪费在不可能的事情上！ (或者至少是不可能的) (3 Don't waste time on the impossible! (Or at least the improbable))

This is something I see new developers do often. They face an error in their code, they find something that they think is the problem, and they can't believe how it's not true. As an example:

我看到这是新开发人员经常做的事情。 他们在代码中遇到错误，发现了他们认为是问题的东西，并且不敢相信这不是事实。 举个例子：

"I see the problem is on line 14, where it checks if the

is_admin

variable is

true

, and it's not

true

—but the user is an admin!!

“我看到问题出在第14行，它检查

is_admin

变量是否为

true

，并且不是

true

但用户是管理员！

They approach this problem thinking, "How can this be!!!" instead of, "How can this be?"

他们思考这个问题， “这怎么可能！！！” 而不是“这怎么可能？”

There are times when you will encounter a core language or framework bug, but 99.9% of the time, you did something wrong or the situation is not as it appears.

有时您会遇到核心语言或框架错误，但是99.9％的时间您做错了什么，或者情况并非如此。

Instead of spending time marveling at the impossible unfolding before your eyes, question your assumptions about the situation. Something is not as it seems. Being aghast at the impossible is only a waste of time—start your problem-solving system.

与其花时间惊叹于眼前的不可能实现，不如问一下关于情况的假设。 事情不是看起来那样。 对不可能的事情感到震惊只是浪费时间-启动您的问题解决系统。

4“如有疑问，请打印更多。” -聪明人 (4 "When in doubt, print more out." - Some wise person)

I don't know who originally said this, but it's one of the most effective debugging techniques out there. When you don't know what's happening, start printing the state of your program in places where you think the problem is happening.

我不知道最初是谁说的，但这是最有效的调试技术之一。 当您不知道发生了什么时，请在您认为问题正在发生的地方开始打印程序的状态。

What is in the

user

variable? What is the response from the HTTP request? Did we take the

if

or the

else

branch in this situation? Did we even call this function or are we even on this page?

user

变量中有什么？ HTTP请求的响应是什么？ 在这种情况下，我们是否采用了

if

或

else

分支？ 我们甚至调用了此函数还是在此页面上？

I've seen countless developers trying to debug and fix an issue (and I've done it many times myself too) when they weren't even working in the right file! A quick

print

or

console.log

will show you that you are in fact looking at the actual code being run.

我看到无数开发人员甚至在没有使用正确文件的情况下尝试调试和解决问题(我自己也做过很多次)！ 快速

print

或

console.log

将显示您实际上正在查看正在运行的实际代码。

5把它一步一步的时间。 (5 Take it one step at a time.)

A common mistake every new developer does: they do too much at once.

每个新开发人员都会犯的一个常见错误： 他们一次做太多事情。

They want to write code for 30min, click run, and see it work. What they find is that they spent 30min writing bugs and errors, and it's now a nightmare to fix.

他们希望编写30分钟的代码，单击“运行”，然后查看其工作情况。 他们发现他们花了30分钟编写错误和错误，现在解决这个噩梦。

When I go to make a new page in an app, the first thing I do is put

<p>hi</p>

on the page. I want to make sure that all of my internal code is setup correctly and I see that

hi

on the page. I take it one. step. at. a. time.

当我要在应用程序中制作新页面时，我要做的第一件事是在页面上放置

<p>hi</p>

。 我想确保所有内部代码都正确设置，并且在页面上看到了

hi

。 我拿一个。 步。 在。 一个。 时间。

Do one thing at a time. Get "hi" printing on the page. Next get the user input. Next validate the input. Next save the input. If you take small steps you know exactly where to fix the problem when it occurs.

一次做一件事。 在页面上打印“ hi” 。 接下来获取用户输入。 接下来验证输入。 接下来保存输入。 如果您采取一些小步骤，您将确切知道问题发生时的解决方法。

Even eight years later into a development career I still take it step by step. I know I'm going to make a ton of mistakes, and I want to know immediately when and where that happens.

即使在进入开发事业的八年后，我仍然会一步一步地走下去。 我知道我会犯很多错误，我想立即知道发生的时间和地点。

结论 (Conclusion)

You've already come so far, but there's still a lot ahead of you.

您已经走了这么远，但是还有很多事情要做。

There's much to learn, and many skills to develop, but there's also a lot of fun and rewarding work ahead as well!

有很多东西要学习，还有很多技能要发展，但是未来还有很多有趣和有意义的工作！

Keep your head up, and remember to take breaks. Get 1% better every day, and in a year you'll be astonished at the results!

抬起头，记得休息一下。 每天提高1％，一年之内，您会为结果感到惊讶！

If you liked this post, I write similar things on my blog here.

如果您喜欢这篇文章，我会在这里的博客上写类似的文章 。

Thanks for reading!

谢谢阅读！

翻译自: https://www.freecodecamp.org/news/how-to-become-an-astounding-junior-developer/

成为杰出人物的路线图