Autoscaling is a simple concept. Automatically add resources when needed, and automatically shut them down to avoid paying for excess capacity. How hard could that be? If you've set up Autoscaling yourself, you know it's not that easy, especially using the native Autoscalers on platforms like AWS and Heroku. That's why you need JudoScale.
JudoScale is Autoscaling as a service, and they make Autoscaling simple and easy, as it should be. You can use JudoScale on AWS, Heroku, render, fly.io, and more. It's free for low traffic apps, and unlimited plans start at $25 per month. Autoscale on easy mode at judoscale.com. Hello, and welcome to another episode of The Bike Shed, a weekly podcast from your friends at ThoughtBot about developing great software.
I'm Sally Hall. And I'm Joel Kenville. And together we're here to share a bit of what we've learned along the way. So Joel, what's new in your world? I've been doing a lot of work in TypeScript recently, and something that's really interesting about a Type system is that it often takes a lot of things that are implicit in your program and makes them explicit.
Something that I've been digging into a little bit is how much uncertainty you add to your program when you index into a collection. So this might be taking an array and using an index to pull an item out of it or taking a map. This is equivalent to a hash and Ruby and indexing a key out of that. Because you're never guaranteed that you're going to get an item back. You might get undefined.
Type checker tries to keep you honest and we'll say, hey, did you remember to check for the case where that value is not present? I have just started experiencing that as my first project with TypeScript. And I've been sort of categorizing on this uncertainty, taking a little bit of inspiration from Fred Brooks' paper, No Silver Bullet, where he sort of breaks down complexity and software into essential complexity, which is sort of inherent to the problem you're working with versus accidental complexity, which is complexity you've introduced by your particular choice of implementation. And I feel like a little bit of that applies to nullability or uncertainty that you've introduced to your program. Some of it is just inherent to the software you build.
Like if you're dealing with user input, you can't trust that. You can't guarantee that they submitted all the fields on a form, things like that. And so that's inherent. But there's other things that are sort of implicit to the choices you've made for your implementation. And I think that oftentimes choosing an algorithm where you're indexing into a data structure can introduce some of that accidental uncertainty to your program.
And then you're sort of handling perhaps with a comment that says they should never happen. Or you're dealing with sentinel values, or you're doing all these hacky things to sort of like just make the compiler happy. Or you have to consider a different algorithm where you don't index. Yeah, that's interesting. And the idea of like, do you tell TypeScript to shut up?
Do you deal with it just enough that TypeScript stops complaining about it? Or do you actually address the root of like, what am I doing here and what did I intend to do here? And some of that comes down to you like, what are you working on and how much time do you have to dig into a totally different algorithm? Or you don't face this problem? Sometimes maybe also sort of upfront, right?
This is a way of thinking that you're used to. Maybe you don't reach for very index heavy algorithms upfront, or you're just much more aware of the risks that go around them. The edge cases you have to handle for an algorithm that's very index heavy. Yeah, this is actually making me realize that like, indexing something is one of those things that I always like see as a flag, not necessarily a red flag, but maybe a yellow flag when I'm looking at code. Okay, it's a little bit like every, you know, if you see hard-coded strings everywhere, sometimes that's a flag for me to go, hmm, is this something that we could be doing differently?
And so whenever I see like an index survey in a piece of code, my first thought is always like, why are we doing that? Is there a different way to do that? How do we know what index is right? Because the other thing is I don't really trust myself to pull out of my brain exactly the right way to index the element I'm looking for. That's the danger of telling TypeScript to shut up, right?
Is the trust me, I'm gonna do this right. There will not be a bug here. We'll backfire on you pretty frequently. Yeah, yeah, the phrase, don't worry, I know what I'm doing is almost never true. I feel like when I was in college and I had to do a lot of C++ projects.
And I knew it to C++ and I'm not a very good programmer because I'm a college student. And the number of times where I was doing some sort of iteration pattern using a classic for loop and had some sort of off by one error in my indexing or some other subtle boundary condition were really high. And then post college when I discovered Ruby and I was like, oh, there's just an each loop where you can iterate through a collection and you never have to bother with indexes. That's a whole class of bugs I never have to think about. That was one of the things that sold me on Ruby was that, oh, I can do this thing without having to worry about this class of bug.
Yeah, and that's probably why it feels like a flag to me is that I mostly work in Ruby and Ruby you very rarely need to do that. There's tools built in that let you, I feel like the enum class is very powerful in Ruby. If there's something you wanna do and you're trying to write it yourself, there's very likely something already built in that can help you out with that. Exactly, it's a definitely a smell to not be using the idiotic way of doing things. And in TypeScript or JavaScript, similarly more modern versions have the ability to iterate over a collection without having to manually do it via indexes.
So JavaScript has that for in construct. It's a little bit like Python's list comprehensions and arrays have a for each method that will accept an anonymous function to iterate over an array. And so both of those allow you to go through an array and not have TypeScript yell at you in the way that it would if you were doing classic for loop. In some ways, I guess maybe the, in this case, the TypeScript pushes you towards using more built-ins rather than going low level and doing it all yourself. So Sally, what's new in your world?
Well, funny enough, also TypeScript related, which is that I tend to work a lot more with Ruby and Rails than with any other language. But I'm currently working on a project with a lot of React and reusing TypeScript. And I have mixed feelings about JavaScript in general, but TypeScript is really growing on me. At first, it was very annoying because I didn't fully understand it and it would yell at me about things that I didn't know why it was there but TypeScript's business even be thinking about. But now I really like, first of all, that like TypeTucker will say like, hey, this might be undefined or this might be null.
Are you sure you wanna do this? But I'm also finding that it's just really nice, especially with more complicated parts of the app to know exactly what shape something is supposed to be. It's one of the things that I occasionally will get frustrated with in Ruby is looking at some code and going like, okay, I don't know what kind of object I'm supposed to pass to this or what kind of object this is gonna give me back. If it's not something familiar with or it's not what document it or it's just not clear. And I like that with using TypeScript, I generally have a pretty good idea of what to expect and where something's coming from as far as like, what kind of object is this?
So the idea of types of documentation is really appealing to you. It is really appealing to me. Yeah, yeah. And using TypeScript or the TypeScript checker as a way of knowing that things are at least going around in the shapes that they're supposed to. I've also find it really helpful sometimes when I realize I need to add an attribute to something and I add it in one place, but there are other places where I need to account for it and without TypeScript, those would just be undefined or null and that would be a surprising bug later on when I'm like, why isn't this working the way it is because it's not expecting this attribute and it's there or because it is expecting this attribute and it's not there.
And so I think it just helps me be a little more thorough too. Do you find that having types has impacted the way you test? Not entirely. Like we've got a React frontend using inertia with the Rails backend. So I tend to sort of lean towards testing the way that I'm comfortable.
So we are writing frontend tests for the components we're creating, but sometimes I'll just go with like, you know, this really makes more sense as a Ruby system test or Rails system test. And so like in general, just because of where my comfort is, I'm maybe not writing as many tests using JavaScript as I could be. So it hasn't really affected it, but I, it's still early and I could see that affecting the way I test for sure. Do you think that maybe the types give you confidence it's similar to what you would have from unit tests in the frontend code and maybe that helps you feel not quite as much of the need to have like a really thorough, sweet-of-unit test on the frontend?
That's a really good point. You know, I think it does. I think it has been giving me confidence and I just kind of didn't even think about it. So some things that I feel like I would have needed to manually check in and unit test, I know are already checked by TypeScript. So I can sort of avoid those or skip over some of the more tedious edge cases that handle with just having an untied language, which has been nice.
I guess that's one of the really nice things about having a type checker that does know about nullability is that you get to mark in your program. These are the places where the data is guaranteed present. And these are the places where it may or may not be present that we need to do presence checks. The type checker then guarantees that those are true. So in a unit test, if you were to write a unit test, you don't need all those edge cases that we would write in Ruby like, oh, what if you pass a nil?
Because an edge case has already been eliminated by the type checker. Yeah, it speeds things up a little bit and it's nice to be able to check those off my way list and worry about other things. I mean, that's exciting to see that you're diving into more of the frontend, getting into TypeScript. I'm sure we'll hear more about that over the course of the season as you sort of unlock new sort of aha moments. Maybe that's a thing to check in on in our recap episode, the hey, now you've been doing TypeScript for 12 weeks.
Here were your initial thoughts. How are you feeling now? Yeah, it will be interesting to see. Does it continue to grow on me or does our relationship turn sour? Stay tuned.
Have you ever tried to debug an issue in production while switching between your error tracker, log viewer and APM tool? Maybe you know how painful it is when you can see the error but can't find the relevant logs or when you see slow performance but it can't connect to the root cause. Scout monitoring is all in one platform built to make your life easier with log management, performance tracking and error monitoring coming soon. All of your data will be together at last. We'll go from bug to fix in one place.
The result, less context switching, faster debugging and monitoring that actually helps you ship code instead of distracting from it. No DevOps team, no problem. Scout works with your existing stack and gives you insights in five minutes, not hours, from bug to fix in one place at ScoutAPM.com. So learning types when you're getting into TypeScript is sort of one of the many tools that we have to learn as programmers to get good at our job, especially if you're writing TypeScript. Something I wanted to explore more today is a little bit of what is the skill in software development.
I think that's sort of classically phrased as the, what exactly would you say you do around here? I'm a people person. Yeah, I think that's a really interesting question and something I think about a fair amount, especially as the field of software development is always changing, but I feel like there's been bigger changes with AI tools and sort of like, what's my job and what's the tool stop? Yeah. One of my kids is actually considering software as a career.
And so thinking about sort of what are the ups and what are the downs and which parts of it appeal to him and align with his interests and skills has also been interesting conversations. And I think what I think the skills in software development are I think maybe would be a little surprising but might sound kind of generic and silly and that is evaluating information and solving problems. Let's break that down a little bit. How does that maybe differ from, I don't know, like a strategy consultant? It's possible that it doesn't entirely.
Ooh, all right. I sort of brush aside the ideas of like familiarity with a language or syntax or like knowing exactly which characters to type because that's less a skill and more just like familiarity really, right? You can learn a context but whether or not you have the skill to then use those tools that you've learned is different. So first of all, evaluating information. I used to work at a coding boot camp and something that I saw a lot of really new developers do is when they get an error message, they don't read it and they panic.
I think from more experience developers, we know that error messages are your friends, right? Especially in a good system, the error message is going to tell you what went wrong. Hopefully it'll tell you where it went wrong. And sometimes it's even going to give you a suggestion for how to fix it. So being able to read that error message, understand the system that generated the error message what they think is wrong.
And then use your context clues and critical thinking skills to go, is this actually what's wrong? Or is this sort of a red herring and there's a problem and this just happens to be the layer where it exploded enough to give me an error? A react thing I've been seeing a lot in my tests is that sometimes I'll get an error that a color is undefined, which feels very weird. And I've come to realize that when I got that error, it usually means I have it mock something, I need to mock in the test. Fun.
But if I didn't have the critical thinking skills to dig into that and explore around it, I could get stuck on how do I define this color? When that's actually not the problem at all. So I guess there's sort of like, I don't know if I want to call it data, but there's sort of a bunch of facts you need to know about your particular programming language and environment. But just knowing those facts doesn't make you a good programmer. Those are often things that you focus on when you're a very junior.
But then what you do is you layer on that critical thinking that you're talking about and you sort of add that logic on top of the facts that you know and that's what takes you to the next level. Yeah. And I think it's also, none of us are born with a complete language syntax in our brain, obviously. Like all of us look things up on a daily basis in our jobs for the most part, I think. And so yeah, I think you mentioned before the idea of like, oh, I just Google things, that's my whole job as a software developer.
And I have a sticker somewhere from a like a spoof on an O' Riley book called Copy and Pacing from Stack Overflow, which is like fun to joke about. But that's really like, that's sort of part of what I mean by evaluating information. You know, there are any giving question on Stack Overflow is gonna have a variety of answers. And how do you decide which one is correct or if any of them are correct? And I think that's the skill that we develop over time as developers is sort of an instinct for like, that looks reasonable.
I understand why that would fix my problem. And I know how to try it safely versus, I'm just gonna copy and paste this into my Chrome developer console and hope that my computer doesn't explode. And to me, I feel like that's one of the things that will hopefully keep us employed despite AI for a little bit longer. So AI can read everything and, you know, parse it and put it back together in various ways. But from what I've seen, it's not great at like critiquing that information yet and evaluating sources of information.
And so that's where I think the human skill is still really relevant. I'm interested in digging a little bit further in the idea of programmers as sort of expert Googlers because I feel like that's often a thing that is a source of insecurity for maybe more junior developers who feel like the way you're a good programmer is having an encyclopedic knowledge of a language and syntax. And therefore having to Google is a like a mission of failure. And on the other side of that, I often see sort of more experience developers trying to sort of maybe address some of that fear by telling junior developers, no, like I Google all the time, like that's basically my whole job. I do all the Googling.
And in the one sense, that seems true, right? We look up things all the time. But on the other hand, it's also not in that we've sort of gone beyond the phase where we, the core of our competency is that knowledge. And now we're just doing sort of reference lookups in order to obviously do our actual job, which is that critical thinking. The idea of a reference lookup as a specific kind of Googling is interesting to me.
Like how would you describe Google searches as a software developer that aren't reference lookups? I feel like most of them are reference lookups depending on how strict you are with the term. Oftentimes, I'm just using this as a way to like find the documentation on a particular method. Or maybe I don't even know the name of the method, but I'm like, what is the method that allows me to filter down a collection or something like that? Especially if I'm in a language where I'm less familiar where I'm like, oh well, Ruby has this, but what is the equivalent in this other language?
Sometimes you're Googling error messages. I guess that's a form of reference lookup-ish, but the things you're looking for might be more blog posts or stackover flow answers than they are particular reference documentation. Sometimes you're Googling more for like, hey, here's a general problem. What are sort of common solutions to this? That's more of an exploratory, like let me understand the solution space.
And that might be for libraries, like, hey, I'm doing authentication in Rails. What are the like three common ways people do that? Or it could be for something more generic. And you wanna see sort of what are the types of abstractions that people are using or how do people tend to approach this problem? And now you're sort of much more in the realm of getting opinions rather than getting reference material.
So I don't know if that all folks under reference lookups? Yeah, I guess it sort of depends on how you define it. Do I just want, you know, show me the syntax for looping over an array in this language or do I want, show me the various approaches to authentication, sort of different kinds of references for sure. And I think it comes down to, I started to realize as you were talking that like, a lot of that comes down to what question are you asking and how are you asking it? And so I think that's another, maybe not entirely different, but another aspect of a skill of a software developer.
And for us as consultants, even more so is asking good questions. So if you're talking to your client, or if you're talking to a colleague, or if you're talking to Claude, or if you're talking to Google, the information you get back is gonna be largely based on what you asked. So if I'm googling like JavaScript array loop, I'm probably gonna get some specific things about syntax, but I'm not gonna get maybe higher level things about like how do I know when to use this versus that, or what are the upsides and downsides and things like that? And like you can have to think about what information am I really looking for as part of asking your question. And with consulting, it's similar to saying, not saying, hey, do you want this to be red or blue, but saying like, what do you want this color to communicate?
Those are two different questions and you're gonna get very different answers. I have a note in my personal note-taking system where the title is, Consultants are Professional Question Askers. Yes, we are. And I think that's true of software developers who aren't consultants too. Like very rarely are we writing software in a vacuum alone for ourself alone.
So even if you are a one person team developing software alone, if anybody else is gonna use it, you've gotta ask, even ask yourself some questions about how they're gonna be using it. Yeah, and oftentimes people will do that sort of old school in a paper notebook, right? You're faced with a large problem and you're like, let me write down what are my open questions about it, and then that'll help me think through the problem. Yeah, and can often lead to the rubber duck situation we talk about where Jeff, through the process of me writing down what my questions are or saying them out loud to you or a rubber duck on my desk, I come up with answers. Sometimes writing the good question or developing the good question turns into the answer and you don't actually end up needing to ask anybody else or to Google it.
I'm gonna take this in a slightly, maybe weird direction. Ooh, I'm sorry. This idea that one of the key developer skills is asking good questions. And a little bit of that goes into like, how do you Google for things well? In AI age, could that also translate to being good at writing prompts?
Oh, absolutely. I've heard the phrase prompt engineering, and that seems maybe a little over complicated, but it's also true. It's not gonna answer the question that you didn't ask, but what we're thinking of is gonna answer the question that you asked. In your experience, what makes a good AI prompt? Have you spent much time thinking about how you write those?
I've definitely found that one thing you have to be careful with is that some AI are very agreeable, like they really want to agree with you. And so if you want an honest opinion, you have to phrase things in a way that will actually give you something useful. I find it's often useful to ask about sort of the landscape of solutions. So that question like, hey, I have a problem X. What are sort of three or four common classes of solution for this type of problem?
This is the five-minute more exploratory phase. Right. So it's kind of like asking Google, except that like with Google, you've got to like sift through a lot of results. And it's just a lot of work to like find the pieces that you need and something like chat JPT might do that synthesis for you. Now it might entirely miss a class of solution, which is something you have to be aware of.
But then so would googling, because maybe it's not on the first page of results. And so you might miss it that way as well. Or even asking a human. It could be that there's a class of solutions that the human you've asked, even if their next word are not familiar with, or if they don't prefer it, so they're not going to mention it, or for any number of reasons. I had a situation like this where I was doing some kind of AI-assisted development, and I was asking for pretty complex array transformation in TypeScript.
And this is at a time where I was newer to TypeScript, and I was leaning on LLM to help me get to a solution. And I didn't like the way it built a solution. And I asked it for a broader like, show me like different families of solutions. And it did, but I didn't like any of them. And at some point I had to say, hey, can you show me a solution inspired by the way that certain type of functional language would solve this?
So I'm pretty sure that the Haskell community does something that's closer to what I'm looking for. And with that prompting all of a sudden, I was like, oh yeah, that other thing, let me show you. And that was exactly what I wanted. And so I think having for myself a little bit of a sense of the landscape was useful, because then I could say, hey, I don't remember what the Haskell community does. And it would probably take a lot of googling for me to find exactly what I'm looking for, and to translate it into TypeScript.
But just giving it that pointer was enough to say, oh yeah, this other class that I forgot to even show you, how do you feel about this? And I'm like, oh, that is much closer. Now I can iterate on it and actually have something I like. I feel like that's a great example of asking a question and then asking a better question. But it's also an example of the skill you use to evaluate all of the first answers.
If you weren't a skilled software developer, you likely would have just taken the first one and gone with it. And it might have worked. But it's not going to be the ideal solution or the solution that fits in with all the other context that even if you gave to your AI agent or whatever you're asking, you might not synthesize it the same way that you do. Yeah. And in this particular case, some of the solution classes that it gave me were overriding the type checker, which a lot of TypeScript devs are totally OK with.
But that made me uncomfortable. So it's like, can we look at different approaches to the problem that are not overriding the type checker? Some of them were sort of extremely verbose or didn't compose very well with something else that I wanted to do. So yeah, like you said, that ability to analyze was really helpful. Sadly, I think another thing that's really valuable is just a little bit of that personal memory index of a little bit of what's out there.
And what's nice with tools like Google, with tools like LLMs is that you don't need to remember precisely what it is, as long as you just have enough of a fuzzy description of it, these tools can help bring it up for you. So in my case, it was, hey, I feel like a Haskell community has a solution for this. Can you show it to me? And I found it immediately. Whereas if I'd never done any functional programming, I would have missed that entirely.
And so would the LLM. Because LLM has massive amounts of information. And it's not going to know it's making a lot of, quote, decisions on the background every time it answers the question of yours. And if you were asking about TypeScript, and the solution you wanted was in Haskell, there's good reasons that LLM wouldn't have reached for that solution, even though it's translatable to what you were doing. I feel like I'm seeing a bit of a tension here that we're saying that the core thing that is important about software developers is not that like sort of base knowledge and just memorizing facts is about that more like critical thinking.
And yet in order to be good at critical thinking, you need to build up a base of facts to work off of. Yeah. And maybe you can mitigate that to a certain extent via tools like LLM's Google, good old fashioned reference books where you don't have to memorize it all. But you do have to know just enough about the landscape to be able to like guide your searches. Yeah, it seems like there's sort of like this incremental approach where it's like you learn enough about the language to be able to ask a question.
And then you get some answers and you evaluate them. And then as you work with it more, you learn more about it. And you're able to critically think about it more. And the more you understand, the better you're able to sort of evaluate the information. So it's critical thinking and information evaluation and asking good questions alone.
Obviously, it's not going to write you an app. You also do need to kind of understand what are the tools I'm using? What is the language? What are some specific gotchas or specific features or approaches that have historically worked in a situation like this? I think that's where sort of we as very senior developers have sort of like moved past a lot of things like syntax where, you know, oh, I got the syntax wrong.
I'll fix it. Or maybe even an LLM can fix it for me. Or a Rubocop can fix it for me. Or some other tooling thing. And that's not really a thing we think about all that much.
Because most of our thought is in the solution space versus someone who's more juniors putting the majority of their thought and how do I structure this correctly? How do I get the syntax rate? How do you think you sort of bridge that divide? Yeah, that's interesting. And just it immediately made me think of when I was first learning to code and when I was working in a code school and helping other people learn to code, it's really hard to find good learning resources for that middle period.
There's a lot of stuff online that I'll guide you through learning the early stuff. And there's a lot of blogs and resources that will help you solve the more abstract problems once you're more developed. But there's not a lot of resources available for bridging that up because it's really hard to do. And I think the answer for me in my experience is just keep practicing, keep failing and trying and asking questions and testing answers over and over again, which is not an exciting answer. But I think it's sort of like, it feels like a gradual shift from like, I'm mostly syntax thinking to more problem solving thinking or holistic architecture thinking.
I don't know. What do you think? Do you have a way to bridge that gap other than just do it over and over again? And if you can get a mentor or somebody to support you, that's really great. Ideally, a company is doing this for their junior developers, giving you an opportunity to work with more senior people where you can sort of pick some of those things up.
I think introspection is generally really helpful as well, pausing and thinking like, hey, I solved this problem in this way today. I chose this solution this way. Why did I choose that? Learning to flex that decision muscle pretty early, having to explain yourself. I think a great way of doing that is just explaining your rationale on in your PR description or in your commit message.
And it doesn't have to be a whole essay or any of me, a few sentences. But I say, hey, I was faced with this problem. I Googled and found these like three different stack overflow solutions. I went with this one because I think that it has fewer security downsides or is a little bit more concise or whatever your particular reasoning was. And it's OK to get the wrong answer.
Maybe a more senior person will say, hey, I'm glad you thought this through. But you may not realize that other solutions preferred for these reasons. But it gives you a small area to start flexing that muscle and to work beyond just the memorize everything to critical thinker. And I think you can get some of the same benefits from reading other people's PRs. I've heard junior developers often say, I'm not qualified to review that very senior developers PR.
What do I have to tell them? Which I think is only one piece of a PR review. First of all, you might have something to tell them. You might have an interesting thought that differs from what they did. But also just reviewing it and asking questions and seeing how they thought and how they explain their thoughts and understanding how it fits in is hugely beneficial.
Like feedback and error correction are not the whole point of the PR. It's also information sharing and just understanding. One of the most powerful things you can ask as a junior developer is why. And I've been doing that a lot as I've been getting more familiar with React, which I've always only used in bits of pieces. Say about half my comments on PRs that involve React recently have been, hey, I don't understand why you're doing this.
And I'm new to React. Can you sort of walk me through this? And that has been super helpful. I'd love to hear a little bit about what the experience is for you sort of going back into beginner mode. But you're not truly beginner because you have already such a vast knowledge of other software to build on.
And so you can recognize patterns. You're like, oh, this is like this other thing. And you also have critical thinking skills built really deeply. So in some ways you're returning to beginner world. But in other ways, you're very much not.
What does that experience like for you? It's been fun, honestly. I think a lot of software engineers love learning. Like that's part of why we're doing this. If you don't want everyone to learn again, this is probably not a great path for you.
Discovering new kinds of problems and new ways of approaching things, I think, has been really fun. It's also been kind of humbling to be like, I don't have any idea what this problem is. And I don't know how to fix it. And I absolutely just need to ask for help from someone. It's also been really interesting because at the same time that I'm getting used to React, there are pretty senior developers on the team who have never done Ruby or Rails before.
So they're doing the same thing. And it's been interesting to see sort of the Ruby and Rails patterns I'm trying to bring to JavaScript and React and the other patterns that people are trying to bring to Ruby and Rails. And sort of noticing the ways in which what I'm comfortable with influences how I work with something I'm not comfortable with. Like I was saying earlier that I'm going to try to write a test in Ruby as often as I can. Yeah.
Sort of the cross-pollination you get there. And it's the kind of thing that I'm really glad I'm doing it on a team. This is one of those times where having people who are more experienced than what I'm working on has been enormous. I've had jobs in the past where I was the only developer. And that's a great way to not learn anything.
It's kind of stagnate. Yeah. So it's like the thing that we do is not being encyclopedias of language syntax. And to a certain extent, it's maybe having at least exposure to a lot of these things. A little bit of indexing in our minds and the raw ability to think critically and break down problems and evaluate.
How do you feel about maybe a kind of a middle ground which is maybe not an encyclopedia of details like syntax, but maybe a deep familiarity with some of the big ideas of programming? Things that you might call fundamentals although I know that might be controversial. And this could be as far away as like, oh, you need to have a solid understanding of math to, oh, category theory would be good to, hey, maybe it's good to read or to have familiarity with some classic computer science papers. Anything you want to fit in that box of like big ideas from the software? Maybe some type theory.
Yeah. I mean, I think all of those things can be super helpful. I think the difference between like formally studying those things or even knowing like the official academic language around those things and understanding the concepts underlying them is sort of different. Like I don't actually know what you mean by category theory, but I bet if we talked about it for a minute, it's probably something that I understand and I just don't have that word for. I think as software developers where it's where we learn a lot on the job.
And so, you know, sure, you might learn some of these things if you're doing a CS degree. But also when you're doing a CS degree, you're usually doing it very young and very early and sometimes even entirely before your career is a programmer. And so you're still in that just memorization phase of learning and you might not get as much value out of the theory parts because you're just sort of memorizing facts and you don't have a framework to sort of fit it into. Yeah. Or it's just like detached theory floating in your textbook and your brain without necessarily a good way to apply it to the real world problems that you're seeing.
I think it's just a matter of like two different directions, maybe not just two, but you know, did you learn the theory and then figure out how to apply it to the real problems you're facing or did you just start solving real problems and through that process develop an understanding of the theory whether or not you have the right, the same terminology. And I think they're both super valid approaches and they most of us do a little each. I'm just sort of impressing the thing this in real time and now I'm seeing almost like an image of like a triangle of sort of three parts of our job. There's sort of always maybe intention or imbalance, one of which is just sort of a knowledge base facts that we have to memorize. Another one is theories, sort of ideas, lenses through which we can look at the world and understand things.
The other one is sort of raw, just critical thinking and knowing how to break down problems. Maybe sort of those three things or maybe the core parts of software, but maybe the public perception of our job is sort of over-indexing the just fact knowledge, the memorization syntax. I think that's a really good way of putting it. And I think you can build up all three vertices of that triangle in a lot of different ways in like, you know, pure studying of theory, researching, reading a lot, experience conversations, like all of those contribute to all three of those vertices in different ways that can all be really important. And I think, I just keep thinking about the different ways people come to this career that some people start out with like, you know, computer science degree and then move into like creating actual software and developing it that way.
And some people start with learning just enough code to do the thing that they want to do and then building on that. And at some point in that development, you can't really tell the difference between those to Google anymore. Although early on, it's very clear. Yeah. Everyone has their own journey.
Everyone's going to build up a little bit of those vertices, I think, in different areas. And I think each of those vertices on the triangle also sort of depends on the other two. So, you know, making critical thinking decisions, you might use a mental model or a theory on the theory end of things to help you sort of filter through ideas. And you definitely need a lot of sort of low level data and facts to make that decision. And then that will impact your critical thinking sort of decisions.
On the other hand, maybe you just, you have a bunch of like facts and data and you've made a critical decision. Now you're starting to see patterns emerging and say, Hey, I tend to make this decision in these situations. Now you're starting to build up a heuristic and maybe that fits under your sort of theory node and just sort of building that up using the other two. And you know, sort of, I feel like all every node can sort of benefit from the other two. Yeah, they're not totally distinct thoughts there, vertices of a triangle.
They're all connected. Well, there's definitely a lot to chew on there. What are we is probably an existential question that we all face at some point. But I think we are the point where we should probably cap this off. So on that note, shall we wrap up?
Yeah, let's do it.