Jean Young is the founder and CEO of Akita software, the eBPF powered API observability service. Prior to starting Akita, Jean was a professor at CMU where she worked on programming language design.
- Making like little VB interfaces
- Computer science is really different than programming
- Trialing co-founders
Beyang: All welcome back to another addition to the Sourcegraph podcast. Today, I'm here with Jean Young, the founder and CEO of Akita software, the eBPF powered API observability system prior to starting Akita. Jean was a professor at CMU where she worked on programming language design. Jean, welcome to the show.
Jean: Thank you. Glad to be here.
Beyang: Awesome. So to kick things off how did you get into
Jean: programming? Both my parents were computer scientists, so they had started out as electrical engineers, way back in the day before computer science was a thing. They both got into computers. So we had a terminal in our home pretty early on and I, I guess like many other parents, they like to teach their kids what they do.
Jean: So I, I learned basic pretty early. Like I think they taught it to me when I was like six. We had, we had a computer in our home, like pretty early. I taught myself web programming and pretty much like as soon as I got an internet connection, I just got really into the internet.
Jean: And in fact, I had my internet time limited. And so it felt like a thing, you're not really supposed to do. You're like rebelling and . Yeah. So I think that, like programming was a thing that everybody in my family does, but web programming, like that's the thing that you only get to do for a limited time a day.
Beyang: That's hilarious. What was your, do you have an earliest programming memory, like something to do with like basic or web programming that stands out?
Jean: I was pretty into visual basic actually, cuz I would make these like little visual interfaces to click through, but I didn't really have any you couldn't really share it so that that's actually why I got really into web stuff.
Jean: But then I was like, whoa, stuff that runs on the internet is amazing. You can just share it with people.
Beyang: That's awesome. What were some of the things that you built on the web in those early
Jean: days? A lot of websites. I had, I had a website about everything that I cared about. I had a Tamagotchi website.
Jean: I was really devoted to it. I had websites, I built my friend's websites. I had chat rooms and all my websites. It was a very very social for me. It was like very much about interconnectedness.
Beyang: That's awesome. That's awesome. Did you make any friends on the
Jean: internet? No, not really. I think I, like most of my internet friends were like pretty like random, creepy people.
Jean: I think. I didn't really, I mostly just talked to my existing friends and I think that, my, my parents are pretty like warn me off of internet friends pretty early on. So I think that was not something I spent a lot of time
Beyang: doing. Yeah. Makes. Cool. And from there, was it kinda like a pretty much like straight shot to studying computer science in university?
Beyang: Or, what led you down that path? Yeah,
Jean: that's a great question, even though so my mom, my dad they're both doing computer science and programming, so my mom still works as a professional programmer today. My uncle also computer S. I'm the oldest cousin, but like most of my cousins, like everybody, except for one person works in some kind of that's incredible programming or computer science or all my cousins in America, yeah. But yeah, but I think that, when I was figuring out what I wanted to do, I think I'm. my family was like we immigrated to America so we could have other options. You can do anything. You can be the doctor. You can be a doctor, you can be a lawyer, you can go into politics.
Jean: You can't be the president, but you can be many other things. And they really wanted me to explore my options. Cause they're like, we all ended up in this cuz the government assigned it to. Maybe you should do something else. Yeah. And then I think there's also like a lot of gendered stuff. I think, at the time there, computer science wasn't as mainstream.
Jean: I think a lot of people saw it as, my, some of my teachers saw it as like a not really like a. A girl thing, which was I think, they would really take back today, but at the time, no one just, no one knew very much about it. I declared economics my first year of college.
Jean: I realized I didn't care at all about the economics classes. Like when I came time to fill out my course syllabus, I just copied it off my friend. I was like, Hey, what courses are you taking? I'll just take the same.
Beyang: Cool. Okay. So your kinda like natural proclivities and inclinations led you back to computer science.
Beyang: At what point did you make it official? Was there a point where you're like, ah, this
Jean: economics yeah, sophomore year? Cause I took computer science classes the whole time. I think I was like, man, this economics thing isn't working out. So I was actually pre-med for one semester and I took two semesters of organic C.
Jean: And then I was like, this pre-med stuff is like really intense. It's the opposite of what I wanna be doing. Also like taking organic chemistry without taking other chemistries was pretty rough, but like I figured it out by the end but I was like,
Beyang: man, this is you would string to O chem. I feel like everyone's oh, that's like a huge leap when you go from
Jean: I was like, I was pretty good.
Jean: AP chem. So I think I can just do it. I remember for the whole first semester, I just didn't really know. I was like, I I don't know. I didn't know what anything was called, cause it's a lot of nomenclature. And so I completely studied the wrong section of the textbook for all of the test.
Jean: And so then when I came to the final, I like went to the final study session and I was like, Hey, I'm like not doing so well in this class. And I was like, oh, I've been studying the wrong section of the book. And then I got I did really well on the final cause I finally studied the right section of the book.
Jean: And then the TA was like, oh my God, I've never seen someone improve so much. You can do anything. Amazing. And I was just like, no, I was really just studying like the wrong section of the book. But yes, it was you helped me. Yeah, I think that, every teacher likes to believe they like save someone.
Jean: And so I feel like she really believed she saved me but I was really confused that's cause I didn't even I just didn't know what anything was called. Just let me study the metal section of the book and oh shoot. Like the whole test is on the other book section.
Beyang: That's crazy.
Beyang: Okay. So what I'm getting so far is you come from a family of geniuses and you are yourself a genius.
Jean: Well, I think computer science is just a skill it's like writing or math, it's anyone can do it. Anyone can get better at it. Yeah. I think that when that's your family, that's it's just you start learning it, you learn more of it.
Jean: Anyone can get better at it. And. I think that's a big part of why I believe in accessibility of this stuff, actually. I think there's not like there's no magic about it. There should be less and less magic about this stuff as it becomes more and more a part of our lives,
Beyang: a hundred percent.
Beyang: When you were going through undergrad CS, having had the background that you did, exposure to computers in an early age do you feel like your experience was unique in some ways, or, how did you view yourself as going through the program?
Jean: I think computer science is really different than programming.
Jean: That's and I think that if you have been exposed to computers more, it doesn't actually help you in a lot of stuff. Like it helps you some cuz you don't have to make the initial leap to Procedural thinking and thinking thinking algorithmically a little bit, but like when I, so I taught at Carnegie Melin for a couple years when I was teaching something that people told me there.
Jean: And that I think is true just across everything I've seen is people People who show up, having programmed a lot, like still haven't really learned the concepts most of the time. You, you might have programmed, but like how well do you understand algorithms or how well do you understand recursion?
Jean: And I think that I had a bit of a chip on my shoulder initially. I should know this stuff better. I like, I've seen it for a long time. And I think that got in my way. I think that, there's just stuff everyone has to learn initially. Yeah, a hundred percent. And I think that this is really at odds with I think a lot of people are like, oh, computer science education.
Jean: Like, why do that if you've been programming. But I think for me like learning the concepts was quite a different thing than learning like web programming, for instance,
Beyang: This something you said for learning, I guess like the principled foundations and the theory behind something, thinking through it in like a kind of like rigorous fashion.
Jean: Yeah. Or thinking algorithmically or, like proving things about what you're programming and proving bounds about your algorithms. I think that most people never have to do it again, but it was definitely
Beyang: useful. Do you think like that appeal, like it was like this new part of computer science that kind of transitioned from hacking on stuff and just being like very hands on, on, on the application side to like diving into the theory.
Beyang: Did that lead you into like programming languages? Was that kind of the. The motivation or interest there.
Jean: Yeah. Yeah. Cuz I think for me, one of the main reasons I didn't want to do computer science or I listened to other people when they were like, oh, you probably don't wanna do this was I thought the tools were just crap.
Jean: I was like, man, like nothing makes any sense. It works like 80% of the time. I didn't realize that there are like fundamental concepts that this was based on . Cause I was like, all this stuff is a. And I feel like if I had learned it theory first, I'd just be like, okay. Yeah. But, when I learned the theory after experiencing the tools for a long time, I was like, what you mean?
Jean: This can be clean. And it was supposed to be like this. And so I think. That. So it was partly that where I was like, okay, I think it'd be very interesting to spend my career cleaning this up. And I think another part of it was very selfishly motivated where I loved the theory.
Jean: I loved my theory of computation class. I thought algorithms was really fun. And I ask myself, how can I do more of it? Because this does not seem to apply to the kind of hacking I was doing before. So what kind of stuff could I be doing to get closer to doing doing this kind of work in my everyday life?
Jean: And so I will say now as a company founder, I don't really get to do that stuff, but I feel like it's based on those ideas.
Beyang: When you graduated from undergrad, I feel like maybe a fork in the road for a lot of people is do you go and get a graduate degree and do research or do you go into industry?
Beyang: What, at that point in your life, was there like a question in your mind or was it pretty straightforward?
Jean: Yeah, definitely. So I'm, I had internet Google this summer before my senior year. So that was summer 2007. Google was very hot, then it was, still it's still very hard to get a job there, but it was like, like not clear if you're graduating from a top school, if you could get a job there.
Jean: I had a return offer from there. So I like, my friends were like, oh my gosh, that's where you were gonna go. And at the same time I was like, okay, I've done a few internships in industry at this point. I don't know that's what I wanna do because. I would be using state-of-the-art tools, but I feel like the tools could be better.
Jean: So where could I work on that? And at the time there were compilers you could work on. So there was a company called green acres in Santa Barbara. They made compilers, I think like for defense there were like a few other places working in compilers at the time, it was. Very far from the mainstream at places like Google they're working on like the kind of dove tools they were working on was one example of a project they finished the summer.
Jean: I was, there was, they made distributed, linking, so DCC. Cause before that, like linking was not distributed and it took 10 minutes to link any code . I. Okay. I think you can move the needle on like compilation performance or like performance things, but like anything semantically having to do with programming tools of the kind that I wanted to do there just really weren't opportunities for doing that in industry at the time.
Jean: And to me, the question was where can you go to get better at doing the. Work that I wanted to do, which is new kinds of tools, better semantic tools for understanding software systems and I applied to grad school at the time, I had deferred my Google offer to April or whenever the grad school decisions were.
Jean: So if anyone tuning in is I'm an undergrad, a lot of undergrads don't know this, but people make you offers and tell you, you have to tell them by October, you can defer them until whenever your actual decisions are. And at the time I was. So like Google is a very valid option. It depends on what grad schools I get into.
Jean: My undergrad advisor even said, look there is a chance you may not get into the schools you want to it's never a guarantee you need to be prepared. Cuz I was I'll go to grad school if I can get into the schools I want. And it wasn't a very big set. I was prepared for all outcomes.
Jean: But then I ended up getting into some schools I wanted to, I visited them. I really liked MIT. And so that, that was. The moment when I made the decision.
Beyang: Yeah. I feel like in, in up until a couple years ago, there wasn't really a large like developer tool ecosystem either. The main options, like you said, were those kinda like compiler companies, which
Jean: Yeah. There's really been a boom in funding and dub tools in the last few years. And I've. Seen you've written about that. And I think the diversity of dev tools you can work on has also really expanded, but before, even in the bigger companies. So I will say like some, a couple years after I made the grad school versus not grad school decision, like Google, Microsoft, and Microsoft has always had pretty good dev tools actually, but anything that was not Microsoft, Google, Facebook started investing a lot more in depth.
Jean: And yeah. And then, like you saw startups joining joining in that, that, that game after that.
Beyang: Yeah. Yeah. Cool. What did you get up to at
Jean: MIT? So during grad school, I was I created a new programming model and programming language. The language was called JS. The programming model was called policy agnostic programming.
Jean: The main idea was it factored out information flow and security access checks out of your code? So the general thing I was interested in was like, Hey I'm interested in removing boiler plate from code at the time. Still very interested in programming languages are the vehicle. Cause I was like, okay, code is a mess.
Jean: And so there's many ways you can go around cleaning up code. And at the time, my undergrad professors were very much believed in the philosophy that better programming models and better programming languages are what it's going to take to clean up the mess of software that was out there.
Jean: And so the premise is if only we all use better languages, our lives would be better. And in some sense, that's true. The mainstream has really shifted towards that in. 10, 15 years. So at the time I was like, okay what's the next thing? After memory management that would really clean things up.
Jean: And so I was like factoring access checks out of code. If you write any web program, like half of your code is access checks and everyone gets them wrong. And so I'm. Something that's been cool to see since then is there are a bunch of startups now, and there are a bunch of things that are like, let's factor this out as a module, as a library, as like all kinds of stuff.
Jean: But at the time I just like really worked on okay, semantically, what does it look like to factor this out? If you wanted to do information flow and not just access control. So access control is here's a value. Let me protect it. Information flows. Like here's a value. Let me do computations based on the value.
Jean: So let's say my location is secret. A like information flow violation would be like, show me all users who are in the bay area right now. And if my location is secret, like my location should not contribute to this count. So it was really like, let's take this to the next level. How do we track that?
Jean: And I I came to some interesting conclusions while working on this because I was like, okay, cool. This is great. As a theoretical model, this is how you would do it. Other people have told me, I've read your thesis. That influenced how I implemented this library and I've been like, great.
Jean: But for me, I was like, okay, I wanna clean up actual code in real life. And so I started implementing a domain specific language based on the thing based on my language. And I started building web apps based on it, because that's been my goal of who I wanna help, what kind of apps I wanna help the whole time.
Jean: And I discovered something which is in web apps. Most of the code is in application code it's application database code. It's your ORM code. You call it to the database and. I said to myself, oh shoot. That was outside of what I was modeling in my application language . And so this is where the illusion broke for me that any kind of language level guarantees really solve all of your problems because I real, that was when I started realizing just the, this sheer scale of software heterogeneity.
Jean: Because even in a simple model view controller, web app, you have your you have your model, you have your view and you have your controller. That's three heterogeneous run times. It's three heterogeneous languages. There's no way you could you could have a single one, but that's just so unlikely.
Jean: And so that was where I started thinking about, oh shoot, anytime you do anything in one of these web systems, you're calling outside of your language. And so if you're coming from. We're doing this for the guarantees. If you have a completely closed system, like a spaceship or like an operating system or something like that, you can verify something down to the bare metal.
Jean: And I think, Amazon does a lot of this like hypervisor kernel, like verification stuff. But anything web you're just screwed. Like you have so many parts, they're all running in different run times. It's worse than running in different languages, because if you have any kind of managed run time and like any database has a pretty substantial run time.
Jean: Like you just have so many components and it's really about like your interacting components is what I realize at that point. And so to answer the question, what did I get up to in grad school? I made a new programming language and what did I learn from that? And no programming language is gonna save you.
Jean: There's too many parts.
Beyang: Interesting. Interesting. Was that like a gradual realization or was it a sudden epiphany? Do you remember?
Jean: There was a sudden realization, but I was also very deep in it because it was, my first paper was I made this new programming language and then I went to my advisor three quarters of the way through and I was like, Hey I figured out.
Jean: Problem every time I call it to the database, it actually subverts my guarantees and he is oh, that's great. You have your next paper. . And so then, I wrote that next paper and I think that it was during the process of publishing that next paper that I realized that this was a bigger problem because I spent something like three, four years convincing people that this should be a paper.
Jean: Cause there were a few snags. So one was. Most ways of modeling programming languages only model one. So how do you actually model like a programming model? So you have Lambda calculus, but how do you actually model like Lambda calculus with a sequel database inside? There were actually like, no way not really many clean ways that I had seen of doing that before.
Jean: So like, how do you model. In the formal programming languages way was like a huge challenge. And then once even we did that, people were like, why would you ever do that? You already have your paper about your language, like you're done. Yeah. And I guess I realized a few things from that.
Jean: But most of the like language modeling community was really not focused on this cross language thing. Cross language is super messy. It took us, like two years to really figure out how to get the modeling of the language plus the database. And. I was like, man, there's not that many people thinking about this in a principled way and everyone is just doing it.
Jean: And so it, it was, there was the initial realization and then where to best do that work was a series of gradual, not even realizations, but trying to do things and getting thwarted and in various.
Beyang: When you graduated and became a professor, was that kind of thinking top of mind for you?
Beyang: Did that inform like the research direction you picked?
Jean: Yeah, absolutely. I, at the time I knew that. Probably at some point I would want to build the kind of tools I wanted to build in industry because I was hitting these edges of what you could do theoretically in academia, but again at the time.
Jean: So I was finishing grad school in 2015. At the time I would say this was before dev tool startups really took off. You still, the major players were still Microsoft, Facebook, Google. A few other places and the name of the game and all those places was scale. And so if you had a small PHP or Python extension that could check all of the code at one of these large companies, you could build it and everything else had a lot of trouble.
Beyang: got it. Got it. So seeing that you went into becoming a professor to see if you could drive
Jean: research. Yeah, so I felt the kind of problems I wanna work on academia is still the best place. I will take some time here, work outta my ideas. I really didn't think it would happen so quickly that the landscape shifted in in startup.
Jean: Yeah, I think it was really like, I feel like 20 13, 20 14, you started seeing it, but it like most of the shift happened post 2015.
Beyang: I can definitely confirm that like source craft got started in 2013. In those days, if you said the words, developer tool to investor, they like pick up their bags and run the opposite direction.
Jean: It was not hot. Yeah.
Beyang: But yeah, fast forward to now, it's one of those, the hottest areas and for good reason I feel couple like big inflection points or milestones, the Git of acquisition by Microsoft. And then you had companies like GitLab and Datadog come along and just a lot more like companies like that, that prove at this model Hey, like more organizations are building software.
Beyang: And guess what they all care about developer productivity, they all care about tooling. And a lot of these problems are actually like common across organizations.
Jean: Yeah. Yeah, absolutely. And I think that something that's been interesting to see is I keep on calling out Microsoft. Does Microsoft has been doing this all along?
Jean: Yeah. Yeah. And I feel like also something shifted where that was around the time Microsoft actually started doing less. Yeah. And so a lot, like a lot of the Microsoft people went to Google, went to Facebook and like it started getting spread around.
Beyang: Y it's interesting. I think of Microsoft as really the original dev tooling company.
Beyang: Oh mean, absolutely. Yeah. Like nineties there, Microsoft the people always think of like the antitrust like competing hard with apple. But I really think that, the reason that windows won a big factor of it in the nineties was because they built, they prioritized the developer experience.
Beyang: They had this like wonderful vertical suite of tools. Yep,
Jean: yep. Yeah. I completely agree. And they hired a lot of the OG developer tools, people, I think, dev at Microsoft still continues to do some of the best developer experience
Beyang: work. It's interesting too, because I feel like that was maybe the playbook for maybe like tech version one, cuz in those days you didn't really have a, there was no internet, there was no open ecosystem.
Beyang: And so the way to win was to, make your platform the most appealing for third party developers to build on that's how you got, kind of coverage of all the applications that your customers wanted to do on top of your operating system. And in, in some ways like, It's still true to a certain extent you do still have vertically integrated walled garden ecosystems in tech today.
Beyang: And that is a priority to prioritize developer experience for those, for the companies that own those ecosystems. But today we also have the web and the entire open source ecosystem. And in some sense, like the developer tool startup ecosystem that's popped up in recent years is complimentary to that.
Jean: Yeah. Yeah. It's been super interesting to watch and I think that no dust is settled yet, which makes it very fun. like anyone who tries to say the dust is settling, is just not true. Yeah. We're
Beyang: still early days. It's the wild west. It's really fun outside.
Jean: Yep. Yep. Yep. Yeah. And something that's really cool to me is I went into this and, I presume you went into this too, because you saw that developer experience was just so
Beyang: bad as you were going into starting as a professor at CMU was this all top of mind or, did it inform your research area?
Jean: The ecosystem changes themselves. Weren't top of mind. I wasn't like, I wanna capitalize on the ecosystem to me. I was like, Still trying to get at web programming needs to be easier. It needs to be easier for developers to wrangle the mess of code they get. Everything feels tangled up. How can I make it better?
Jean: And so to me, the question was always how can I improve the state of web programming today? And not so much, what's the right time to do this kind of thing. And to me I thought we were many more years out from me being able to do the kind of work that we're doing at Akita now.
Jean: I think it, it helped. It helped that I realized that what we should really be doing is working on better better tools for telling developers what's going on instead of better tools for helping developers do something new. I think a lot of the work in academic programming languages and a lot of the work in people who make programming languages for fun or.
Jean: Work coming out of labs or these these design collectives there are a lot of them are about, here's a fun way to write more code, but to me throughout the. Whole time. Really? I was working on programming tools. The bigger problem is what do people do, what the code they've already written.
Jean: And that was a big part of why I was really interested in here's how we add a new dimension to code. Like my whole PhD thesis was motivated by if you've written some code and you wanna add some policy to some data. It is hell right now, because you have to go in and thread all that through what, if you could decouple it.
Jean: And the overarching theme for that is if you have some code and you wanna do anything different to it, whether it's add a new feature, whether it's make a change that threads throughout, whether it's add instrumentation for some kind of monitoring and observability that you need to thread throughout, it is a really.
Jean: Pain right now to do anything with with code you, you have existing. And I feel like that's a big motivation for what you guys at source graph do. It's a really big motivation for what we at Akita do. And to me, the. The legacy code problem was a very big one. The heterogeneity of code was a very big one.
Jean: And so I was just going after chipping at these problems in ways that I thought were potentially the most medium term impactful. And what I mean by medium term impactful, it was not necessarily, this is something we can do today. That's luxury of the fact that I was in academia. And to me also, if you're working on developer experience, 10, 15 years out makes no sense, like back before, like I feel like in the seventies could be different world then.
Jean: Yeah. Yeah. In the seventies you could be like, theoretically developers will exist one day and I can make all these programming models. And it's great because now we've picked up a lot of the ideas from the seventies. But everything that's happening now. It's like what, what is going to win in the next five years?
Jean: Determines what are the big problems to work on in the next 10 years? And so I'm, to me, a lot of like long term work in this space, doesn't, didn't make a lot of sense for me for that reason.
Beyang: Makes sense at what point was there like a catalyst that made you take the leap from academia into starting a startup?
Beyang: Or was that just a natural progression of
Jean: your work? I looked around, I looked at what was happening in the space. I looked at the needs of people. I feel as an academic program languages person, I was on the very practical end of trying to stay in touch with developers. I would do my tour of Silicon valley companies.
Jean: To year and just check things out, figure out what people are up to. And I feel like, I there are many more existential questions you have as an academic working on something. That's trying to be useful to the like, to industry because you really I pretty regularly ask myself is still, is this the right thing to be doing?
Jean: Is this the right place to be doing this thing? And When I ask myself those questions, I realize the thing I wanna be doing is slightly different. And the place to do it is by starting a company. And I wasn't sure at the time I actually, I talked to people at Facebook. I talked to people at Google.
Jean: I think that. If there's certain kind of problems you wanna solve and the places that might let you solve 'em are dynamically changing every year. It's always good to reevaluate.
Beyang: Yeah. What was the inception of a Akita? Did you have a working group or a brain trust or like a co-founder that you started out with?
Beyang: What was the,
Jean: it was really just me. I trialed a couple of co-founders. And I ultimately decided to take the leap by myself because the couple of co-founders I tried, they were interested in the kind of, so initially Akita was much more focused on privacy cuz a lot of my work was, programing, languages applied to privacy.
Jean: So I was like, okay, we can start with observability, but for privacy cuz that's what my work has been. And so I'm I always had. My intuitive sense was that I wasn't tied to privacy. It was really about certain kinds of programming, paradigm shifts. And so the couple of co-founders I initially trialed, they were very tied to privacy and data.
Jean: And I felt okay, if we pivot out of that's not gonna go very well. And we ultimately did decide to pivot out of that. And a decision I made up front was like, they're not committed to the same thing as me. I was very committed to there's a paradigm I wanna push through. There's a way of thinking about software I wanna push through.
Jean: And I think that, for someone if they're like, this is a way to build a business for this kind of data or this kind of privacy, you would just make a different set of choices about what you are and aren't willing to change.
Beyang: Got it. So you didn't wanna restrict yourself to that specific genre of tooling, I
Jean: To me it was about like, I want people to understand what their software is doing better. Like however, whatever insertion we can get a hold of, we take it. And so I'm, I think also initially if there had been someone who was like, I agree with you on, programming can be different in this way.
Jean: And I feel like the, my founding team eventually was. But I think initially it was like what I learned from trailing co-founders was like, you have to care about the same thing in the same way.
Beyang: Can you describe for like people who aren't familiar with it? What is Akita today what's the simple
Jean: So Akita is going after drop in API observability. So our high level goal is to help developers build more robust and trustworthy software. We believe the way to do it is by making it as easy as possible for developers to understand their running systems. And what this means to us right now is their production systems.
Jean: I think eventually, there's a whole space. There's what happens in production? What happens in In STJ and then left you shift. But what Akita is today is we are drop in we're E BPF based. And we're completely based on passive traffic observation. And so all you have to do is drop us in, let us passively watch traffic.
Jean: We don't stand in the flow of traffic at all. Our footprint is basically the additional memory footprint of our passive watching agent. And we tell developers, this is what endpoints you have. This is the usage of the endpoints. This is what they're doing. This is how they're talking to each other.
Jean: And now you might think okay, there's Zita, dog, there's Grafana. There's all this other stuff. What does a key to do? And We got into this space because people using these other tools even were like, it's so hard. Like we're not really fully using them. It's actually really hard to get this set up for us to set up APM on our systems, our one of our.
Jean: Senior, very senior engineers had to spend a week upgrading our libraries. You had to kinda like figure it wasn't even like clear okay, you have to update this. It was just like broken dependencies for a week. And we had three services at the time. This was like, before we even wrote a bunch more code.
Jean: And So then we were like, okay. Yeah. Cause I think initially, I had many questions, like where is the highest impact place we could tell developers what's going on with their code. So we started out thinking like, maybe people wanna know where their data goes. We realized no, like people actually don't the lawyers do, but a spreadsheet is good enough.
Jean: And then where we landed is is much more basic than what we expected. Developers don't know what endpoints they have. They don't know how those endpoints are being used. If you have something like CloudWatch, even if you have something like data, drug, or Grafana, you have to have a pretty good handle on your system to have instrumented it, to set it up in a per endpoint way.
Jean: And so one complaint we see a lot is if someone's using something like CloudWatch, it's like your whole system is down somewhere somehow. What people really wanna know is which end point and like how bad is it? And so the abstraction of an API to us is both we can reconstruct that by watching traffic alone, we don't have to get in your code.
Jean: You don't need to instrument anything. And also it's a very useful abstraction cuz we have users come to us and they're like, look, I only care about three of my endpoints, but in order to like properly instrument, those three, like CloudWatch, doesn't like. It doesn't make it easier or possible to configure that.
Jean: And even if you look at Grafana or data dog, like endpoint, isn't really an abstraction. Like you have to map it all yourself. Yeah. Yeah. And so for us, like we, we got we figured out where our insertion is basically people. Don't wanna do very much work and they want you to get in there and just start telling them things.
Jean: And so for us it's really just been a process of like us getting in there and being like, Hey, like we can tell you these things, which ones do you care about? And it turned out, the fancy stuff actually was not what got people it's like the much more basic stuff. So
Beyang: just to restate that real quick I is the picture that you're after really this kinda like boxes and arrows picture of each box is like a process or a service that's deployed.
Beyang: And then you show me like the end points that one listens on and talks through. And kinda like what other services that each box is communicating with? Is that kinda like the runtime picture that you're after?
Jean: Yeah that's something we started out being able to show I will say that what we've gotten requested on is even more zoomed in cuz people are like, I've got one service and no clue what it does.
Jean: It's what
Beyang: is it doing? What port is on,
Jean: what sort. You really don't know that. And they're like, yeah. Cause we're like, here's the whole graph. This is talking to this, that's incredible here. And people are like no. Like I have I have three, I really only care about one and really of that four end points.
Jean: But even just like getting my head around that is like hard. And so it's
Beyang: Here's this creature. I inherited it from someone else who inherited it from someone else. Yeah. I inherited
Jean: what does it do? Or I inherited from myself. It's evolved over time. Or, people are using it in ways that I.
Jean: Spec. I said on another podcast, I was recently on once you ship code it's legacy, cuz it's out of your control and it's not paged in anymore. And like that's essentially what we found. Like as soon as it hits production, it's like talking to stuff you didn't know, it's behaving in ways that you're like, aha.
Jean: And so yeah, for us, we're just like, okay if we said our mission was help people understand like what the heck their production systems are doing. And they want this basic stuff. This is how we fulfill their mission. And to me the vision is eventually there's so much stuff.
Jean: You can build on top of this. We've talked about this before the same way source graph is any question people have about their code. You wanna be, I think for us, it's like any question people have about their behavior. We wanna be able to give that with as little work as possible to the developer.
Beyang: Yeah, that's awesome. I feel like one of the key friction points in development is this like translation that has to happened between a static view of the code, which is like what you're thinking about when you're editing source and the dynamic runtime view of the codes. What's actually instant
Jean: what's actually.
Jean: Yeah. And then that's yeah, that's been super elusive. And so like a, a. Mountain. We had to climb to figure out our positioning was most of the observability tools out there and the monitoring tools are very ops focused. And for us, we're like we wanna build a very dev focused tool here. Yeah.
Jean: Because developers need to understand what's going on. So I think a lot of the ops focus tools, it's like we're gonna let you instrument everything. You need to instrument, and we're gonna let you know everything. And if you're really building a developer focused tool for this space, it's really about.
Jean: Helping developers get their heads around semantics, which like none of the monitoring tools do. And for the observability tools, they're dev focused in a, in a different way. It's if you're the dev and you have control of your system, you'll take an observability minded mindset from the beginning.
Jean: Then you can get like all of the benefits of a honeycomb or a data dog or a Grafana. And for us, we're like let's say you're a different kind of dev. You're what I call a 99% developer. You inherit a system, you work nine to five, you don't live and breathe tools. Like you don't get your your social cred from knowing about every tool that's on the street.
Jean: You like, you're not necessarily motivated or able to instrument your code correctly from day one. Cause it's not day one anymore. And you were like, I get no joy. From learning this tool on the weekend. And so who, like what happens to those developers? Because like right now for like other observability tools, like those developers are like the black holes of landscape, you have a few, like really nicely instrumented services and everything else.
Jean: Just okay. Yeah. That was either inherited or that team doesn't care about this and something we've seen is like, you'll have a company you'll have observability evangelist and people are like, yeah. If you like adopt all these like nice things from day one, then you can have all this don't you wanna be in and we're just like, like I've seen this play out with programming languages.
Jean: And I just, if there's no active reason to put in all this work people aren't going to and. As we're waiting for this to happen more and more legacy code is piling up that wasn't done this way. And inevitably in one to two years, we're gonna find better ways of doing it.
Jean: So you're always like the legacy problem is even bigger. for if you want, if you need to instrument your codes, understand it. And so for us, like our whole thing is just like, how, like, how can we really get in there? Tell people as much as possible. It doesn't have to be perfect. Like we're like what, like the phrase we say a lot in our, on our team is B plus on day zero solution.
Jean: Like it's never gonna be your power tool. You're always gonna need something better. If that's, if you want full control or anything like that, just like if you wanted to program in something beautiful, probably Python is not gonna be it, but does it get the job done? Is it like the most popular language today?
Beyang: You gotta go with the system that already exists, right? There's no world in which you get to rebuild this like huge mountain of code from scratch.
Jean: Yeah. Yeah. So like for us, it was, it's really interesting cuz I'm a couple years ago I wrote a blog post that was like, it's called from Balenciaga to basics, like how we came from.
Jean: Do you wanna know precisely where all your data flows to? Do you wanna know where your APIs are? And I feel like every month, like our process has been like more and more basics. We're like, don't you wanna know this? It's oh actually you really wanna know this. And that was much more basic.
Jean: And I think that's been really good for us. It's been really eye opening as.
Beyang: Yeah. It's interesting. It's crazy that we don't have something like this already. If you were to describe, to maybe like in another engineering profession Hey, the state of the state of the world in code is like all our running systems.
Beyang: We basically have very little idea of
Jean: yeah. Yeah. And I think that's, that was that's that other engineering analogy is something I've really been obsessed with for the last 10, 15 years, because there was there was a professor, Daniel Jackson, I don't know if you encountered him at MIT. But he was doing a lot of lightweight software verification.
Jean: So like, how do we prove software systems are correct and not completely sound weights. It's like similar to source graph, but it's if you made like lightweight models of your system, and then you like tried to ask questions about them is it true that the system will never fall down in this way and that way?
Jean: And he gave these incredible talks. That talked about engineering analogies if you're building a bridge, this is like how you would measure it and how you would prevent it from falling down. Or if you were doing if you're building a building here at building codes and something that always blew my mind was like, there's not the equivalent for software.
Jean: And I think, what you all are doing at source graph is one dimension of it. It's like. we're gonna get at software by seeing if you can search for certain patterns. I think that a lot of people in my field use that engineering analogy to be like this is why we have to model every stick in stone that, like every instruction, like my, the first paper I ever published was called safe to the last instruction.
Jean: And we modeled, we, we built this mini OS kernel that was completely verified. And that, that was the approach I believed in for a lot of years. But if you think about how engineers do it, they're not like measuring every atom. they're not like modeling every like brick it's a lot of duct tape yeah.
Jean: They like put like load on it and then they're like, doesn't break. Yes though. It's very test driven. It's very like, what did we end up with? And like how do we measure bridge or how do we measure a building is very much about like, how do we take the artifact that we've built.
Jean: Do stuff to it. And so this is why I think, what you guys are doing at source graph. I think things that like help you just stress test production system. So I think, chaos engineering, all that stuff, like that's like the first wave of it, I think there's gonna be a lot more of this stuff.
Jean: I think it's gonna be much more like stress testing and load testing and like telling people this is what's there. Then like I'm gonna test every property. Not to call out certain kinds of testing that I think are are cool.
Beyang: It's okay. Feel free to be opinionated on this
Jean: opinions are great. So I think that I think that a lot of people who are like, we're gonna measure software, blah, blah, blah, are like property testing.
Jean: That's the way, but I'm like, you gotta fricking specify every property. So we have people showing up for our beta and they're like, we wanna. The properties that property testing, miss, and that's gonna be every property man. I think no one wanted to write types. You think they're gonna write properties?
Jean: So I, I think that just like as much inference as possible for for like basically like load testing and measuring and getting people's heads around production is where the future. Awesome. Not to discount, like pre-production I think like pre-production you guys have it under control?
Jean: You're locking it down. I think like the next frontier is like, what's gonna happen in for production.
Beyang: No. I think that there's a really nice complementarity. Yeah. Oh, I
Jean: completely agree. Yeah. Yeah. And I saw you had John Kumal on your podcast. I think that like playing with like code search plus feature flagging plus telling people what act.
Jean: Actually happens. I think the future is like that kind of ecosystem, like piping things back from production all the way left and then having control over it. That's really I think where the future is. And I think that each piece, like any piece alone, isn't everything like production without pre-production stuff like doesn't exist very well because you can only get so far being like black box on the outside.
Jean: Yeah. So I think that the future is like something that like has a whole loop.
Beyang: Yeah. I feel like a lot of, what you do and what we do. And also what the launched Aley does is really just de obfuscating what's going on in code and making things accessible.
Jean: Yeah. And I think that previously, it was like, we're just gonna de obfuscate the next code you're gonna write tomorrow.
Jean: And what I like about all of our stuff is no, there's a bunch of stuff that already exists. You need to get your head around it. Here's how .
Beyang: Yeah. Yeah. The system already exists. We gotta run with the things that we have in production today that they are that way for a reason. Right?
Beyang: Like they've accrued this amount of code because you get edge cases when your thing is in production that you have to handle. And in some sense, it's almost so much of the software that we build is actually quite simple to explain in, in layman's terms, cuz like the algorithms and data structures are pretty straightforward, but it's like the translation from that like high level, like English level explanation to okay, here's all the source code that wraps around that.
Beyang: Or like here's all the
Jean: Yeah, here's the source code. Here's what interacts with. Here's how it's layered over time. And I think the piece, like the thing I really took away from my PhD was like, add any dimension to that code. Imagine adding new permissions to old code, like you have to touch everything this place with all this.
Jean: And then I realize. Imagine adding anything to old code, that's a cross-cutting concern. It's the same game. And you're gonna have all these questions. You can't really get your head around it. But yeah I think that right now, like code is seen as what you said. It's like a very static thing, but it's we need ways to engage with code that like has been written.
Jean: So an analogy I really liked from when I was working more on privacy was people would say data. A corrosive acid. It's just sitting there waiting to explode or, like it's degrading and I feel like code that's been written in the past that you don't have you haven't opened in a while.
Jean: That's like a bigger corrosive acid, cuz it's not going away. It's you can't rip it out like data, you can rip it out and maybe you lose some users and they're unhappy, but you rip out old code and your cycle's down. And I think that it took people a lot of years to realize data is a cursive acid.
Jean: And I think people are finally starting to realize code is a bigger cursive, corrosive asset. And we just haven't really been thinking about it that.
Beyang: Yeah. Bit rod is real and the long
Jean: out. Yeah. And it's you can't just excise the rod. Like you have to live with it. So what are you gonna do?
Beyang: it's a core dependency. You
Jean: can't. Yeah. Yeah. Cause I think there's a lot of optimism. Like I think that like software engineering has really shifted to be very far from programming where like people were like, oh yeah, code is just code. We can always rewrite it. Like blah, blah, blah, blah. Like software artifacts are like completely different things.
Jean: And I think that like only in the last five years have I really seen the industry really think about it as a whole that way. And I feel like we're still very early days in that.
Beyang: a, as far as the upcoming roadmap for Aquita looks what are the, some of the exciting like features or things on the horizon that you're really looking forward to?
Jean: Yeah, for us, it's, I'm doubling down on building for small to medium 99% developers. And so what we found is look, this is these are the people that we're resonating very well with right now. I think for a while, like startups play the game. What size do we really focus on? And I think that like for a while, we're like, okay, we're gonna like work on a lot, but then we're like, if we do bigger companies, actually there's like major other scaling issues cuz we're like processing API traffic in real time.
Jean: And so we're doubling down on serving the needs of. Small to medium 99% developers. And so that means building a lot of the features they've been requesting. So alerts is some, so like right now you can drop us in you can see metrics and errors. You can see your API endpoints, you can see usage, you can sort by latency P 99.
Jean: And so then people are like we want alerts on top of that. We want other things. And we're really excited to build that. And the guiding philosophy of our staff is like as little. Programmer intervention as possible because it's, like that's that's our audience. And we're like previously our beta was also not accessible to a lot of people cuz we're like just like getting real time.
Jean: Like we got real time in Q2, which like. Took a while. And then we're like getting real time for more than a handful of users was also like a thing that we did in Q2. And so now we're finally opening up our beta a little more, getting our onboarding more smooth, like that's what we're shipping this next month.
Jean: And so we're really excited just to get more users onto our platform, like banging on the rust edges. And so we're, we've been starting to ramp that up more.
Beyang: cool. Awesome. If folks are listening to this and want to give it a spin or try it out, where should they go?
Jean: So Akita software.com.
Jean: We have a join, our beta. We have our, yeah, we have a join our beta button. Just sign up. I think, especially if you join with your work email, you're more likely to get in. Cuz for us, like the use case were really going hard after is like IC developer in. Small to medium size company or team.
Jean: So it's, like company without a ton of DevOps resources, it's a developer who wants observability on their own systems. And so if you sign up with your work email or your real name, even I usually go and look up the people cuz. Our beta still has small enough capacity. I guess I have enough time on our hands that I'm like, okay.
Jean: We really wanna be making sure this is this is a good match. So yeah, if you sign up, I'll look you up and if it looks like your use case might be a good fit write to me if I miss you. So there are people who have written to me and they're like, Hey, here's my use case.
Jean: Or like I'm working on this for this project. Here's what it is. Like I, if anyone with a use case that sounds like we can help with and would be a good test for our system. I try to let in.
Beyang: Awesome. And you're pretty active on Twitter,
Jean: right? Yeah. I'm pretty active on Twitter.
Jean: I don't want I don't see everything that comes my way necessarily. Okay. Fair enough.
Beyang: So that's not the best channel, just email you then, or
Jean: If you, yeah, if you tweet at Akita software and the Akita software, DMS are actually open. If you tweet at me I am so active that I don't see everything, but if you tweet at Akita software that's the sweet spot, I think.
Beyang: Okay. Pro tip right there. All right, Jean thanks so much for taking the time. This is an awesome conversation. Thanks for sharing your journey as a programmer and also telling us more about Akita. It's a really
Jean: cool, yeah, thanks so much for having me on this was super fun. And I think that, like the source graph part and the ADA part and a few other parts, that's like the next, the next era of dubbed walls is really facing reality.
Jean: Getting people's heads around code that exists. So I'm really excited about.
Beyang: Awesome. As am I.