Vox

Leitura de 17 min

Three Things I Wish I Learned Earlier in My Career As A Software Developer

Summary

In this episode of Developer Tea, host Jonathan shares three key insights he wishes he had learned earlier in his software development career. He begins by emphasizing the importance of seeking diverse perspectives, noting that learning from people with different backgrounds and frames of reference provides richer information and helps avoid cognitive traps, ultimately leading to better decision-making.

The first main insight is that learning how to code eventually becomes less important than learning how to think about code. Jonathan explains that senior developers can move between languages more easily because they focus on understanding problems first and then applying different languages as tools to solve them. This shift involves learning techniques and patterns that are applicable across languages, rather than just memorizing syntax.

The second insight is about finding a team you enjoy working with. Jonathan advises against looking for a team with a perfect, predefined process. Instead, he suggests seeking a team you can harmonize with—one where you share compatible values, get along well, and can work together effectively to solve problems. He notes that processes evolve and are unique to each team’s dynamics and constraints.

The third insight is that the simplest solution is often the right one. Jonathan clarifies that ‘simple’ means solutions that are easy to understand and reason about, not solutions that create technical debt or poor user experiences. He advocates for creating small, atomic solutions to specific problems and then composing them together to build powerful systems. This approach allows developers to keep the entire problem and solution in their head, leading to more maintainable and understandable code.

Recommendations

Podcasts

  • Other podcasts on Spec.fm — Jonathan encourages listeners to subscribe to other podcasts on the Spec.fm network to gain diverse perspectives from other designers and developers, reinforcing the episode’s theme of seeking varied viewpoints.

Tools

  • Linode — A cloud hosting provider that offers SSD servers, including dedicated CPU servers for high-performance computing. The episode sponsor is promoting a $20 credit with a promo code.

Topic Timeline

  • 00:00:00 — Introduction and the value of ‘I wish I knew’ discussions — Jonathan introduces the episode’s theme of sharing insights he wishes he knew earlier in his career. He explains that these discussions can act as a ‘fast forward button’ for learning, benefiting developers at all career stages. He encourages listeners to share their own insights on Twitter and mentions the show’s goal of helping developers find clarity, perspective, and purpose.
  • 00:01:43 — Bonus insight: The importance of seeking diverse perspectives — Jonathan shares a bonus item: he wishes he had learned earlier to seek out a variety of perspectives, especially those different from his own. He argues this is where true learning comes from, as it helps avoid common cognitive traps. He explains that combining people with different backgrounds and frames of reference leads to a richer array of information and better decision-making.
  • 00:06:24 — First main insight: Thinking about code vs. learning code — Jonathan presents the first of three main insights: learning how to code eventually becomes less important than learning how to think about code. He explains that senior developers excel by understanding problems first and then viewing them through the lens of different programming languages. The focus shifts from syntax to techniques and patterns that are language-agnostic.
  • 00:09:42 — Second main insight: Finding a team you harmonize with — The second insight is that finding a great team is not about finding one with a perfect, predefined process. Instead, it’s about finding a team you can harmonize with—where you share compatible values, get along, and can work together effectively. Jonathan notes that processes are unique to each team and will evolve, so compatibility is more important than a specific methodology.
  • 00:11:33 — Third main insight: The simplest solution is often right — The third insight is that more often than not, the simplest solution is the correct one. Jonathan clarifies that ‘simple’ means solutions that are easy to understand and reason about, not quick hacks that create debt. He advocates for building systems by composing small, atomic solutions to specific problems, which allows the entire system to be comprehensible and maintainable.

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2019-05-20T09:00:00Z
  • Duration: 00:15:11

References

Podcast Info

Transcript

[00:00:00] in today’s episode i’d like to share some things that i wish i knew when i first started out

[00:00:10] in my career as a developer and hopefully some of you will share some of the things you wish

[00:00:17] you knew as well these kinds of insights can provide kind of a fast forward button on the

[00:00:24] learning process for developers who are at the beginning of their careers or maybe even

[00:00:29] mid-career the things i’m going to talk about today are certainly not just for beginners

[00:00:35] these are ideas that mid-level senior level developers can still benefit from and if we

[00:00:42] think about our entire career as a constant sense of learning where we are always beginners at

[00:00:52] something where we’re always refining our skills or refining our perspectives then these

[00:00:58] kind of

[00:00:59] i wish i knew uh discussions can always provide value to us regardless of where they’re coming

[00:01:06] from what context they’re coming from so i’d like to encourage you to respond to this episode by

[00:01:12] sharing your own i wish i knew do this on twitter uh bonus points if you mentioned developer t

[00:01:20] so i can see them at developer t on twitter i’d love to hear from you all my name is jonathan

[00:01:26] you’re listening to developer t and i create

[00:01:29] this show to help you driven developers find clarity perspective and purpose in your careers

[00:01:35] and before we get started i do want to have a little bit of a disclaimer here by no means do

[00:01:43] i expect that this show is going to provide you all of the coaching and mentoring wisdom that you

[00:01:49] need certainly i believe that the perspectives that we’re able to provide on this show can be

[00:01:56] helpful otherwise i wouldn’t do this

[00:01:59] but there’s only a certain amount of context and perspective that i or any one person can provide

[00:02:06] so i want to encourage you to find other perspectives seek them out and seek them out

[00:02:14] as soon as you can in your career that’s kind of a bonus item for today’s episode one thing i wish

[00:02:21] that somebody had told me when i first started out is that the perspectives of a variety of people

[00:02:28] are going to be

[00:02:29] perhaps the most useful thing that you can find in your career and this is true for developers

[00:02:35] it’s true for non-developers true for everyone in almost every kind of career just in life in

[00:02:41] general if you can seek perspectives especially perspectives that are different than your own

[00:02:48] that is where true learning comes from we’ve talked about this quite a bit on the show and

[00:02:54] this isn’t just a value statement that we should appreciate all kinds of perspectives but it’s also

[00:02:59] of people from all kinds of backgrounds that certainly is a value that i hold but it’s not

[00:03:05] the only reason that i recommend heavily that you seek out the perspectives of people that are

[00:03:11] different than you from a basic social science level this is a self-serving thing just as much

[00:03:19] as it is a community serving thing when you seek out the perspectives of people that are different

[00:03:24] than you then you start avoiding some of the cognitive traps that you’re able to find in your

[00:03:29] that people who are like you probably have in common with you you can think about it like this

[00:03:36] if you combine a bunch of people who studied the same subject for example to solve a particular

[00:03:44] problem the way that they solve that problem is likely to have some similarities now that’s not

[00:03:51] to say that you won’t have similarities between two people who study different things but rather

[00:03:57] when you combine people who study different things with people who study different things

[00:03:59] who have different backgrounds in this case we’re talking about academics but you can fill in the

[00:04:05] blank perhaps cultural background then the frame of reference that a person comes from is going to

[00:04:13] inform the way they see the world and so when you have multiple frames of reference especially when

[00:04:20] those frames are as dissimilar as possible you end up with a much richer array of information

[00:04:29] with more information generally speaking you can make better decisions so that’s our bonus item for

[00:04:37] today the the thing that i wish i had learned earlier in my career is that these diverse

[00:04:45] perspectives are perhaps one of the most valuable things that you can have in your career we’re

[00:04:51] going to take a quick break and talk about today’s sponsor linode and then we’re going to come back

[00:04:55] and talk about the other three things that i wish i knew when i was starting out my career

[00:04:59] as a software developer today’s episode is sponsored by linode with linode you can instantly

[00:05:05] deploy and manage an ssd server in the linode cloud not just one ssd server you can deploy

[00:05:11] and network a bunch of ssd servers and what can you do with these pretty much anything you’d like

[00:05:16] in fact if you are used to the normal uh kind of ssd server in the cloud discussion then you

[00:05:23] probably are thinking oh this is just a web service linode recently started offering dedicated

[00:05:29] cpu servers for the linode cloud and i’m going to talk a little bit about that in a moment

[00:05:29] so these are designed for consistent high performance computing like video encoding or

[00:05:36] game servers but of course you can build almost anything on linode because it’s built on top of

[00:05:41] linux pretty much anything that you can build with linux so continuous integration continuous

[00:05:47] delivery you can easily deploy and maintain your entire infrastructure simply and totally

[00:05:53] cost effectively linode’s tools make it easy to provision secure monitor and backup your

[00:05:59] your cloud go and check it out head over to linode.com slash developer t they’re going to

[00:06:04] give you 20 worth of credit when you use the promo code developer t 2019 that’s developer t

[00:06:11] 2019 all one word linode.com slash developer t of course again a huge thank you to linode for

[00:06:18] sponsoring today’s episode so let’s get straight into the three things that i wish somebody had

[00:06:24] told me before i started my career as a software engineer

[00:06:29] and here’s the reality there’s a lot more than three things i wish i could put a list together

[00:06:34] of all of the things that i’ve learned that i wish i could have known earlier but really that’s kind

[00:06:39] of what a career is about it’s about learning these things for yourself over the course of

[00:06:45] your experience and you can’t just read a book and have all that knowledge readily available

[00:06:50] you kind of have to have the experiences that muscle memory to really take on all of the

[00:06:58] knowledge that you need to

[00:06:59] to succeed in a career that’s why experience is so important but with some of these things in mind

[00:07:06] if you go and seek out the the same kind of information from other developers you can have

[00:07:11] good pointers these are kind of things that you can look out for ways of thinking that you may

[00:07:18] not have thought of thought about naturally on your own so let’s go straight through these three

[00:07:23] things the first one is that learning how to code eventually becomes less important than learning

[00:07:29] how to think about code i’m going to say that again learning how to code like learning the

[00:07:35] language or learning the idiosyncrasies of a given language’s community or learning a framework

[00:07:41] learning how to code eventually becomes less important than learning how to think about code

[00:07:47] this is why many senior developers can move between languages without much of an issue

[00:07:53] it’s not because they’ve invested hours on end learning syntax maybe they did

[00:07:59] but they can move between these languages much easier because instead they’ve learned how to see

[00:08:05] problems through the lens of different languages rather than understanding languages so they can

[00:08:12] use them as a tool to solve a problem they look at a problem through the lens of a language

[00:08:19] and maybe a better way of thinking about this is the problem exists whether the language exists or

[00:08:26] not and so to solve a problem

[00:08:29] with the language to solve a problem with code you first have to think about the problem

[00:08:35] and once you’ve kind of worked out some of the problem then you can take those different languages

[00:08:42] those different ways of thinking in code and apply them map them over the problem

[00:08:49] now sometimes multiple languages will map perfectly fine over a problem sometimes languages

[00:08:54] are better suited for one problem type than another but great developers

[00:08:59] great software engineers understand that the code is secondary to the thinking about the code

[00:09:06] this is a slight shift it’s going to change the way that you think about learning because instead

[00:09:14] of learning just syntax which is still an important part of the equation you’ll start

[00:09:21] learning about technique about patterns and you can apply patterns no matter what language you’re

[00:09:29] using so that’s the first thing learning how to code eventually becomes less important than learning

[00:09:34] how to think about code the second thing i wish i learned earlier in my career is that finding a team

[00:09:42] that you enjoy working on is not about defining a perfect process in other words you shouldn’t go

[00:09:48] around looking for specific elements of a process that you think is perfect it’s about finding a team

[00:09:55] that instead you can harmonize well with

[00:09:59] there are some things that great teams have in common but people are individually different

[00:10:04] and those differences are even more pronounced when you combine them and so it wouldn’t really

[00:10:10] make sense to go and blanket apply every single process thing that you think is perfect to a team

[00:10:18] a team has its own idiosyncrasies it has its own rhythms its own restrictions and so your process

[00:10:26] is probably going to change it’s going to change your process and your team is going to change your

[00:10:29] process it’s going to evolve and what is perfect for one team may not be perfect for another

[00:10:34] and so it’s more difficult for you to find a team that you can work well on that is already using a

[00:10:43] perfect process that you love it’s much more likely that you will find a team that you can

[00:10:49] harmonize well with and what do i mean by harmonize well with well you get along you have

[00:10:55] compatible values you see a team that you can work well with and you can harmonize well with

[00:10:59] the problem together fairly clearly and some of these things are process oriented the process that

[00:11:07] one person really enjoys doesn’t totally uh jar with the process that another person on the team

[00:11:15] really enjoys so these are more complex ways of thinking about a team instead of being dogmatic

[00:11:23] about a given process look for a team that you harmonize well with

[00:11:29] the third thing that i wish somebody had told me earlier in my career

[00:11:33] is that more often than not the simplest thing is the right answer composing a lot of simple

[00:11:42] things together actually provides sufficient complexity for very powerful systems now let

[00:11:49] me qualify what i mean by simple i don’t mean that you allow a large amount of technical debt

[00:11:57] in the name of doing something that you don’t want to do in the name of doing something that you

[00:11:59] don’t want to do in the name of doing something small and quick i also don’t mean that you choose

[00:12:04] an ugly experience for whatever the user is whatever the receiver of your uh your product is

[00:12:13] when i say simple i mean the thing that you can fit in your head easiest as developers we often

[00:12:21] try to solve broader problems than necessary sometimes we create complex systems because

[00:12:29] we expect that we will need them rather than actually experiencing that need and so if you

[00:12:37] start by creating small atomic solutions to small atomic problems then the entire problem and the

[00:12:46] entire solution can all fit in your head you can reason about them all at once and when you take

[00:12:53] that atomic solution to an atomic problem and you compose it with other solutions

[00:12:59] maybe solutions that others on your team are making or solutions that you are making

[00:13:04] then you can start to create a system of simple solutions that work together

[00:13:10] now of course we’re talking in abstract terms and there are very concrete ways

[00:13:15] that you can apply this knowledge i trust that you will take these conversations into

[00:13:21] discussions that you have with maybe your manager or your clients co-workers your team members

[00:13:27] find people that you can apply this knowledge to and you can start to create a system of simple solutions

[00:13:29] that care about your career and care about the work that you’re producing

[00:13:36] your co-workers certainly care about the work that you’re producing a good manager will care

[00:13:42] about your career and so checking these ideas with them and finding ways to apply the simplest

[00:13:48] possible solution for example that’s how you grow in your career one week one meeting one project at

[00:13:56] a time thank you so much for listening to this video i hope you enjoyed it and i’ll see you in the

[00:13:59] next one

[00:14:00] listening to today’s episode of developer t and thank you again to linode for sponsoring today’s

[00:14:03] episode head over to linode.com slash developer t use the code developer t 2019 at checkout

[00:14:10] and you’ll get 20 worth of credit on linode’s platform thanks so much for listening to today’s

[00:14:16] episode this episode wouldn’t be possible without our awesome producer sarah jackson

[00:14:20] and spec.fm spec is a network for designers and developers just like you who are looking to level

[00:14:27] up in their career i would encourage you to subscribe to linode for sponsoring today’s episode

[00:14:29] to go and instead of subscribing to today’s episode to this podcast go and subscribe to

[00:14:35] another podcast on spec.fm again going back to that diverse voices discussion that we had at

[00:14:42] the beginning of the episode there are other diverse voices on spec.fm that are going to be

[00:14:47] valuable to add to that kind of input consumption that you’re doing with podcasts don’t just listen

[00:14:55] to this one listen to other perspectives as well and there’s some really great ones

[00:14:59] on the network at spec.fm thank you so much for listening and until next time enjoy your tea

Visão de gráfico