Hello, and welcome to another episode of The Bike Shed, a weekly podcast from your friends at ThoughtBot about developing great software. I'm Stephanie Min. And I'm Joelle Kinville. And together, we're here to share a bit of what we've learned along the way. So, Joelle, what's new in your world?
I started to build out an API feature for my client. And their app has previously not had an API. And there's a few people have been starting out building some API features. And they've brought in a gem that I had not heard of before called Committee, which is basically applying OpenAPI and JSONAPI spec as a rack middleware to your incoming requests. So if your API says, hey, this is the schema for how I expect a request body to look like, the middleware will automatically respond with a 400 error.
request body is in the wrong shape. So you don't have to manually add validation to all your controllers. Similarly, you can add a middleware that will fail any requests or responses where your backend has made a JSON response that is not valid according to a schema. That way you don't send bad data down to your customers. Both of those are opt-in. So if you just want it on the requests and you want to handle the responses on your own, you can do that.
But it does allow you to have sort of free validation of your schemas against API requests and responses. Interesting. I am very curious about this. I have not worked with a whole lot of custom middleware before. And I'm kind of curious, do you think that is a responsibility that should live in that layer? I kind of like it there because it happens kind of automatically. It makes sense, I think, to me, especially for a request coming in, to...
fail it early if it doesn't meet some prerequisites rather than traveling all the way into your Rails app and doing a bunch of things if it's not even valid. I could also see doing that through some sort of before action that runs in your base controller or something like that that would run some code that would verify against schemas. But for a third-party gem, the nice thing is that It's much more sort of self-contained modular. It doesn't have to live in your application code. It's just a thing that you plug in. And so I think for packaging as a third-party thing, middleware makes a lot of sense to me. Do you configure what it accepts in your application code, though? Yes. So you give it a list of URLs that it runs against. And then you also have to, you're building out an API spec effectively, where you say this endpoint accepts data in this shape, and you give it a JSON schema.
And then on success, it will return data in this shape. And on failure, it will return data on this shape, where all these shapes are JSON schemas. I mean, I imagine it would really depend on your use case, just like how strict you want to be around what you're accepting. But as Joel, as someone who has touted the parse don't validate heuristic, I'm curious what you think just like about when this would be useful, when just kind of that separation between when you do want to be really strict and or more flexible. So strictness is interesting. And that can actually come down to the schema itself.
I think people hear schemas or people hear even like types and feel like, oh, it's going to be really constraining. And really, schemas and types are only as constraining as you want them to be. You can write them in such a way that they will accept all sorts of permissive data types. I read an article by the same author who wrote Personal Validate about how you would type something that's almost like an eval in Ruby. This is talking about, I think it's a function called pickle from Python and how that feels like so flexible that it would be impossible to write types for it. And then the author goes through talking through like why these types or why you actually can type it and how you can do it and how very loose data can still be typed. And that was really eye-opening for me because I think for me, that was an assumption that I'd had previously that turned out to be wrong.
So, yep, I'm excited to see how committee goes. I'm already a fan of JSON schemas. I've used them previously, but packaging them up in a middleware that will automatically check your endpoints seems like a nice thing. It also might, I'm not sure if it can generate documentation or if you need another plugin for that, but you are using an OpenAPI spec file for that. So you should be able to generate documentation as well. So I'm optimistic about it and we'll report in further episodes how things are going.
So Stephanie, what's new in your world? So one thing I was really excited about this week was reading the results of Planet Argonne's 2024 Ruby on Rails community survey. And I wanted to give a special shout out to this podcast that you are listening to right now was one of the, I guess, top 10 most enjoyed podcasts, technical podcasts, which was really cool. I felt really happy and also still weirdly self-conscious that people listen and people like it. wrote on it in a survey. And yeah, I love reading these community survey results every two years. I think it's so interesting. I love kind of like looking at the previous one and comparing and seeing how things changed. And yeah, I have some interesting insights to share about it if you want to get into it. Yeah. And also thank you to all of our listeners who put us into the survey and mentioned that we were one of your favorite podcasts. It's always great to see that our work is really connecting with the community. So what would you say are some insights or things that you saw in the survey that were sort of interesting to you or maybe connected to you in what you saw?
So one of the coolest things that I saw, and I don't know if it was just visually very attractive in the very nice graphs that they have, but there's a question that says, what was your level of programming expertise before learning Ruby on Rails? And it's pretty much evenly distributed across number of years of experience. So it's like in the 20 percentages for people who have no programming experience at all, people who have more than five years of experience. It was, yeah, this like little circle graph that they have. It's like almost like totally evenly segmented, which I thought was really cool just to think that like, oh yeah, like.
And Rails is a framework that attracts devs who are long-term programmers and also new devs. And I don't know, there's something about that diversity that feels really special. Yeah, coming from all sorts of backgrounds. And I think that that is definitely something that we do notice in the Ruby community. You go to an event or something and you'll see sort of the full range of experience levels. I'm curious to know for you personally, what was your level of experience when you first started Ruby? Ooh, that's a great question. I would say like less than two years, between none and less than two years. I had...
mostly like JavaScript experience. And yeah, it was kind of a whole new world for me. And now I am so glad that I have moved into the Ruby world a little bit because I've since realized that JavaScript is not my favorite. But yeah, I feel like that is like kind of typical though, right? As people discover Ruby and they're like, wow, this is great. Like maybe having experienced just more verbose languages or whatever. I hear that a lot where they were like, you know, kind of just get really on board. And I think that's so cool. I love hearing those kinds of original stories.
When you first encountered Ruby, do you think the language itself is what really connected with you? Or maybe some of the parts of Rails that make web development really easy? Ah, that's a great question. I feel like people fall in those two camps, right? I think it was the language itself. When we had Noel Rappin on the show last week, he said something about how a lot of Ruby developers just love the aesthetics of Ruby. And I think that is definitely the camp that I fall into. I definitely am very much one of those developers that loves Ruby for the aesthetics.
It took me a little while to get there, though. I don't think that initially I was like, oh, this is so cool. This reads just like English or anything like that. But I think as I got more into it and was writing more Ruby, it really started sticking to me. And then now I'm very much one of those programmers that cares about the aesthetics. I think another cool thing from the survey was, I think we know that, or at least there is some sense of like, yeah, a lot of people kind of learn Rails by just building their own app with it. And that process is really easy, kind of like you mentioned.
because it, you know, Rails makes it easy for you. And it's really neat to see how a lot of like the survey results about learning kind of converge into that idea where most people, when they first learned Rails, like 25% of them basically built and deployed their own app. And I think that's so cool that like you have no experience with this thing and you can just build a whatever, a hello world or probably something cooler. And then the next kind of most popular way of learning was through videos and tutorials. And those like really seem to, I suspect, go hand in hand together.
They really complement each other really well. And it's awesome to see it more in numbers because it just makes me think about if I ever want to share this with someone, what the best way to do that would be. I'd be really interested to compare these results with similar questions with other language communities. I feel like the Ruby community is a community that's very focused on productivity and making it easy for you to ship and do things. And so it seems very natural to me that the way we would teach how to Ruby is in a very practical, let's build a thing together, as opposed to maybe something in the Haskell community where maybe you're reading papers or you're reading a book or something like that. Yeah, that's really interesting. The other thought that I had was I'm also kind of curious if it's influenced by when Ruby and Rails kind of came on the scene or were first created. Because yeah, the 2000s and 2010s, that was just...
It feels like a time when people were able to learn things from YouTube videos rather than more traditional methods. And I'm even more curious, anything that comes on the scene in the future, if those ways of learning are also different. To me, and this could be because this is how I learned, it feels really hard to replace learning by doing. I like to read a book. I like to read articles. Videos, I'm less into. But I feel like all of those are complementary to a learn-by-doing approach.
It's interesting that they broke out, built, deployed my own app versus worked on an existing app, because I feel like those are almost sort of two paths that people take. Either you're, maybe you're going through a bootcamp or you're doing self-taught or something, but you're following a course that makes you build a Rails app. Or you're a new team member on a team that is writing an app in Ruby, and you just kind of get brought in and say, hey, we'll pair with you, we'll work together, and you'll just kind of learn it by working on the app with us. That's a great point. I think they did pull out working on an existing app and building a new one. And also very different experiences, I think. Because I learned from working on an existing app, which is still learning by doing. But I think that was very practical for a job, which is different still from learning how the framework works, I think. But either way, I suspect that you can kind of get there as you kind of spend more time with the technology.
I did almost like a mix of those two methods where I was coming in for a new job that was going to require some Rails. And so I went through the Michael Hartle Rails tutorial, which you're reading, in my case, it's an e-book and following along by building an app. But then that was preparation for jumping in on a Rails app where I absolutely did not really know what I was doing and having someone hold my hand and then building real production code. So I did a little bit of both very early in my Rails career. Wow. Yeah, that feels like the super advanced course of getting all of the different experiences with it. I also am just impressed that people actually in this community feel out of surfing in the first place. And I am just very, I don't know, thankful that people do and the insights I find are so interesting. And of course, huge thanks to Planet Argonne for even organizing this. They have been for many years now. So check out the survey results. I'm sure you'll learn something cool about Ruby and Rails and how we feel about it.
fun to sort of compare personal experience versus what other people in the community are like. And sometimes you'll look at something like, oh, here are the books that people are reading right now. And like, oh, I read that book. I read that book. Or maybe, oh, I want to read that book. So sometimes it can be a source of inspiration as well. So on the topic of Ruby and Rails as technology we like, perhaps one of the cool things about it is that Ruby is a bit of a, you know, is ostensibly an object-oriented language, but in
The way we use it also kind of does incorporate other different paradigms. I'm curious about kind of digging into that a little bit and how we use different paradigms in our work and just what having those different mindsets enable us to do. So I have a really fun note in my note-taking system. And it claims that a paradigm is an answer to the question, what is a program? And so different paradigms answer that question slightly differently.
And in my note, I highlight three in particular. A procedural paradigm will say that a program is a series of instructions to a computer. An object-oriented program or paradigm envisions a program as the behavior that emerges from objects talking to each other. And a functional paradigm envisions a program as a series of data transformations. Now, at the end of the day, a program, it's what we write, and they all do something. But having that lens of how you view what it is that we're building can affect the sort of tools you work with, the languages that you use.
And it can be really, I think, eye-opening to be self-aware of what paradigm you're working in. I do have thoughts about the actual topic, but I was wondering when you said that this thought of yours was in your note-taking system, was this just a totally spontaneous thought that you had? And you're like, huh, what is a program? Or is this something you read somewhere else? It's hard to say now, right? Because it's an older note. I may have been reading something about a particular paradigm or something, and that got me thinking like...
if I had to explain to someone what a paradigm is, because I feel like we throw that word a lot as programmers. Oh yeah, an OO paradigm or functional paradigm. And we all have a sense maybe of like what the difference between object oriented and functional is. But if I had to sit down and explain to somebody, what is a paradigm? I didn't know that I could quite explain that. And so I thought on that for a little while and then eventually came to my own answer, which is that a paradigm is an explanation to the question, what is a program? Yeah, very cool. The other thing that I was thinking about was, I mean, even the question of what is a program can be defined in a lot of ways. And I was just thinking about like,
In programming history, how these, I guess, paradigms came about and the timeline of them, I don't know the answer to this, but if we started with a procedural paradigm because that was the first computers, but I almost then was like, well, a program doesn't even necessarily need to be a computer. Maybe I'm getting a little super abstract here, but the idea of functional programming being a series of data transformations like that is something that can be done as a process, as a program, kind of separate from the hardware itself almost. I mean, I feel like now we're getting a really interesting sort of philosophical side of things. I want to say that these are some initial programming concepts were theorized before we had the machines to run them. I want to say that's some of the early work that Data Lovelace did, sort of theorized that, hey, if we had machines, they could run things like this and did some early work about what programming might be like before we even had the machines to do it.
That makes sense. I believe that. That's really cool if that's the case. I don't know. I can't even fully wrap my head around trying to theorize something with technology that doesn't exist yet. I think also some of the work done by Alan Turing and Alonzo Church, also they were working more mathematical models, but it predated a lot of the hardware that we could actually run. So they just sort of...
would work on the assumption that assuming we had a machine that could do these things, or assuming we had a machine with infinite memory, what would be the properties of such a machine? Or what would be the limitations of what could be computed? And a lot of the foundations of computer science were built before we had the hardware that we think of as computers today. So coming back a little bit from the heady world of philosophy, I'd be curious to dig a little bit more into how particular paradigms impact the way that you code. So when you write in a more procedural manner, how does that, does that change the way that you think or the way you structure code? What does that look like for you? Yeah, I actually think I start from a more procedural mindset and I don't know why, and I'm sure this is different for everyone, but in some ways that's like the simplest way for me to translate.
potentially like business criteria, especially if they're like written almost in a particular way, like user does this and then this happens or that kind of seems to be the first way I'm able to break down something a little more complex. And I remember someone giving me advice to just be okay with starting messy and not feel the pressure of applying whatever paradigm that I feel like I'm supposed to or is appropriate. And a lot of the time the code will just look like, especially if there's like credit actions involved, right? Like update. calling update on one model and then maybe having to also update something else. And maybe there's an email that gets sent afterwards. So it's like, send email. And I find that it is a good just way for me to just dump out all the things that need to happen, right? And at least now I know like, hey, I've met the acceptance criteria of these things happening because I've implemented methods with those instructions. And I also think that usually here, like being really explicit about what each step does, being clear about it is really helpful in, like I said, just making sure that my program does like all the things it needs to do. I'm going to...
I was going to say a hot take, but I think it's more of a medium take out there. A lukewarm take? In the world of Rails, leaning heavily on service objects comes from writing in a more procedural perspective. because service objects are effectively a way of saying, or taking a bunch of code, we're like, do this, do this, do this, do this. And then maybe we don't want that all in a controller, so we just pull it out somewhere else. Because Ruby is, at its heart, an object-oriented language, the best way that we can do that is by just wrapping it in an object in a call method and invoking it from the controller. Yeah, I am in agreement with that. And, you know, it does the job. But, and I think, at least for me, especially recently, as I've been trying to think a lot more.
In domain models, kind of when I see service objects and when I am kind of trying to refactor them, what I said about having really good names for each of those steps is helpful because then you start to see patterns in those steps. I think there's a, I can't remember what exactly the strategy is, but in the ThoughtBots Ruby Science book, there is a refactoring suggestion where you, if you see a lot of like... update user and then send email to user, those kinds of method names, you might be able to extract a domain object out of there. Obviously, user is kind of a bad example in this case because hopefully you already have a user class. But sometimes those instructional methods can lead you to trying to write the code in a different paradigm. Yeah, you might start in a more procedural way and then move towards a more object-oriented or a more functional approach.
I want to take a moment to talk about the way the community may or may not make value judgments. I feel like sometimes if we talk about some code being more procedural in Ruby, because Ruby's sort of more naturally object-oriented, sometimes it can feel a little bit judgmental or telling somebody they're doing it wrong if we describe their code as procedural. I don't know if you've ever felt that. Maybe you've written a service object and someone on the PR is like, oh, that's a pretty procedural way of doing that. And it feels like a slight negative. Yeah. I think I've experienced that before, but...
And maybe we're kind of trending a little bit away from that, or there's now a bit of a bias against that. But I think there are lots of parts in Rails that are also quite procedural too. And so I don't think it's bad. Like I said earlier, it does the job. I think it's a great place to start. And I'm curious, when you see that kind of code, do you have any...
Any kind of feelings about it? It depends. I think that service objects is a pattern or something that I often find are overused in Rails apps. So I tend to, if I see that pattern, look for other things that can be done instead. Oftentimes, those will be ideas or patterns that come from more of an object-oriented paradigm. As you said, though, Rails itself contains a bunch of procedural code. And if you're ever writing something entirely from scratch in Ruby without a framework, you'll very quickly find that you need at least a little bit of procedural code to kind of wrap your app and to manage the booting up.
of things because objects just kind of sit there. So you need something to be like, oh, when the script boots, start instantiating objects and sort of, if we think of these as all different actors having conversation, somebody's got to set the scene and start the conversation. And that typically is done in a more procedural way. I like that a lot because I was thinking of configuration. And I was also thinking of, I don't know if this is a great example, but like callbacks too feel kind of procedural to me where...
Like you said, things are just happening in a certain order, and you want to make sure that those instructions happen in a particular way. I feel like where I tend to write the most procedural Ruby is if I'm writing some kind of utility script. Sometimes it can be a rake task. Sometimes that can be just a Ruby script that I want to execute locally to do something arbitrary. And so then it's oftentimes just a straight series of lines of code, and it's execute line one, execute line two, execute line three. They all do different things, and that's my script.
So my scripting style is definitely very, very procedural. Yeah. And that makes a lot of sense. Like there is a time and place for that. And you just getting the app to do its thing, right? We write like database seeding scripts, all those sorts of things. We're still using Ruby and it's like, yeah, totally, totally normal. That's procedural. I'm curious to get into like functional paradigm a little bit, because that's the one that I have the least experience with in Ruby, really, I think. Whereas you have been doing that a lot more with, you know, recently you've mentioned working on a project that heavily uses dry RB. What's your experience with,
functional paradigm in Ruby and Rails? So Ruby is a primarily object-oriented language, but it sort of secondarily pulls in some ideas from functional programming that I think are part of what makes the Ruby language so nice. I'm thinking in particular of the innumerable module. But more generally, anything that accepts a block, blocks are effectively what the functional programming community would call higher-order functions. They're a sort of little function that's anonymous that you can pass to some other piece of code, and it will do something with it when it wants.
And a lot of the classic functional programming approaches to doing operations on lists and things are part of the innumerable module. So in a more procedural world, what you're writing are effectively for loops. So you're iterating through, and typically, especially more old school, you're not even doing like a for each on an array. What you're doing is for i equals zero, i plus plus, i is less than 10 or something like that. And then as you're going through that and you get a number, you index into an array and you do all this very kind of low level stuff.
And with Enumerable, you can do things like just each. Give it a block and say, run this block on every element in the array. But this architecture is flexible enough that you can have all of these other great methods in Enumerable that also work with the same approach. And I think that's the power of having something like blocks in Ruby, is that we didn't just create a special syntax for traversing arrays. It's a general purpose tool that we have access to everywhere. Yeah, that's a really good point. I didn't think about blocks in that functional way, but I suppose I do have experience doing that then. And that makes me think, for some reason, I was just thinking about it.
at a more kind of larger system level. But yeah, like I certainly reach for functional patterns when I have like a really kind of small scoped problem that I need to solve in a method. And all of these sort of very nice ways of dealing with arrays, things like map, filter, reduce, all come from, have been borrowed from the functional world. So I think those are, I think Ruby does multi-paradigm in a really good way. Sort of while being primarily object-oriented, pulled in some of the best ideas from functional programming and made it easy to work there.
Yeah, I mean, I also am thinking about how excited people are about pattern matching in Ruby. And that is, I believe, like a pretty borrowed from, you know, functional programming paradigm. And I think there are other people who dislike it for that reason, or maybe are more skeptical of it for that reason. But I appreciate just like how you pointed out that we do get a little bit of the best of both worlds, hopefully. I'd like to contrast, though, the difference between procedural and functional programming. Because I think at the surface, they can feel a little bit the same in that...
neither of them are really focused on objects. Instead, they are sort of structured in, I mean, functional programming might call it a function, procedural programming might call it a procedure, but you're really just combining procedures or functions together to build a program. And at the surface, that might feel like it's just semantics, like we're calling them different things, but they might seem like the same. But I think there are some fundamental differences. Yeah, I'm curious about that because kind of just going back to what I said about the idea of applying a paradigm to a more complex system, I suspect that procedural code does get quite...
difficult to reason about. And I'm wondering if there are differences in a functional paradigm that can help manage that complexity. Is that where your head is at? Yeah. So I would say that going back to my description of what the...
the different paradigms envision a program to be. Functional programming envisions the programs as a series of data transformations. And so you get some input and you get an output and the function does some kind of transformation on it rather than taking actions. It's very data oriented. Procedural programming is much more action oriented. You might do some data transformation as part of it, but that's not the main focus of how your program is structured. Because of this, functional programming tends to be very heavily also focused on composition.
the ideas of, hey, we've got this data transformation and this data transformation. Can we combo the two in sort of a, now a multi-transformation? So there's a lot of ideas in the functional programming world that are all focused on different ways of combining functions together. They get pretty powerful. A basic one, but that we've seen, I think, gaining a lot of popularity in a lot of different languages recently is pipelining. Taking, like, executing some code and then outputting the result of one operation into the next one. Yes. I...
can see how that helps encapsulate some of that complexity that I was thinking of with procedural code because you are at least working with the transformed thing and sending that along. So I guess another way of putting it, a thing that you'll hear functional programmers refer to constantly, is the idea of pure functions. A function only operates on the data that is passed in, and the only thing it does is return data out. So it's purely data in, data out, which means that functions are very localized. They only do actions on the things that come in.
They don't impact the world other than returning some data out. And so that gives them a sense of encapsulation because you can run them anywhere and not be worried, oh, well, in this situation, if I run it, it's going to mutate this thing or it's going to accidentally send an email or something like that. And now just thinking about how cool it is that we do have all of these things at our disposal, though, because like you were saying earlier, it's like when you have just a bunch of objects, they don't actually do anything until something kicks it off. When you have a bunch of pure functions, they have no impact on the world, right? Because that's not what they were designed to do. And yet.
There needs to be an impact on the world to make software actually useful. And I don't know, I guess kind of one of the conclusions I'm getting out of this conversation is they're all important. And that's really cool. There's a classic. talk by Gary Bernhardt called Functional Core Imperative Shell that digs into a little bit of this idea that if you're writing a Ruby program and you're trying to be a little bit more functional by doing things like not doing a ton of side effects or trying to focus more on input and output, but in order for all that to work as a real program that interacts with the world, you need a bit of a shell around that that deals with side effects, with user input. And so taking a more functional idea sort of at the core of your app, but then the edges of the system need to be more procedural. Yeah, I would really recommend watching that.
And we'll link it in the show notes. I'd also like to point out that this idea of pure functions has found its way into the Ruby core library, maybe even in ways that we're used to without even realizing it. And that's methods that end with a bang or not. So in the Ruby core library, if a method ends with a bang, it will mutate the object. Whereas if it doesn't, it will often return a copy or a new object for that.
And so if you're trying to write code in a more, I guess, functional inspired way, or you're just trying to avoid mutation for other reasons, using the non-bang versions is what you're going to want. I didn't know that. That's really cool. And I think one of the things I like about that is, I don't know if this was what kind of went into that decision, but it's really neat how they were able to extend the existing paradigm and introduce a new version of it, or a different paradigm with the addition of that character and making it, just giving us more options.
is really neat. It is worth mentioning that this is only in the Ruby core library. In Rails, bang at the end of a method means that it will raise on failure. So if you use a create bang, it will attempt to save the database, and if it fails, or if the validations aren't right or something, it will raise an error. As opposed to create without the bang will just return false, I think. So Rails is a different convention there, but in Ruby itself, if you see a method with a bang, that means that it mutates rather than returning a new value. Yeah, and I think I also see people...
end up following those kinds of conventions sometimes too, if they're writing their own methods that don't exist in the Ruby core library, but like kind of feel canonical in that way, that would be really neat as a, as a convention to follow to signal like what kind of paradigm is underlying, like a method that you're trying to introduce to an API. So we've talked about a bunch of different paradigms. The three that we've mostly been focusing on have been procedural, object-oriented, and functional. But there are others, including logic programming. All of them, especially if you're working in languages that are dedicated to that paradigm, get you to think in a different way. And I think that our experience as programmers gets really enriched when we do that. And for myself personally, I can say that having spent some time in a purely functional language, in my case Elm, really got me to think about a lot of things in my Ruby code differently. It helped me write tests in a way that I think were easier to test and less brittle.
Just gave me a perspective that really gave me appreciation. I think it helped me understand the enumerable module as well, much better. And so having gone, in my case, pretty deep into the functional world, I came back to writing mostly object-oriented Ruby, but I think I was better at my day-to-day job. So I would strongly recommend taking some time to interact with other paradigms and maybe... think about how that might interact with the Ruby code that you write. Yeah, I think that, I don't know, at least I found myself surprised when I realized that a lot of kind of the languages I use, like even obviously, you know, we've been talking about Ruby, but even JavaScript, for example, I think some people use it in a more functional way. And I've also seen more object-oriented ways of using it. Those are all really...
fun things to notice in your work and other people's work. And yeah, hopefully that becomes something that you're able to find the right paradigm or tool for when you're approaching an issue or maybe kind of explore doing things in a couple of different ways and see which one feels the best. On that note, shall we wrap up? Let's wrap up. Show notes for this episode can be found at bikeshed.thoughtbot.com. If you enjoyed listening, one really easy way to support the show is to leave us a quick rating or even a review in iTunes. It really helps other folks find the show. If you have any feedback or questions, you can reach us at hosts at bikeshed.fm via email. Thank you so much for listening to The Bike Shed, and we'll see you next week. Bye!