Vox

Leitura de 19 min

How Our Tools Shape Us

Summary

In this episode of Developer Tea, host Jonathan Cottrell explores the profound relationship between developers and their tools. He argues that tools are not just passive instruments we use, but active forces that shape our behavior, thinking patterns, and even our physical bodies. From programming languages like Ruby and Lisp to physical tools like chairs and computers, every tool we adopt influences how we approach problems and develop as professionals.

The discussion centers on Marshall McLuhan’s famous idea that “we shape our tools, and thereafter our tools shape us.” Cottrell illustrates this by asking listeners to imagine life without any tools—clothes, computers, utensils—and then consider how each tool we add changes our behavior. He emphasizes that this shaping happens whether we’re conscious of it or not, affecting everything from which keyboard keys we use most frequently to the cultural values we adopt from programming communities.

Cottrell specifically examines how different programming languages shape developers differently. Learning Lisp makes developers more familiar with parentheses, while Ruby’s community emphasizes “developer happiness” as a core value that shapes how programmers approach their work. He references a conversation with Mark Engelberg about how learning functional programming through Closure first can fundamentally change how one thinks about programming.

The episode challenges listeners to be more intentional about tool selection. Rather than simply adopting tools because they’re popular or someone recommended them, developers should consider what kind of professional they want to become and choose tools that will shape them in that direction. This requires imagining one’s desired future form first, then selecting tools that will help achieve that form, whether that means working with big data (suggesting Python or C++) or pursuing other specialized paths.

Ultimately, Cottrell encourages developers to regularly evaluate their relationship with their tools and consider when it might be time to change tools to support different growth directions. He acknowledges this is difficult work but essential for developers who want to reach their full potential and work with purpose rather than simply following trends or default tool choices.

Recommendations

People

  • Marshall McLuhan — Referenced for his famous quote about tools: ‘We shape our tools, and thereafter our tools shape us.’ This philosophical insight forms the foundation of the episode’s exploration of how tools influence human behavior and development.
  • Mark Engelberg — Mentioned as creator of the Code game series and discussed for his perspective on learning functional programming through Closure first. Cottrell references a conversation with Engelberg about how different programming paradigms shape thinking differently.

Podcasts

  • Tools Day — A show on spec.fm hosted by Una and Chris that discusses various tools, particularly relevant for front-end developers. Cottrell recommends it as a resource for developers interested in tools.

Tools

  • Linode — Sponsored cloud hosting service described as ‘an excellent tool’ because it’s designed with the user experience in mind. Features mentioned include Lish console for server access and plans starting at $5/month with 1GB RAM.
  • Ruby — Programming language discussed as an example of how tools shape culture and values. The Ruby community’s emphasis on ‘developer happiness’ influences how programmers approach their work and evaluate their tools.
  • Lisp — Programming language mentioned as an example of how tools physically shape developers—Lisp programmers become more familiar with parentheses keys due to the language’s syntax requirements.
  • Closure — Programming language discussed in the context of learning functional programming paradigms first. The episode references how learning Closure can fundamentally change how one thinks about programming.

Topic Timeline

  • 00:00:00 — Introduction to tools and their influence — Jonathan Cottrell opens by asking a provocative question about why developers use their current tool sets—whether by choice or because someone showed them. He introduces the episode’s theme about how tools shape us on a grand scale, beyond just programming tools to include all tools we interact with daily. The host explains that Developer Tea aims to help driven developers connect with their career purpose through better practices and principles.
  • 00:02:24 — Defining what constitutes a tool — Cottrell expands the definition of tools beyond programming languages and editors to include computers, software, desks, chairs, mice, and essentially everything we make and use. He argues that most things we rely on daily could be considered tools, and emphasizes that we need to examine our relationship with these objects. The discussion sets up the central question of why our tools matter and how they influence us.
  • 00:06:03 — The reciprocal relationship with tools — After a sponsor break for Linode, Cottrell returns to discuss the fundamental relationship between humans and tools. He asks listeners to imagine life without any tools—no clothes, computers, or utensils—to illustrate how dramatically tools shape our existence. The host introduces Marshall McLuhan’s concept that ‘we shape our tools, and thereafter our tools shape us,’ explaining that as we integrate tools into our lives, they inevitably change our behavior and ways of thinking.
  • 00:08:27 — How programming languages shape developers — Cottrell provides concrete examples of how tools shape developers. Programming languages like Lisp make developers more familiar with parentheses keys, while Ruby’s community values ‘developer happiness’ that influences how programmers approach their work. He notes that even the physical act of sitting at a desk staring at a screen literally shapes our bodies, demonstrating that tools affect us both mentally and physically.
  • 00:10:23 — Intentional tool selection for desired outcomes — Referencing a conversation with Mark Engelberg about learning Closure first, Cottrell discusses how different programming paradigms shape thinking differently. He argues that developers should be more intentional about tool selection by first determining what kind of professional they want to become, then choosing tools that will shape them in that direction. For example, developers interested in big data might choose Python or C++ rather than Ruby, as each language shapes problem-solving approaches differently.
  • 00:13:00 — Conclusion and call to action — Cottrell concludes by acknowledging that changing toolsets and being intentional about tool selection is difficult work. He applauds listeners for engaging with these challenging ideas and encourages them to apply the concepts, have conversations about them, and even disagree with points made in the episode. The host emphasizes that this intentional approach to tools can help developers reach their potential and work with greater purpose.

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2018-03-07T10:00:00Z
  • Duration: 00:15:55

References

Podcast Info

Transcript

[00:00:00] I want to ask you a simple question. Are you using the tool set that you’re using today

[00:00:09] because someone showed it to you or because it’s the tool set that you chose to use?

[00:00:18] In today’s episode, we’re talking about tools and we’re talking about this on a grand scale,

[00:00:24] not just choosing programming tools, right? Not just editors or actual languages or frameworks or

[00:00:34] stacks. That’s not what we’re focused on, although those tools are included in this discussion.

[00:00:40] We’re focusing on how we interact with the world, really, but with tools that we create.

[00:00:49] My name is Jonathan Cottrell and you’re listening to Developer Tea.

[00:00:52] My goal on this show is to help

[00:00:54] driven developers connect to their career purpose. And if you’re a driven developer,

[00:00:59] then you know how important this is if you have done it, right? The reason that this is so

[00:01:06] important to connect to that underlying purpose is because that will act as fuel for you.

[00:01:14] This is kind of a soft subject. It’s difficult to talk about in objective terms because it’s so

[00:01:20] hard to kind of generalize this.

[00:01:24] This kind of thing of this soft subject of purpose. But those of you who have found your

[00:01:31] career purpose or that you’re working on finding that career purpose, you find that the work that

[00:01:37] you do ends up being better, right? And that really is what this show is about. And so we’re

[00:01:42] serving the people who are seeking after that career purpose, not only by helping you find it,

[00:01:48] but also by guiding that work to be better.

[00:01:54] Focusing on these practices and principles, right? So today’s episode is kind of a principle,

[00:02:02] but it really is a marriage between principle and practice. And we’re going to find this over

[00:02:08] and over on Developer Tea, this kind of mix of practice and principle. But today’s episode,

[00:02:15] we’re talking about tooling and we’re talking more specifically about our interaction,

[00:02:21] our relationship with our tools.

[00:02:24] So what is a tool? For developers, of course, languages are tools and the editors are tools.

[00:02:33] Of course, if you zoom out further from that, then the computer itself is a tool. And of course,

[00:02:38] all of the software that the computer runs, those are tools as well. But so is the desk that the

[00:02:46] computer is sitting on. And so is the mouse that you use. And so is the chair that you sit on. And

[00:02:52] in fact, so many things are sitting on the desk. And so is the computer that you use. And so is the

[00:02:54] perhaps all of the things that we make could be classified as tools. So we aren’t going to

[00:03:01] prescribe necessarily what is and what isn’t a tool on the show. Although most things that we

[00:03:08] would consider tools have some sort of functional purpose to them. But that’s not always necessarily

[00:03:14] true. But again, let’s not get too deep into the semantics. So when we’re talking about tools,

[00:03:20] we need to recognize that so many things,

[00:03:24] we rely on on a daily basis, could be considered tools. So why is this important? And what is our

[00:03:31] relationship to these things that are around us? We’re going to talk more specifically about the

[00:03:38] human relationship to tooling right after a very short sponsor break. Today’s episode is sponsored

[00:03:45] by Linode. Linode is an excellent tool. Speaking of tools, Linode is an excellent tool. And we’re

[00:03:51] kind of giving away a little bit of what we’re talking about. But we’re going to talk a little

[00:03:54] bit about what we’re going to talk about in a minute. But the reason that Linode is an excellent

[00:03:58] tool, or one of the many reasons it’s an excellent tool, is because it’s built with you in mind. The

[00:04:04] tool is actually shaped so that you have a better experience as the user of the tool. It’s intended

[00:04:14] to be used, rather than you kind of coming along and using a Linux server, and it meeting only your

[00:04:22] functional needs. Linode is an excellent tool. It’s intended to be used, rather than you kind of

[00:04:24] give away a little bit of what you’ve been needing. But the actual experience is one that

[00:04:26] is alongside Linux. A lot of 되게 nice things probably won’t work for it as well as a good

[00:04:28] skill tool, but then again, it’s a lot easier tostation automatically. It’s not a workbook

[00:04:29] that goes beyond that. It looks at your behavior as a developer, Linode, has provided to you

[00:04:31] various features, like for example, a leash console. If you don’t know what lishes, you’re

[00:04:34] not alone, I didn’t know what it was before I heard of Linode. But lish allows you to

[00:04:38] access our server even if you’ve locked yourself out. And this is looking at the human side

[00:04:40] and shaping the tool to the human rather than forcing the human to work with and vengeful

[00:04:43] against you, rather than from our systems to make those things that we need to have

[00:04:50] an automated function that has become twenty five algorithms to program your stirring obtains

[00:04:52] forcing the human to work with a brittle or otherwise uninformed tool.

[00:04:58] Go and check out what Linode has to offer.

[00:04:59] They have excellent plans starting at $5 a month for the entry-level plan,

[00:05:05] which gets you a gigabyte of RAM, by the way.

[00:05:07] This is not a useless plan.

[00:05:10] This is not just a hobby plan.

[00:05:12] You can actually launch a pretty decent application on a server that has a gigabyte of RAM.

[00:05:18] Go and check it out, spec.fm slash Linode, to get started today,

[00:05:22] and you’ll get a $20 credit to your Linode account if you use the code DEVELOPERT2018 at checkout.

[00:05:29] Thank you again to Linode for creating excellent tools for developers.

[00:05:34] So we’re talking about tooling today, and by the way, speaking of tools,

[00:05:37] there is a show on spec.fm that I want to highlight for a second, Tools Day.

[00:05:44] Tools Day is hosted by Una and Chris.

[00:05:48] Go and check it out.

[00:05:49] They talk about various tools, and this is particularly good for front-end developers.

[00:05:55] Again, head over to spec.fm.

[00:05:57] Tools Day is there on spec.fm.

[00:05:59] It’s also available at toolsday.io.

[00:06:03] So we’re talking about tools, though, and we’re talking about beyond just these programming tools.

[00:06:08] We’re talking about things that we create in the world and use as tools.

[00:06:13] And if you look around you, even the clothes that you’re wearing,

[00:06:17] you could consider.

[00:06:18] You could consider these a tool.

[00:06:19] And I want to bring up this interesting interrelationship that we have with our tools.

[00:06:25] If you imagine your life without them, just for a moment,

[00:06:30] this is kind of a difficult mental leap to make,

[00:06:33] but imagine your life without any of the things that you have that surround your kind of day-to-day operation.

[00:06:43] Without your clothes, without your computer,

[00:06:46] without any of these.

[00:06:48] These obvious things, but also without the less obvious things,

[00:06:52] like even your utensils that you use to eat your food.

[00:06:56] The very simple reality is that your life would be drastically different.

[00:07:03] And so as you add new tools into your life, your behavior will change.

[00:07:10] So it stands to reason that any tool that you encounter and that you integrate into your day-to-day life,

[00:07:17] could very well change your behavior.

[00:07:21] Marshall McLuhan is credited with a quote,

[00:07:26] and certainly with the idea that we first shape our tools,

[00:07:33] and then after that, and I’m paraphrasing here,

[00:07:35] after that, our tools shape us.

[00:07:38] And we’ve kind of illustrated this point by making that kind of mental leap

[00:07:42] into a world without any tools whatsoever,

[00:07:45] and then adding one to it.

[00:07:47] One tool at a time, and watching that behavior change take place.

[00:07:52] But if you think about your behavior in your job,

[00:07:57] for example, even the programming language that you use

[00:08:03] is going to change the way you use your hands on a day-to-day basis.

[00:08:09] Now this is a seemingly insignificant change, of course.

[00:08:13] If you’re writing Lisp, for example,

[00:08:15] then you’re going to be much,

[00:08:17] much more able to find the parentheses keys, right?

[00:08:20] Because there’s significantly more parentheses

[00:08:23] designed into the tool that is Lisp.

[00:08:27] But if you’re a developer, and you’re like most developers,

[00:08:31] then you’re also going to, very likely,

[00:08:33] spend a lot of your day sitting at a desk,

[00:08:36] or standing at a desk, staring at a screen.

[00:08:41] And in this way, our tool is shaping us,

[00:08:44] quite literally shaping our physical,

[00:08:47] physical bodies.

[00:08:49] And in what other ways can our tools shape us?

[00:08:54] Well, even from a cultural perspective,

[00:08:57] let’s take Ruby, for example.

[00:08:59] One of the main kind of ideas in the Ruby community

[00:09:04] is to optimize for developer happiness.

[00:09:08] And what does this mean?

[00:09:09] Well, it’s a value set that the developers of Ruby

[00:09:12] have continued to pursue over the years

[00:09:16] that Ruby has been around.

[00:09:18] And it informs the way that the language is designed,

[00:09:21] but it also informs the way that the community

[00:09:24] engages with the language.

[00:09:27] To various degrees, Ruby developers will view Ruby

[00:09:32] from the perspective, or maybe from the kind of evaluation point

[00:09:37] of how happy does Ruby actually make me?

[00:09:41] So even in the intention of the tool,

[00:09:44] we are shaping later behavior.

[00:09:47] So why does this matter?

[00:09:49] What is so important about this?

[00:09:51] Well, the takeaway that I want you to have from this episode

[00:09:55] is that as you choose your tools,

[00:09:58] I want you to think more about how consequential

[00:10:02] those choices may be.

[00:10:05] Now, we’re not talking about how consequential they are

[00:10:08] in terms of your kind of marketability as a developer.

[00:10:11] Of course, that’s something that is relevant,

[00:10:13] and something that you should consider.

[00:10:16] But it’s not the only consequence that you have

[00:10:19] as a result of learning or using a particular tool.

[00:10:23] I talked further about this with Mark Engelberg,

[00:10:26] the creator of the Code game series.

[00:10:30] These are board games for children and adults,

[00:10:34] and everything in between,

[00:10:36] that teach you programming concepts.

[00:10:38] Mark and I discussed learning first

[00:10:42] through a functional paradigm.

[00:10:45] So learning through, in particular,

[00:10:48] Mark is a proponent of closure,

[00:10:52] and learning closure first,

[00:10:54] and how learning closure first

[00:10:56] can change the way you think about programming.

[00:10:59] Because this tool is designed in a particular way.

[00:11:03] We have a shape with our tools.

[00:11:07] Our tools have a form,

[00:11:10] a way of existing and behaving.

[00:11:14] And because we use them,

[00:11:16] because we interface with those tools,

[00:11:18] we also take a shape.

[00:11:21] We also conform in some way to that tool.

[00:11:26] So what we should do,

[00:11:28] or what we have the opportunity to do,

[00:11:31] is try to determine the form

[00:11:34] that we want to take first.

[00:11:37] Rather than choosing our tools,

[00:11:39] and allowing them to shape us

[00:11:41] into a form that we had not yet considered,

[00:11:44] perhaps we can consider

[00:11:46] what form we want to take first.

[00:11:49] Perhaps you want to work on problems

[00:11:53] that are dealing with big data, right?

[00:11:56] Well then, if you look at the current tool set,

[00:11:59] then it’s very likely that you’re going to end up

[00:12:02] using something like Python,

[00:12:04] or maybe a more performant language like C++.

[00:12:08] Choosing another language, perhaps like Ruby,

[00:12:11] may put you into a shape

[00:12:13] that you didn’t want to be in, right?

[00:12:16] Because the tool will kind of require you

[00:12:20] to conform to a shape.

[00:12:22] Now this doesn’t impose on us

[00:12:25] in a way that we can’t avoid.

[00:12:27] The shaping that our tools do to us

[00:12:30] is something that we usually are volunteering for.

[00:12:34] But what often tends to happen

[00:12:37] is we’re not evaluating that interchange.

[00:12:41] We’re not evaluating our relationship to those tools,

[00:12:45] and very often we’re not evaluating

[00:12:48] whether it’s time to change those shapings.

[00:12:51] Whether it’s time to change our relationship

[00:12:53] with a given tool

[00:12:55] in order to form differently.

[00:12:58] Thank you so much for listening

[00:13:00] to today’s episode of Developer Tea.

[00:13:02] I hope you found it encouraging,

[00:13:04] enlightening,

[00:13:06] but perhaps most of all,

[00:13:08] I hope you found it challenging.

[00:13:10] Because this is not easy stuff.

[00:13:12] It’s not easy to change your toolset.

[00:13:15] And it’s not easy to imagine

[00:13:18] this future that you want

[00:13:20] and then try to choose your tools

[00:13:22] based on that.

[00:13:24] That’s a difficult process.

[00:13:26] And I applaud you for doing this.

[00:13:29] I applaud you for listening to this episode

[00:13:32] because you’re taking hard steps

[00:13:34] that other people,

[00:13:36] many people,

[00:13:37] are not going to take.

[00:13:39] If you apply these kinds of things,

[00:13:41] the things that we talk about on the show,

[00:13:43] if you apply what we talk about,

[00:13:46] then you’re going to put yourself

[00:13:48] into a different category of person.

[00:13:51] You’re going to put yourself into

[00:13:53] a different category of developer.

[00:13:55] We talk about being a great developer all the time.

[00:13:58] And it’s not about leveling up above your peer.

[00:14:02] It’s about reaching your own potential as a developer.

[00:14:05] It’s about unlocking something

[00:14:07] that you actually care about doing.

[00:14:09] You actually get up in the morning

[00:14:12] and you’re excited to get to work

[00:14:14] because you care about what your purpose is

[00:14:17] as a developer.

[00:14:18] So I applaud you

[00:14:20] for taking the time to work on your career,

[00:14:23] listen to these episodes,

[00:14:25] and apply the things that you learn

[00:14:27] and also challenge the things that you disagree with.

[00:14:30] Everything we say on the show isn’t solid gold.

[00:14:33] Definitely far from it.

[00:14:34] My hope is that you’ll take this episode

[00:14:38] and you’ll have good conversations.

[00:14:41] You’ll ask good questions.

[00:14:43] You’ll get so fired up about something

[00:14:46] that you disagree with on the show

[00:14:48] that you do something about it.

[00:14:50] I want to incite action on your part.

[00:14:53] So if you’re fired up about something

[00:14:55] that we talk about on the show,

[00:14:57] I want to hear about it.

[00:14:58] I love hearing stories from listeners.

[00:15:01] You can email me at developerT at gmail.

[00:15:03] You can also reach out to me on Twitter

[00:15:05] at at jcatrell

[00:15:06] and the official podcast Twitter

[00:15:09] at developerT.

[00:15:11] Thank you so much for listening.

[00:15:12] Thank you again to today’s sponsor, Linode.

[00:15:16] Once again, Linode is an excellent tool

[00:15:18] because it’s not just a crude tool.

[00:15:21] It’s not a primitive tool.

[00:15:23] It has been shaped beyond that.

[00:15:25] It’s the next level of service

[00:15:27] that you need as a developer

[00:15:29] in your Linux cloud provider.

[00:15:31] Head over to spec.fm

[00:15:33] to get started today.

[00:15:35] And the code should automatically apply.

[00:15:37] But if it doesn’t,

[00:15:38] use the code developerT2018 at checkout

[00:15:41] and you’ll get $20 worth of credit.

[00:15:43] Thank you again for listening.

[00:15:45] And until next time, enjoy your tea.

Visão de gráfico