991: Pair Programming with AI in Your Python Notebook, with Dr. Trevor Manz

20:52Now, there might actually be an annoying user experience because the model is going to dogmatically follow these steps that I've canned. And I didn't anticipate something that the user might want.

21:00Jon Krohn:Yeah, this intuitiveness around the skill functionality reminds me of the intuitiveness, the increasing intuitiveness of even just crafting prompts for the back and forth conversation with an AI model and an LLM generative AI experience, where a couple of years ago, supposedly there were jobs that paid like$300 ,000 a year for prompt engineer, but that quickly went away as they figured out with the training data sets for the reinforcement learning in the post-training of LLMs that we don't need to have somebody crafting prompts in a very specific way. We can actually have the model increasingly magically intuit what the right thing to do is in a particular situation and anticipate what you're looking for.

21:46Jon Krohn:And I think that sounds, hopefully that sounds like a reasonable analogy to what the skills are doing as well, where, yeah, if you think about it a programmer, you're very prescriptive, you could end up kind of pigeonholing the LLM when it has so much remarkable intelligence that trusting it to kind of make the right decision ends up with a better result. Yeah. I think it's all that fuzziness and those edge cases that if you're too prescriptive, then you don't really benefit from the generalness of these models of being able to connect all the different contexts that they're able to grab. And I think when prompting was very, very important was in the era where it was very turn-based between the models.

22:27And so the only context that they had was exactly what you were saying inside of that prompt. And as we've shifted now into more agentic coding flows, part of that context is now just spread on your file system. It's over the network. The agent is able to bring what it needs to into the environment to help when you ask a very vague prompt, try to get more context to figure out how to answer that. And so it's about equipping these models with more tools to bring in the context on demand rather than like scoping the context in the beginning with like only what you're telling the model.

22:59Jon Krohn:Yeah. So this wasn't on my plan for discussing what I'm about to ask next, but I think it's really interesting probably for a lot of our listeners and for me personally. So your development environment these days, how do you set it up? Like do you use cloud code? Tell us about how, how do you code these days? I use Cloud Code with Git Work Trees and I'm running many Cloud sessions. I've always been a terminal coding person. You've always been a terminal coding person. For the most part, yes. I'm like a NeoVim. I feel like the first era of these coding tools came out and everyone shifted from VS Code to cursor.

23:43I wasn't totally ready to give up my editor. And then Claude or these agentic flows were really the first tools that really fit my workflow. But you wouldn't have been using VS Code either. I wasn't using VS Code.

23:55Jon Krohn:No, no. But more so that I think that there was these interesting integrations getting built into IDEs. And me with my very bare bones editor was kind of left out of those. Do you have a new Ubuntu? No, no. I'm a Mac user. Don't worry. But yeah, so then over time, I listened to some folks that I really trusted talking about these agent decoding tools and specifically Cloud Code. And then I started giving it a try and it really felt like it fit my workflow. I could put this thing off on a task for a bit and then review it with the tools that I was at hand. And now I'm finding that I'm jumping around my code base a lot less, but I'm using the the same kind of tools to help myself review code and look at the diffs that are being presented by these tools, yeah.

24:43Jon Krohn:Yeah, really cool. Beyond the coding, the development experience, you also obviously have a lot of experience doing data analytics, data visualization, data science in kind of a notebook environment. So maybe even walk through for us, you've now talked us through what your workflow is like when you're coding, but when you're exploring data, when you're doing data visualization, it could be interesting for our audience to hear what a power user of Merimo, how they use that kind of tool. Yeah. I've always thought that notebooks hold this really special place in the ecosystem because they are this environment that marries your code and data together.

25:22And so although I've been sort of this bare bones text editor for my traditional software development, I've always used some kind of notebook when I wanted to do data work or some sort of live REPL. I think my first thing I was in was RStudio and then I switched over to Python and started using Jupyter and now I'm a MarineMode user. Yeah, so I usually would spin up a notebook from the command line and just jump in and start loading my data. And now I find myself with the MarineMode pair skill, I'm often now... The way that I... Anytime I get an issue or often the place that I start to work on a problem is now in my agent encoding tool.

26:01So for me, that's often cloud code. If that looks like some task that I want to load some data, explore that data, I'm going to start asking to start up a Maremo pair session and then start describing a very high level sort of these are the data sets that I want to look at. These are libraries I think that I want to do. And sort of being a lot, like I was saying before, a lot more declarative about the approach that I want to take. I know exactly what I want to do with my data.

26:24Jon Krohn:And this is maybe a really dumb question, but when you, when you, when you start doing that Marimo pair session, that's in the command line or that's in like a notebook environment. That's in your, your agent. So it'd be like open code, cloud code, codex. You can just say like, Hey, I want to start working on my notebook that the Marimo pair skill teaches the agent how to start Marimo or connect to Marimo for you. And then you're driving Marimo from your agent. Whoa. So it would be kind of like you'd, you'd have it open in a browser window. And so you'd be working and say you could have Claude code running a terminal.

26:59Jon Krohn:And so you're typing into that terminal, but then the agent is changing things in your Marimo notebook. Exactly. It's open separately. Yes. And you can also collaborate on it. So you have the Marimo notebook interface. So if the code that it generates, or there's some tweak that you want to make to a cell, then you can go edit that by hand in the Marimo notebook. But then you can ask Claude, you say, hey, I circled something that's interesting in this notebook. like, can you tell me about it? And Claude has access to that state now because of the way that they share this context. So it's like all that rich information that historically has been like trapped in that environment now is more context that you can offer to the agent beyond your file system.

27:38Jon Krohn:That's so cool. I love that. Does it do things like if you, so if it had kind of been developing a notebook, had been getting going on some data analysis for you, and then you go over to your Chrome browser or whatever, and you make a change to a cell. Could you end up in a situation where either in the notebook experience or in the terminal window, it's watching what you're doing and it's just kind of like, hey, I like what you did there. Yeah. Right now, what we're trying to get our better feedback loops if you've made edits for us to stream those back, there's a feature inside of MCP that's called channels I think we might explore in that direction.

28:20At the moment, Claude has, or your agent has access to running code inside the kernel. So if you've made a change, it can grab any state that it wants inside the notebook. It can see your cells. It can take screenshots of cells now and look at those. So if you say, hey, there's something interesting here. I'm not quite sure what it is. Go off and use the other tools at your expense to help me understand what this is. At your expense. Exactly. Then that's something that's now context that you can feed back into getting somewhere with your data. I like to think of it as when I started really adopting agent encoding tools for traditional software development, software ideas started to feel a lot cheaper in the sense that, okay, that's not going to take me an afternoon.

29:04I could do that really, maybe just do this proof of concept. I've had so many of those times inside of notebooks where there's something I know that should look at or explore, but I don't want to figure out the API or I can't remember exactly this thing. And instead, I can just say, maybe we should try these different validations first, and then let it work on that problem and then make some plots and bring me back when I can make my decision.

29:25Jon Krohn:I like it. I also like the idea of in the not too distant future, being able to say to the agent, hey, you know that$8 ,000 you made last month on that vending machine business you run? I use some of that money if you feel like it's worth it on tokens to do this analysis. Yeah, it is pretty wild. And it's interesting how this vending machine problem has become such a benchmark of agentic capability, but it's a good one. I like it. I'll have a link in the show notes to information on this vending machine benchmark if people aren't aware of it. But it seems like agents could be making a lot of money on vending machine businesses in particular.

30:03All right.

30:04Jon Krohn:So thank you for that overview of the experience. And actually, you could probably even tell from the way I've been reacting, this has been a really eye-opening experience. Like you've kind of, it's great that you folks at Marimo are thinking so creatively about what the data scientist or researcher or data analyst, you know, anybody who's working with data, you know, reimagining what their experience could be like in this agentic era. And I think you've landed on something really cool here. I candidly hadn't used, as you can tell by the way I'm asking questions and being blown away. I hadn't used Mareem O 'Pair before recording this episode with you, but now I'm so excited to do it because it sounds like such a fun experience.

30:48Yeah. I think the thing that has been really important to us and to our users is what are people trying to accomplish inside notebooks? And as someone that I, like myself, worked in notebooks and have worked with a lot of scientists that use notebooks, often the code was a means to an end, I have this data problem and the thing that they care about is the data and the problem. And so giving them a better tool to be able to maybe offload some of the coding part to answer that task. While at the same time, and it's worth iterating, the thing that you're working on is a Marimo notebook. So it is this reproducible artifact.

31:25So the thing is not like a set of logs or just some Python code that ran or some scripts that end up on the system with an answer. It's a Marimo notebook. So that ends up being very important to stakeholders that want some artifact that they can audit and see, like, how'd you get to this answer? It's all this code that's encapsulated inside that artifact.

31:41Jon Krohn:A hundred percent. I love when my stakeholders are getting into my notebook. And that happens all the time. No, I know exactly what you mean. It is super useful. If even for you or people on your team to be able to come back later, to be able to collaborate on these things and to have a sense of where the data come from. But yeah, historically, it's not my experience that the executive sponsor is there. Yeah. Nice. So, yeah. So that gives us a really great sense of the user experience using RemoPair. I'd like to get a little bit more into how this works so seamlessly. So you recently posted on LinkedIn about recursive language models, which candidly is a specific term that I don't think I'd come across before.

32:29Jon Krohn:But it intuitively makes sense when we explain what it is. So recursive language models in which recursive reasoning may represent the next frontier after chain of thought and react, reasoning plus acting paradigms. So yeah, tell us about recursive language models and why they could be the future. Yeah. I think honestly, if you're using a coding agent today, I think that they are some form of a recursive language model. And I'll elaborate a little bit on what that is. It's some research that came out last year. But the idea of the of recursive language model is a system where essentially you have a model that it has some environment that it can offload its context to.

33:08So previously, everything that you had to do with your... If you've been using agents, a thing that people start to get very worried about is context rot, where there's this phenomenon that as you increase the context for the model, they start to forget or go off track. And so people are pretty conservative about what they put into context because they want to keep their model on track. And so one way that agents or a recursive language model helps with this is that they create an environment where the agent has the ability to, rather than taking the data and putting it in context, it can offload that to some part of that environment.

33:43And so for a coding agent today, that's your file system. It can take your corpus of data and things that normally you might need to shove in as context and just say, actually those are files on the file system. So do you want to look there? That's where they live. And you have tools to access that context when you might need it. So Marimo pair sort of extends this paradigm by also bringing in a paradigm. Yeah. Marimo pair extends this paradigm by allowing the agent to extend that environment further, but with Python. So now that context isn't just files, it can be values that you have in memory.

34:19And so instead of it having to try to understand all of the context of your data and pollute the context. Instead, you have your Python environment is another place that it can store that.

34:30Jon Krohn:Really cool. How do you think that this recursive reasoning architecture might reshape our understanding of intelligence, particularly within collaborative human AI workflows? Yeah, I think it's, well, at least in the context of Marimo pair, your notebook sort of is a representation of that memory. So the way that like we, like a lot of coding agents folks are thinking about like your file system as like the working memory for an agent. Now when you look at a Marimo notebook document, the notebook itself is the, is sort of a representation of that memory. So, you know, if I put a coding agent on a data task many different times, like the same question a bunch of times, it might find like 10 different ways to use the file system to answer that question.

35:21But Marimo sort of puts a little bit more of a structure around like how that answer has to look. And now at the end, you have your notebook might have some answer in it, but you have this really similar scaffold and each of the cells is sort of a representation of what the memory that it took to get to that answer. Wow.

35:38Jon Krohn:Super cool to think how things are going to continue to quickly evolve and our experience engaging with agents that can help us on any kind of task, including our traditional data science tasks. Really cool. Let's dig a bit now into what you were doing before, Marimo, because you did a lot of really interesting work that led to a lot of public results and open source work. And so So we have a fair bit of research on it. When you were in the high dive lab at Harvard Medical School, you were focused on building interactive visualization tools for computational biologists in particular so that they could analyze data more effectively.

36:20Jon Krohn:And as a consequence of that, over the years, you collaborated on several open source projects, including a library for multi-scale visualization of high resolution multiplexed bioimaging data called Viv on a scalable data profiler called Quack with no C and a toolkit for working with chunked, compressed, and dimensional. So like, you know, very high dimensional arrays. And that was called Zerita.js. And so I'll have links to all of those in the show notes. But as we mentioned earlier in the episode and ended up being how you transitioned into your role at demo, you created AnyWidget, which is a unified standard that lets Python developers bring custom interactive widgets into notebook environments across platforms.

37:08Jon Krohn:So I don't know if you want to talk about any of those other projects, or we can just dig into AnyWidget in particular. I mean, maybe zooming out about a common thread of all the open source stuff I've worked on. I was a big visualization nerd, and I love interactive visualization tools. but I always found that there's always an over a cost associated with using a visualization tool. So often we had users that lived inside something like a notebook environment. But we made this application that had some interesting visualizations and hopefully could help them come to this new insider understanding with their data.

37:41But that ask of trying to convince someone to use a new tool is something I took for granted in the beginning because people are often conservative in the tools that they adopt and adopting a new tool, it has to do a lot of things. So I started focusing on the data science ecosystem and specifically notebooks because there was such this powerful and useful tool and they're everywhere. So people use Google Colab, they use Jupyter, they use Marimo now. And what I found was we had all these web-based visualization tools that didn't have a good way of getting fit inside of those environments. And so a widget, it in Jupyter terms is this interactive element that's based, the front end is built with some web technology.

38:23And then the Python side is just a Python object. And there's this machinery that is done that allows the Python side to talk to the front end and backwards. And it's called like bi-directional communication. And that's a really powerful extension when you're living inside these notebook environments because it allows you to take something like a data frame or a dictionary, an object or something that is like data in Python and then get just this really custom interactive view inside the notebook. And AnyWidget was sort of a tool that scratched my own itch of building these types of things was kind of difficult.

38:55And making sure that they worked across all the environments that people were using was really challenging. And so, yeah, through that, I came up with AnyWidget was sort of both a standard, which is how do you define and create these interactive elements, and then the implementation that wires it up on the Python side. Yeah.

39:10Jon Krohn:And you had, it really took off. So congrats on that. In a SciPy conference talk, which I'll try to remember to put a link to in the show notes, you drew a fascinating analogy between chemical catalysts that lower activation energy and widgets that lower the overhead required to achieve data insight. You want to elaborate on that one a bit more? Yeah. That sort of goes back to what I was saying about the overhead of using tools. Like When you're in the Python ecosystem, the overhead of bringing in something like an algorithm feels very cheap because it's an import away or an install away. But I thought a lot during my PhD about what is it about visualization software that makes that feel like it's not quite at hand?

39:53And I think a lot of it is just because the way that they're packaged up or these tools aren't just a pip install away. It's like, you got to download this app, you got to export your data. So even though visualizations are really useful and helpful for coming to Insight, they are not quite at hand as the rest of the Python ecosystem. And so the analogy I was drawing with the reaction diagram was like, catalysts are a thing that can lower that overhead such that you can get to the outcome that you want faster with less overhead. And I think widgets are a way of taking these interesting visualization toolkits and packaging them up in a way such that they are a lot more like your Python libraries that you just import and use inside your notebook.

40:32Jon Krohn:Nice. And I suspect that that ease of use kind of relates to being able to be more creative, being able to be more playful, which brings me to my next topic. What's iPy Mario? Good question. iPy Mario is a fun toolkit that I made that is an any widget that I sort of did a live recording of making to just try to give like the bread and butter of how you create a custom widget because I think we have a lot of folks in the community that either come from the Python side or they come from the web side and they want to... And you kind of have to know these two worlds to start making them some of your own.

41:11So yeah, I made this sort of dummy project that is a little Mario brick that when you click on it, it jumps inside of a notebook. And we started with a piece of JavaScript code I found on Twitter. And then we go all the way to the end where it's a package that you publish to PyPI. So... What does it do? It does nothing other than just it shows you how to build such an integration and take this piece of functionality and integrate inside a notebook. But sometimes play is nice inside of these environments.

41:40Jon Krohn:And so, yeah, an interactive element. It shows you how to get all that from end to end and put that into a notebook. And it's hopefully trying to teach people the practices of, okay, you have this state in Python. You want to bring it into the front end. This is how you do that. And so, it's a very toy and dummy example, but I've seen enough buttons where I thought I wanted something that was a little bit more fun. Nice. And so it's interesting how, you know, you have this PhD in bioinformatics nominally. A lot of it focused on data visualization. It's interesting how you often think of data science, machine learning, AI, working with Jupyter Notebooks is kind of like, you know, backend development in a way.

42:22Jon Krohn:But actually a lot of what you've done is around user experience and the front end. Have you always been interested in this kind of like, I guess the full stack of the application experience? Yeah, I think I got my start. I did my undergrad in chemistry and not any like software engineering. And then I, but I made like websites for fun and I did not realize that these two worlds could be like connected in any way. But then as I started doing more research, I started analyzing my more data and I guess I was using more of the data science tool stack. And so I think over time I realized that these ecosystems are very good at different things.

43:04Like the Python data ecosystem is just so rich and battle tested for doing anything that you kind of want to do with data. But then the web ecosystem is not good at any of that stuff, but it's incredibly rich and accessible for building interactive interfaces. So So finding the right environment where you can plug those two things together, I think, is a really powerful way to provide new types of insight with data because often the visualizations that we have at hand might not be the best representation for what you're trying to understand. Being able to add this extra dimension of beyond being able to type code and run cells, now I can create a button that I click and that triggers something in my notebook.

43:45or being able to make a selection inside of a widget that then is like data that comes back into my notebook, like something like Python. It's just adding these extra elements of interaction that, yeah, when you see an outlier, your thought is not, okay, how do I write the query that selects that point? It's like, I want to just touch that point and tell me what that is and understand that inside the notebook. So there are certain tasks that are better suited for an interface and some that are better suited in code. And you just want an environment that lets you sort of play to whatever task you want.

44:15Jon Krohn:That's a really good example. I already called myself a dinosaur once, but here's another example of how you just described that great experience there where I could have a box and whisker plot with a couple of outliers hanging out beyond the whisker on that box and whisker plot. And of course, my mind is in a traditional experience where I couldn't possibly imagine that I could grab my mouse and click on one of those outlying data points and get information on it. Instead, I would have to, before a code gen tool, I would have to come up with a way of slicing my Python data frame and be able to isolate a few rows of the table that are over a certain value.

45:00Yeah, you're looking at it, the axes, and you're like, okay, what exactly is that?

45:04Jon Krohn:I think that's higher than 95. So I'm gonna say, yeah, anything with this column value of greater than 95, I'd like to see that row in this data frame. And that's obviously not a natural way of being. Yeah. And I think to bring it back to on the Marimo side in our reactivity, that selection that you make can now be a variable that re-triggers a cell that runs downstream. So if you select a point, now you can write your other cells that are dependent on that point and it flows through that reactivity. And that's a really powerful way of rather than you manually typing in those predicates to filter your data frame, just use the tool that's good at selecting those points.

45:46And then you have your code downstream that summarizes them or tells you something about them.

45:50Jon Krohn:Yeah, it's pretty cool. You have mentioned in an interview in the past that the web and Python ecosystems have been around for almost the exact same amount of time and have evolved in parallel and kind of mostly separately. But you are on a mission to kind of bridge these two worlds together. And so it seems like with any widget, with Marimo, with Marimo pair, we will have more and more of these interactions between front end, back end, as well as human and agent. It's pretty cool. Yeah. I think the thing that excites me the most is that about this toolkit now is before, if you wanted to make these types of integrations, I think you had to be very deep on both Python and the front-end side to plug them together.

46:37But now if you've got something that you want to look at inside of a notebook, like our Marimo pair skill has some best-in-class instructions of how to build any widgets hidden inside of it as a reference. So if you start talking about wanting to make an any widget, the model is going to help you maybe if you're not a front-end person understand how to wire those things up and start building something. And I think what I was saying before about the value of skills is being able to package up domain or specialized knowledge and having high impact in the way that you distribute it. Folks on my team build widgets.

47:09We build these types of integrated experiences and we want our users to just feel creative and not limited by the code to be able to build like the things that they want and to help them inside their notebook understand their data problem.

47:21Jon Krohn:Now my brain is so rooted in its old ways that when you talked about the best practices for creating in any widget being in the skill, my mind was like, oh cool, I can open up the skill and read it, but it's not for me. I will say the nice thing about skills is that they are very auditable and readable. So if you did want to learn about, I mean, it's in the AnyWidget documentation too, but it also makes sense in the Marimo context to explain exactly how widgets interface with Marimo and if the model is going to go off, we can provide that extra opinion such that the model, the user has a good experience inside the notebook.

47:58Right, right, right. Intended for the agent, but human useful too. Yes, exactly.

48:01Jon Krohn:Yeah. I had someone on my team recently say that, you know, the funny thing about everyone starting to write like ClaudeMD files or agent.md files or skills is that these should all just be like contributing.md file. Like the things that we should have in our repos for other people to contribute. But now because you can pay, like maybe it was just N of one working on that project before, and now it's me plus a fleet of like these coding tools. It's been useful to, it's actually been a forcing function for me to write it down somewhere, how to be most effective in contributing. Right, right, right.

48:32Jon Krohn:That makes a lot of sense. Beyond your Python experience, which a lot of our listeners would have experience with as well, you have a fair bit of experience with TypeScript. What is TypeScript for? Why is that a language that you use? Yeah, TypeScript comes fully from working on the website. So it's like anything that when you want to start building out these interactive interfaces, like the primitive that you get in the browser as a language is JavaScript. TypeScript is the the typed version of that language. I see. Yeah. So that was the key thing. It's like, I, you know, I'm pretty familiar with JavaScript.

49:08Jon Krohn:Yes. Probably a lot of our listeners are. It's kind of the default for building any kind of the front end of any web app these days. But okay, so TypeScript is like hard typed. So you have to, you have to declare specifically every kind of variable type that you're going to be using. Yeah, it's like Python with type hints, essentially. The main difference is that Python itself will actually run that code with the type hints in. The browser has no idea what TypeScript is. And if you put that in, it would just have a syntax error. So there is, when you make a package, or you publish that code, or prepare it for the browser, you have to strip out all that information.

49:43But when you're building really complex systems with JavaScript, it's helpful to have a type checker help you.

49:49Jon Krohn:And so that stripping out that kind of happens automatically as you compile? Exactly. Yeah, there's like a transformation step and there's a bunch of tools that do it. Right. And then so I didn't just arbitrarily ask this TypeScript question. Okay. Okay. I was doing it because a drawing from your work in both Python and TypeScript, how can something called the progressive software design philosophy be baked into languages themselves? So you've talked about this before and it relates even in your answer there, you were kind of talking about TypeScript being useful with very large projects. And so this is kind of, it sounds like this progressive software design philosophy is about moving from a single file to a modular project.

50:28Jon Krohn:Do you want to tell us a bit more about that? Yeah, I think, well, so my inspiration there was when the original way that you'd create like these custom widgets, you'd have to like create a full project to, and then like you had, then you were sort of burdened by all this tooling if you wanted to use something like TypeScript to be able, because now instead of just like opening up your browser and like writing some JavaScript code, you now have a build step before you're able to see that output. And I think that that overhead to like play or like trying out ideas means that it's just harder to try them out in the first place.

51:00And so you don't... You have to be confident in your idea before you try it out because it's only worth like setting up all that architecture to be able to try it out if you know that you've got a good idea. And so one of the philosophies in any widget is that it should just be JavaScript and that like the starting point, you should be able to prototype a widget inside of a notebook the way that you would like prototype a Python function. And then when you want to reuse that function, maybe you move it out of the notebook, you put it in a library. And I wanted that same kind of experience for building these interactive elements.

51:34Jon Krohn:It sounds like something important for us to be aware of as everyone in the AI space seems to be generating far more code than ever before, starting to think about how we make things modular, make things reusable, as opposed to just having these monolithic files is important. And yeah, it sounds like this progressive software design philosophy that you're describing is a nice approach to be doing that. Yeah. I think just getting the muscle of don't feel burdened by like trying out an idea, but maybe have something in the back of your head of like, okay, this is growing like at this scale, maybe we need to start applying different tools that help me make sure I'm accountable for maintaining this bit of code.

52:18Using types or type hints is a useful way of having very cheap checks that can eliminate a type of problem that... To what you're saying about offloading context, being able to have a type checker offload the thought of is this value an integer here is really a useful context to have when you're focusing on a problem. And also if that code is being generated not by you and by an LLM, being able to look at a function and say, okay, this thing can only ever be an int, that can be useful. So it does take experience with understanding at what scale do these things apply. But then certainly at the size of the code base of something like Marimo that we're working on now, we really put a lot of time into making sure that we have good checks and making sure that what we're bringing into that code base, because we also are generating a lot of code, is something that we can maintain over time.

53:06Jon Krohn:Brilliant. Great. Thank you for all the useful tips today. I'd like to spend a little bit of time at the end of this episode on the bioinformatics research that you were accelerating with your data visualization research. So we've talked about Mareem O 'Pair. We've talked about AnyWidget. So yeah, let's now talk a bit more in detail about your time in the High Dive lab at Harvard. So you focused on this critical intersection of biomedical informatics and composable visualization tools for genomics and microscopy. So this was tools like I candidly had never heard of these before, and I'm probably going to mispronounce them, but things like Vitessi, Highglass Python, and Goss.

53:46Jon Krohn:Yes. Yeah. And so from previous interviews that you've given, it sounds like you view visualization, not just as a final output, which I think a lot of us do, but as a fundamental way for researchers to interrogate the foundations of their scientific models. So yeah, how do composable modular systems change how scientific tools evolve compared to tightly integrated platforms? Yeah, how do these kinds of visualizations that you recommend, this whole way of working around visualizations around coding, improve scientific inquiry? Yeah, I think I've heard it described before as like there are visualization people and they're not visualization people.

54:31And I was very quick to being a visualization person because, and as a result, at every step of a pipeline or data process that I am working on, I want to visually have some check of what is going through my system. And the number of times that I have loaded a data set and there have been missing values or something at a very early stage that if I caught it, and often visually it's very easy to catch those types of things, I wouldn't have spent an afternoon going down some path and then finding out, oh yes, or baking in some part of that data into a result. And so I think that a place where my lab and research in the high dive group, it's a natural fit for an area like bioinformatics or computational biology because there are a lot of experimenters that are building out new types of techniques for acquiring different types of data about molecular systems or cell systems.

55:25And they often don't have it, like the data are very abstract. And it's like hard to have some representation that is like familiar in a way that you can like understand what that signal is in the context of like what you're trying to understand. And a classic example in like genomics is like a genome browser. So, you know, there's not a, there's not an off the shelf tool that lets you just look at regions of the genome. Like we, that's a tool that came out of you know biologists want to understand genes and proximity of genes together and so um now we have this ability to have a genome browser when we're talking about something like this gene we can look at and see where that is on the genome we can compare that across like different variants and things like that um and then when i worked in the microscopy side we were taking these massive images of these tissues and again there aren't these great tools there i mean there are several different tools for doing these types of things but like these tools Tools often are one-off applications.

56:17They don't live in the environment that you're working on your data. So maybe I'm running an algorithm to try to segment this image and it'd be really useful to look at that segmentation over the image and make sure that my thresholding or something is actually quite good. So being able to make these tools feel very at hand for doing those cheap kind of checks is really where I got inspired to work on this type of work. And then after that, it's like a matter of coding, I guess, to try to fit them together. Right, right, right.

56:43Jon Krohn:Yeah. Fascinating. You probably wouldn't know this about me, but a lot of my data science exposure was, I cut my teeth on bioinformatics data as well, like genomics data, and then mapping that to phenotypes or having intermediate RNA expression data. Yeah, so I find that whole area interesting. We probably could have spent a whole episode on it, But I'm actually, I'm going to get to my final topic area here, which is just a bit of a, you know, we've talked about all the exciting things that you're doing now and in your recent past, but actually your whole career arc is pretty interesting. And so I wanted to give you the chance to feel like for the audience to hear about it and for you to fill us in on maybe some takeaways from that.

57:31Jon Krohn:So before being a founding engineer at Marimo, your journey started in a small town in Wisconsin. And during college, you were an accomplished competitive swimmer, earning high grades and being active in a lot of different campus community initiatives. And then you were a National Science Foundation graduate research fellow at Harvard. Wait, oh no, Harvard. Right, right, right. And a visiting researcher at the University of Cambridge in the UK. So yeah, rigorous PhD research, a really exciting startup that's now owned by a really cool company like CoreWeave. elite athletic competition, amazing universities like Harvard and Cambridge.

58:14Jon Krohn:Do you have any advice for people on how, are there transferable things across all these different domains, habits that you've developed maybe that allow you to be so effective at these different things that you pursue? Well, that's kind of you to say. I guess throughout my career, having the energy to just spend time and go deep on a topic is like, I don't know what matches that type of experience of trying to learn something new. And I even find myself fighting it today in the sense that we now have these tools that are very good at giving us answers very quickly that I am actively trying to find ways to to keep myself sharp and when I do get interested in something to actually give myself the ability to go deep and learn about it.

59:08So I think it's easy to look at your career, your timeline, and then you construct a linear narrative of I did this to do this, to do this, to do this. My story was definitely not that. It was all along the way I did chemistry. I swam. I had no idea what I was going to do after college. Then opportunities come up. you take those opportunities. And I think, yeah, giving yourself the permission when something is interesting to go deep. And even if it's just for the sake of whatever interest that you have in it, I think that that gives you the ability to cut yourself or allow yourself to become a domain expert in whatever that is.

59:48Cut your teeth. Cut your teeth. Yeah, not cut yourself. I'm just cutting myself the whole way. Yeah, exactly. And I think there will always be value in going deep on a topic and becoming a domain expert on it. Nice.

1:00:01Jon Krohn:Yeah. And I think for you, for me, for probably a lot of our listeners, there's an inherent enjoyment in going deep and developing those new neural connections. There's something for me, when you think about the beginning of a calculus textbook and you work through all the exercises, is if you were to open the calculus textbook at the back and start from there, it would look like gobbledygook. But if you do it from the beginning to the end, you get to the end and everything makes sense. That's a really cool experience. I don't know for me. It's one of the kind of peak experiences you can have.

1:00:39Jon Krohn:And yeah, it gets harder, you know, first with phones and constant access to the internet over laptops. And, you know, I think it was easier in a lot of ways to go deep on a given topic that you're interested in, you know, before I had a phone and I just went to the library and kind of walked around and was like, oh, like those books in this adjacent bookshelf also look interesting. Let me take a look at that. And, you know, in theory, any of those kinds of things could happen on the internet or in conversation with an LLM or while you're collaborating with an agent on some task. But somehow in practice, it seems to happen less, or it seems like there's the activation energy to go and do that.

1:01:30Jon Krohn:It seems like it requires more for me to get over that hump. Yeah. I think curiosity will always be valuable. And catering to your curiosity and indulging in some interest is just, well, wherever technology takes us, keep, stay curious, keep doing things. Yeah. It actually is funny that I wasn't going to get to it, but the very last question that I had in this set of potential questions and topics that our researcher, Serge Masise, put together, the very, very last question is that you mentioned that your curiosity led you from a single tweet by Mike Bostock to fully packaging a Python widget for PyPy.

1:02:10Jon Krohn:And so, yeah, curiosity is, yeah, it sounds like it's kind of a common thread and a key part of your success. So thank you for that. Nice. Well, while I've gotten through all of our questions specific to you, you may or may not know that I end every episode with the same two questions. And one of them is very easy, though. The final question is very easy. The penultimate one, I usually give guests a heads up because sometimes they like time to think about an answer to this. Do you have a book recommendation for us? And you can actually, we can cut the cameras and you can think about it for a little bit if you want.

1:02:49I've been reading Soul of the New Machine recently. It's by Terrence. I'm forgetting the author.

1:02:57Jon Krohn:It's okay. See, that's the kind of thing that people get to do when I give them a heads up, which I remember to do 99 % of the time, but didn't today. We'll find this. Soul of the Machine? Soul of the New Machine. Soul of the New Machine. Yeah. I'll have that in the show notes, and whatever Terrence's last name is, we'll get there. Nice. What's it about? Is it fiction, nonfiction? No, it's nonfiction. It's about a computer company in the 80s. People that care a lot about the craft. And I think that in an era where there's a lot of code that's getting put out into production, it's just cool to see people and hear about these stories of folks that really, really care.

1:03:31Nice. Yeah.

1:03:32Jon Krohn:Great. Sounds like a great read. And then I promised this would be an easy one. Okay. This episode has been sensational. I have loved learning from you. The way that you talk about everything is so easy to understand, even when it's, you know, relatively complex technical topic. And so I'm sure there are a lot of listeners that would love to be able to follow you for your thoughts after this episode. What's the best way to do that? You can follow me on X. I'm Trev Manns there. I'm on Blue Sky, LinkedIn. If you're interested in the GitHub or like on open source contributions, I'm on GitHub. I'm on the Marimo repo.

1:04:08So, yeah.

1:04:09Jon Krohn:Nice. Fantastic. And yeah, of course, it's worth a mention that there's, you know, quite a few open source projects that were mentioned in this episode, Marimo, any widget, obviously. And so get in there and contribute to those projects as well if you want. Yeah, definitely. Nice. All right. Well, Trevor, thank you for taking the time. Again, such a great episode. And it was nice shooting with you here in New York. Yeah, thanks for having me. Absolutely stellar episode today with Dr. Trevor Manns. In this episode, he covered Marimo Pair, an agent skill that teaches coding agents like Claude Code how to drive a Marimo notebook, reading cell state, running Python in the kernel, taking screenshots of cells, and iterating on data tasks the way agents iterate on traditional software.

1:04:53Jon Krohn:He talked about recursive language models, which give an agent an environment, a file system, a Python runtime, a notebook to offload context into instead of cramming everything into the prompt and triggering context rod. He talked about any widget, his open source project that defines a unified standard for building interactive widgets that work across Jupyter, Colab, and Marimo notebooks, plus the Python machinery that wires the front end and back end together. And he also gave us his advice that no matter where AI takes us, curiosity and the willingness to go deep on a topic and become a domain expert will always be valuable.

1:05:27Jon Krohn:As always, you can get all the show notes, including the transcript for this episode, the video recording, any materials mentioned on the show, the URLs for Trevor's social media profiles, as well as my own at superdatascience.com slash 991. Thanks, of course, everyone on the Super Data Science podcast team, our podcast manager Sonja Brejovich, media editor Mario Pombo, partnerships manager Natalie Zajski, researcher Serge Massis, writer Dr. Zara Karche, and our founder Kirill Aromenko. Thanks to all of them for producing another super episode for us today for enabling that super team to create this free podcast for you.

1:06:00Jon Krohn:We are deeply grateful to our sponsors. You can support the show by checking out our sponsors' links in the show notes. And if you'd ever like to sponsor an episode yourself, you can find out how to do that at johnkrone.com slash podcast. Otherwise, please do support this show by sharing this episode with someone who would love to listen to it or watch it. Review the show on your favorite podcasting platform or YouTube. Subscribe if you're not already a subscriber. But most importantly, I hope you just keep on tuning in. I'm so grateful to have you listening and I hope I can continue to make episodes you love for years and years to come.

1:06:34Jon Krohn:Until next time, keep on rocking it out there, and I'm looking forward to enjoying another round of the Super Data Science Podcast with you very soon.