PostHole
Compose
Login
SE Radio 675: Brian Demers on Observability into the Toolchain
Brian Demers, Developer Advocate at Gradle, speaks with host Giovanni Asproni about the importance of having observability in the toolchain. Such information about build times, compiler warnings, test executions, and any other system used to build the production code can help to reduce defects, increase productivity, and improve the developer experience. During the conversation they touch upon what is possible with today's tools; the impact on productivity and developer experience; and the impact, both in terms of risks and opportunities, introduced by the use of artificial intelligence.
Brought to you by IEEE Computer Society and IEEE Software magazine.
Brian Demers, Developer Advocate at Gradle, speaks with host Giovanni Asproni about the importance of having observability in the toolchain. Such information about build times, compiler warnings, test executions, and any other system used to build the production code can help to reduce defects, increase productivity, and improve the developer experience. During the conversation they touch upon what is possible with today’s tools; the impact on productivity and developer experience; and the impact, both in terms of risks and opportunities, introduced by the use of artificial intelligence.
Brought to you by IEEE Computer Society and IEEE Software magazine.
Show Notes
Related Episodes
Other Resources
Transcript
Transcript brought to you by IEEE Software magazine.
This transcript was automatically generated. To suggest improvements in the text, please contact [email protected] and include the episode number and URL.
Giovanni Asproni 00:00:18 Welcome to Software Engineering Radio. I’m your host, Giovanni Asproni, and today I’ll be discussing observability in the tool chain with Brian Demers. Brian is a developer at Advocate El Grado, a Java champion and Apache member who contributes to the directory of Maybank and Shiro projects. He spends much of his day contributing to OSS projects by writing code tutorials, blogs, and answering questions. Brian, welcome to Software Engineering Radio. Is there anything I missed that you’d like to add?
Brian Demers 00:00:47 Yeah. Well thanks for having me. I think that bio pretty much covers it. I think the only other thing I’ll add is most of my career has kind of been in and around the Java world, so everything I think about sort of skewed a little in that direction. But I think everything we’re going to talk about today applies to just about any developer.
Giovanni Asproni 00:01:02 Okay, so let’s start. Now, tool chains in software development, we have several tool chains, compiler tool chain, build tool chain, CICD tool chain, lots of tool chains. What tool chains are we referring to here?
Brian Demers 00:01:15 I think the answer is yes, all of them. So I think the issue really is exactly what you mentioned. We have all of these tools, they’re complex, they’re all kind of tied together. Some of them are stitched together better than others. So we really need a better way to understand them.
Giovanni Asproni 00:01:30 Okay, weíll be talking about all the tool chains we’ll be using here. Good. Now when we talk about observability in the tool chain, what are the similarities and differences with the observability of systems running production? Because usually when we talk about observability, we think about the system in production and the various events, logs and things we can get to understand what is happening there. So are there any similarities with this?
Brian Demers 00:01:56 Yeah, absolutely. So if we think about our production applications, you wouldn’t deploy a production application today without any kind of monitoring or anything behind it. And a lot of that is because they’re complex. We don’t really know the load on the system or all of these other things we’re unaware of until that, I donít know, Black Friday event happens or whatever. Our build tools are very complex systems. Our build chains, everything are very complex. You have all of these things happening, downloading dependencies, compiling, linting, unit tests, integration tests, whatever. I mean there’s security scanning, lots of things that can go wrong just like our production applications. So to me it’s kind of mind boggling to think about that we’re just now getting to a point where we’re treating the complexity of our build tools the same way as we would our applications. So if something goes wrong in your build tool, how do you deploy something to production? Well, you can’t. So if your build tools are actually in line, they’re on the path to getting something deployed to production.
Giovanni Asproni 00:02:55 And also is there any relationship with the shifting observability left? This is something that you find a lot nowadays that is pretty much feeding observability data from the system production to basically the developers for the day-to-day activities. Is there any relationship between observability in the tool chain and this shift left of the observability of the system?
Brian Demers 00:03:17 Absolutely. I think one of my favorite things to talk about is flaky test, for example. So flaky test, I may mention this a few times, but if you haven’t ever been aware of flaky tests, it’s a test that essentially will pass one minute and then without any code changes will fail the next minute or vice versa, or works in my machine but not on your machine, it works on CI but not locally, whatever it is, there’s some inherent flakiness. So the earlier developers can know about those types of problems, the better they can spend their time. So I find working on a feature and there’s a flaky test for example, that has nothing to do with my code that I’m changing. Just the fact that I’m aware of that will make it so I don’t go hunt down that issue. Now there’s a lot of other problems with flaky tests. We can talk about how fixing them and how to monitor them and all that. But essentially that’s just one example of a developer having knowledge earlier in the system is better.
Giovanni Asproni 00:04:08 Okay. And in terms of problems that these observabilities in the tool chain now, what problems are we actually trying to address with this? So you mentioned flaky tests and maybe also security scanning, some of that stuff. But in general, what are we trying to achieve here?
[...]