« All Episodes

Turbulence (Re-Airing)

Published 7/14/2017

In today's episode, we discuss once again the concept of turbulence and fortitude.

Today's episode is brought to you by Linode. Linode Provides superfast SSD based Linux servers in the cloud starting at $5 a month. Linode is offering Developer Tea listeners $20 worth of credit if you use the code DEVELOPERTEA2017 at checkout. Head over to spec.fm/linode to learn more about what Linode has to offer to Developer Tea listeners .

Transcript (Generated by OpenAI Whisper)
Hey folks, you are listening to a re-aird episode of Developer Tea. If you don't want to miss out on future episodes, make sure you subscribe and whatever podcasting app you use. Just a reminder, we are doing these re-airs, a couple of re-airs, we're missing a few episodes because my son was born just a few weeks ago and so I'm taking some time to be a little bit closer to family and spend some time with him in the earliest weeks of his life. So you're going to hear maybe some things that sound a little bit out of date or maybe some references to links that may not be available anymore. Just a heads up, but the content is still intact, should still be totally applicable to your situation help you level up as a developer in your career. Thank you so much for listening to today's episode of Developer Tea. Let's get into the episode. But first, a quick update to this episode, since this episode aired, I actually have earned my pilot's license and of course I've become a father myself so this episode is even more meaningful now than it ever has been before. Let's get into today's re-aird episode, turbulence. When I was young, my dad would take me and the rest of our family flying. He was the pilot. Dad has had a private pilot's license for longer than I've been alive. Now you may expect that this is a child's dream scenario, getting to fly pretty much anytime they wanted to. But the thing was I was incredibly sensitive to turbulence and I get pretty sick and perhaps more importantly, easily frightened when we would fly. Now this was especially true whenever we flew over mountainous regions. One day, dad explained to me how as the airplane moved through the air, the air kind of treated the airplane like a river treats a stick that's floating downstream. If that river has a rock in it, the water flowing over the rock might rise a bit and fall back down, go to the left or the right, fitting to the contour of the river bed. He taught me this not because it would change the experience of the turbulence or somehow fix my intolerance, but instead it would change the way I thought about the turbulence. Now today, I want to talk to you about turbulence. But as it relates to programming languages and practices, and perhaps even can be applied more broadly to some of your life experiences. I experienced this today. As I was working with a developer, we happened upon a problem with a front-end view we were working on. We tried pushing some items into a set of arrays in the view and we kept on hitting errors. We couldn't, for example, modify an array that was nested inside of another array. And instead we had to modify the top level array and it got messy really fast. Anyway, the particulars aren't necessarily important. After about 30 minutes of googling and fixing one thing just to break another, we realized something profound that if we did this particular data transformation elsewhere, more specifically if we had done it not in our view, we could have been done practically moments after we started. It struck me shortly after that this wasn't a mistake in the design of the language. Instead, this was part of the design of this particular language, a view templating syntax to be exact, that disallowed us from manipulating data to a significant extent. Now, why would a language be designed to be harder to use? We'll discuss just that right after we talk about today's sponsor, Linode. Today's episode is sponsored by the Excellent Service Linode. Linode has eight data centers. Their plans start at $10 a month and you're basically getting Linux in the cloud. You get a server running in under a minute. They have hourly billing with a monthly cap on all of their plans and add on services. They have virtual machines for full control. You can run Docker containers. You can have encrypted disks, basically whatever you want to do. You can do with Linode. They have native SSD storage, by the way. This is super fast storage on a 40 gigabit internal network and they run on Intel E5 processors. There's a seven day money back guarantee and you can get $20 of credit by using the code Developer Tea2017. Thanks again to Linode for sponsoring today's episode of Developer Tea. So we left off talking about the experience I had at work today. The front end templating language that wouldn't allow me to manipulate a raise of data I was working with. And this kind of thing happens a lot, doesn't it? You expect a language or a tool or perhaps even a person to behave a particular way and it or they simply won't cooperate. This could be a major point of frustration if you let it be or you can recognize that usually things are the way they are for a purpose or at the very least they are the way they are for a reason. In my particular case with a front end templating language, what do you think the reason or purpose was for this seeming lack of features? Perhaps the syntax was incomplete or somehow designed poorly, but there's a deeper, more meaningful possibility here that we haven't explored. Perhaps the designer of the syntax is encouraging me through the design of the syntax. He's encouraging me the developer to use the templating language in the way it was intended to be used. If you've worked in structures like MVC, you've likely heard the advice of separating your logic and your data from your view. As my coworker and I sat looking at the code, we realized that we were in some serious turbulence. I took a step back and asked, maybe this is how this is supposed to be. And so the code was rewritten and we floated down the river moving through that turbulence and back onto our original course. We could accomplish what we wanted to accomplish because we responded to the turbulence not by pushing against it, but by letting it guide us. I encourage you as you encounter things that push back against you, as you encounter turbulence, be it from code or from anything else, then instead of struggling against it, first ask the most important questions you can ask when you encounter problems. Specifically, ask the question, why? It's very easy to assume that we know the answer to that question. As a young child, I assume that turbulence ultimately meant something bad was happening, that that was the why of the turbulence. It was only after I understood, thanks to my dad's help, that turbulence was there for a reason that I could think differently and ultimately react to that turbulence with calmness. I hope you've enjoyed this episode of Developer Tea and this quick discussion about turbulence and about allowing turbulence to guide you rather than you fighting against that turbulence. Today's episode is sponsored by the excellent Service Aligno. You can get $20 of credit by using the code Developer Tea 2017 at checkout. Thanks again to Aligno for sponsoring today's episode of Developer Tea. And thank you for listening to Developer Tea. If you're enjoying the show, make sure you subscribe and whatever podcasting app you use pretty much in any podcasting app allows you to subscribe. And by the way, the Apple TV just now launched their podcasting app in the latest update to the Apple TV, so make sure you subscribe there as well. Thank you so much for listening. Until next time, enjoy your tea.