Elizabeth Lawler: Creating Maps for Code

In this episode, we cover:

• Introduction (00:00)
• Elizabeth, AppLand, and AppMap (1:00)
• Why build AppMap (03:34)
• Being open-source (06:40)
• Building community  (08:50)
• Some tips on using AppMap (11:15)

Links Referenced:

• VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=appland.appmap
• JetBrains Marketplace: https://plugins.jetbrains.com/plugin/16701-appmap
• AppLand: https://appland.com

Transcript

Elizabeth: “Whoa.” [laugh]. That’s like getting a map of all of the Planet Earth with street directions for every single city, across all of the continents. You don’t need that; you just want to know how to get to the nearest 7/11, right? Like, so just start small. [laugh]. Don’t try and map your entire universe, galaxy, you know, out of the gate. [laugh].

Jason: Welcome to another episode of Build Things on Purpose, part of the Break Things on Purpose podcast. In our build episodes, we chat with the engineers and developers who create tools that help us build and operate modern applications. In this episode, Elizabeth Lawler joins us to chat about the challenges of building modern, complex software, and the tool that she’s built to help developers better understand where they are and where they’re going.

Jason: Today on the show, we have Elizabeth Lawler who’s the founder of a company called AppLand, they make a product called AppMap. Welcome to the show, Elizabeth.

Elizabeth: Thank you so much for having me, Jason.

Jason: Awesome. So, tell us a little bit more about AppLand and this product that you’ve built. What did you build?

Elizabeth: Sure. So, AppMap is a product that we’re building in the open. It’s a developer tool, so it’s free and open-source. And we call it Google Maps for code. You know, I think that there has been a movement in more assistive technologies being developed—or augmenting technologies being developed for developers, and with some of the new tools, we were looking to create a more visual and interactive experience for developers to understand the runtime of their code better when they code.

So, it’s interesting how a lot of the runtime of an application when you’re writing it or you’re actually crafting it is sort of in your imagination because it hasn’t yet been. [laugh]. And so, you know, we wanted to make that information apparent and push that kind of observability left so that people could see how things were going to work while they’re writing them.

Jason: I love that idea of seeing how things are working while you’re writing it because you’re so right. You know, when I write code, I have a vision in mind, and so, like, you mentally kind of scaffold out here are the pieces that I need and how they’ll fit together. And then as you write it, you naturally encounter issues, or things don’t work quite as you expect, and you tweak those. And sometimes that idea or the concept in your head gets a little fuzzy. So, having a tool that actually shows you in real-time seems like an extremely valuable tool.

Elizabeth: Thank you. Yes. And I think you’ve nailed how it’s not always the issue of dependency, it’s really the issue of dependent behavior. And that dependent behavior of other services or code you’re interacting with is the hardest thing to imagine while you’re writing because you’re also focusing on feature and functionality. So, it’s really a fun space to work in, and crafting out that data, thinking about what you would need to present, and then trying to create an engaging experience around that has been a really fun journey that the team has been on since 2020. We announced the project in 2021 in March—I think almost about this time last year—and we have over 13,000 users of AppMap now.

Jason: That’s incredible. So, you mentioned two things that I want to dive into. One is that it’s open-source, and then the second—and maybe we’ll start there—is why did you build this? Is this something that just was organic; you needed a tool for yourself, or… what was the birth of AppMap?

Elizabeth: Oh, I think that’s such a great question because I think it was—this is the third startup that I’ve been in, third project of this kind, building developer tooling. My previous company was a cybersecurity company; before that, I helped build applications in the healthcare sector. And before that, I worked in government and healthcare. And—also, again, building platforms and IT systems and applications as part of my work—and creating a common understanding of how software operates—works—understanding and communicating that effectively, and lowering that kind of cognitive load to get everybody on the same page is such a hard problem. I mean, when we didn’t all work from home, we had whiteboards [laugh] and we would get in the room and go through sprint review and describe how something was working and seeing if there was anything we could do to improve quality, performance, reliability, scalability, functionality before something shipped, and we did it as a group, in-person. And it’s very difficult to do that.

And even that method is not particularly effective because you’re dealing with whiteboards and people’s mental models and so we wanted to, first of all, create something objective that would show you really how things worked, and secondly, we wanted to lower the burden to have those conversations with yourself. Or, you know, kind of rubber ducky debugging when something’s not working, and also with the group. So, we created AppMaps as both interactive visualizations you could use to look at runtime, debug something, understand something better, but also something that could travel and help to make communication a lot easier. And that was the impetus, you know, just wanting to improve our own group understanding.

Jason: I love that notion of not just having the developer understand more, but that idea of yeah, we work in teams and we often have misalignment simply because people on different sides of the application look at things differently. And so this idea of, can we build a tool that not only helps an individual understand things, but gets everybody on the same page is fantastic.

Elizabeth: And also work in different layers of the application. For example, many observability tools are very highly focused on network, right? And sometimes the people who have the view of the problem, aren’t able to articulate it clearly or effectively or expeditiously enough to capture the attention of someone who needs to fix the problem. And so, you know, I think also having—we’ve blended a combination of pieces of information into AppMap, not only code, but also web services, data, I/O, and other elements and so that we can start to talk more effectively as groups.

Jason: That’s awesome. So, I think that collaboration leads into that second thing that I brought up that I think is really interesting is that this is an open-source project as well. And so—

Elizabeth: It is.

Jason: Tell me more about that. What’s the process? Because that’s always, I think, a challenge is this notion of we love open-source, but we’re also—we work for companies, we like to get paid. I like to get paid. [laugh]. So, how does that work out and what’s that look like as you’ve gone on this journey?