Wicked Good Development Episode 26: Tom Cools

February 03, 2023 By Kadi Grigg

23 minute read time

 

Today we are celebrating World Open Source Day: a day of celebration of the hard work and dedication done in the open source community and an opportunity to come together and share knowledge and experiences. At Wicked Good Development, we thank open source maintainers and contributors for their endless pursuit of showcasing the power of open collaboration for the advancement of technology.

In this episode, Kadi and guest co-host Theresa Mammarella invite open source contributor, Tom Cools, to share his journey in the world of open source. Sit back and relax as we talk through why he got involved in the community, what his first project was, and best practices to make projects more accessible for new contributors.

Listen to the episode



Wicked Good Development is available wherever you find your podcasts. Visit our page on Spotify's anchor.fm

Show notes

Hosts

Panelists

Relevant Links

Transcript

Kadi Grigg (00:11):
Today, we at Wicked Good Development have a special treat for you. We are celebrating World Open Source Day, a day of celebration for the hard work and dedication done in the open source community, and an opportunity to come together and share knowledge and experiences. At Wicked Good Development, we thank open source maintainers and contributors for their endless pursuit in showcasing the power of open collaboration for the advancement of technology. Here's one contributor's story.

Kadi Grigg (00:41):
Hi, my name's Kadi Grigg, and welcome to another episode of Wicked Good Development, where we talk shop with OSS innovators, experts in the industry, and dig into what's happening in the developer community.

Theresa Mammarella (00:51):
Hi, my name is Theresa Mammarella, and I'll be your co-host today. I work as a Developer Advocate at Sonatype, and I've been involved in the open source Java space for about five years now in JDK development, and now currently helping open source projects secure their codebases and third-party dependencies.

Kadi Grigg (01:10):
Today, we have a great episode lined up for you. Today, we have Tom Cools coming to us from Antwerp, Belgium. So Tom, before we get into the conversation today, for the listeners at home, can you give an introduction of yourself?

Tom Cools (01:23):
Oh, introducing myself. Always a weird moment. So, hi everyone. I'm Tom Cools. It's unfortunately not pronounced schools. It's Cools. It's C-O-O-L-S. People told me that I shouldn't say that. I should just keep it a secret because yeah, whatever. I'm a software developer for nine years now at the company called Info Support. I did my internship there and kind of kept hanging. It's a consultancy firm, so I get sent all over the place. I've done pretty big projects for the financial industry, for the shipping industry. Quite a lot of different stuff, which I quite kind of enjoyed. And I'm also a trainer and coach at Info Support, so sometimes we give trainings and then they allow me to teach Java for a day or Docker for a day. So, it's a nice switch between being able to do consultancy and teach a bit. And next to that, I occasionally speak at conferences, because that's what I like to do-- share my knowledge and just enjoying life as best as I can while also helping a lot of other people.

Kadi Grigg (02:24):
Well, thanks for being here. Let's dive in. So, Tom, I recently had the privilege of watching you present actually at Devoxx Belgium a couple months back. And I wanted to, before we get into more of the open source stuff, just get a better understanding of how you move from having a teaching degree and being a coach trainer, Java developer guru.

Tom Cools (02:48):
How did I do the switch? Well, I did my teaching degree when I was-- well it takes three years. So, I was 18 when I started it. I was 21 when I graduated from my teacher's degree. And I was looking around and, you know what kind of teachers I appreciate the most-- that's the people who have work field experience. So, I did high school. I did three years for my teacher's degree. I graduated as a teacher, and I was like, okay, am I going to teach for the rest of my life? I'm 21, I don't know how life works. So, I decided, you know what? I want do something else first. So the last year of my teacher's degree, because I'm allowed to teach IT subjects, which means Word, Excel, PowerPoint-- excellent, good stuff-- but they also showed us two lessons of JavaScript. And it was like I actually like this a bit more than the teaching part.

Tom Cools (03:42):
So, then I went into my IT degree. And that's how the ball kind of got rolling. So that's kind of the switch. I just felt I wasn't ready to go into education yet because I was too young. I didn't know anything about the world, and I don't want to stand in front of a bunch of students, bunch of kids basically, and tell them this is how the world works. Well, I've never seen the world. I was just inside education all the time. And then when I was finishing up my IT degree, I had to find an internship. And the company I work at now, Info Support, since they also provide training it was a nice mix for me. Because I still love teaching. I love sharing knowledge. But Info Support does consultancy and training, so I was able to to mix my two passions basically. And that's also when I started going to conferences and sharing my knowledge there. Because it's kind of the same as teaching. It's a bit more unidirectional. But if you've seen some of my sessions, I try to include the audience quite a lot and make it like a fun experience for everyone.

Kadi Grigg (04:40):
I honestly think that's the best part of watching you present-- it's just how you make it so relatable and interactive. Asking the audience questions or even using the plushie as the example.

Tom Cools (04:52):
Yeah. That's going to have to be explained at some point. Put a link to the video in the show notes because just saying, "oh yeah, you use a plushie on stage"-- that's gonna raise a few questions with the audience.

Kadi Grigg (05:03):
That is a fair point. I will make sure to do that. So, you mentioned how you moved over to Java at Info Support and how that internship really grew. How did you-- you've been in this space for quite some time now, but what was really your first working project with open source?

Tom Cools (05:23):
My first working project with open source? You mean actually working on open source software or being involved in having to select an open source framework?

Kadi Grigg (05:32):
Being involved. We'll go with that one.

Tom Cools (05:36):
Being involved. That was awhile ago. I think about six years ago, when microservices first started to pop up. There were a few frameworks that were really focused on how do I deploy a Java application without having a separate web application server. So, it used to be you need an IBM WebSphere server or you needed a Tomcat server, how you were creating WAR files instead of JAR files. And the WAR files need to be handed over to a different team, and they need to install the WAR files. But when microservices came, I was like, this is not something-- if you want do microservices, that's not a good approach to do it. So, you've got these frameworks that actually had runnable JAR files. It's so common now. It's Spring Boot and MicroProfile a micro node and, Quarkus that you have a runnable JAR. But it didn't used to be standard a couple of years ago.

Tom Cools (06:30):
And the first framework I actually got involved with was called Dropwizard, which was, if I get it correctly, was a Tomcat server that was packaged together with your code in a runnable JAR file. So, you just had to Java JAR and then your JAR file, and it would start the entire application server. So, it was my interest in microservices actually led me to Dropwizard. But there was one thing that was missing in that Dropwizard library that was support for WebSockets. And then my first open source contributions was making a plugin for Dropwizard that allows you to use WebSockets with Dropwizard with this framework to create microservices, which is pretty cool because I've never contributed anything to open source besides some comments, but I'm not even going to mention the documentation. While that's valuable, I consider my first real contribution to be the plugin for Dropwizard.

Theresa Mammarella (07:25):
That's really impressive. I actually went to a session at All Day DevOps where they were talking a lot about, like you mentioned open source contributions and sort of starting with what a lot of people do, which is documentation and that kind of sort of small contribution. So, what do you think was the biggest challenge for you in making that gap between sort of smaller fixes towards a feature like that when contributing to open source?

Tom Cools (07:54):
What was the biggest thing? It was more-- I do a lot of things either out of really being hyped about it or being really angry about it. That's how most of my conference sessions start. And for Dropwizard, it was a frustration. I like the framework, but it just didn't have this one feature. So, I started looking into how can I implement it? So, then I switched from "you know what, I have another experience now." I think I was working for two years, and I felt, okay, I can probably do this. Let's just give it a try. And it turned out just to work for me, which doesn't mean-- I don't want come off as documentation isn't valuable. It's a very good way to contribute to open source and make your first steps, get to know the software a little bit. But it still has a little extra spark when it's code that you're submitting. Like you know that whenever someone uses this framework now or this library that it goes through something that you've written, a little bit daunting but very cool to know "oh, this library has 10,000 daily users," and you know that you've made some impact.

Theresa Mammarella (08:59):
Absolutely. Well, I think it is like in your talk, how you have that sort of circle of learning where you have to start learning just one thing that you don't know. Where I think starting in open source, you want to do something that's easier so you can sort of understand the culture that is contributing and participating before you also apply the skills that you already have. But you might need to learn a new codebase and things like that.

Tom Cools (09:22):
Yeah, exactly. And I think we kind of underestimate what it takes to contribute to open source. Because you need to know Git-- it just doesn't start-- if you start developing, you need to know Git to do any kind of contribution, even the documentation. So, if you've never contributed to open source, I would really recommend to do some documentation changes and see how the entire process works. How do they accept merge requests? Do I need to submit an issue first, or can I just change it? People will point you to the contribution.md file, so you have to read that and kind of get up to speed with it. The only thing that I-- so, I have a new conference talk that I've given once, and it's partially about onboarding people. And we think about onboarding when people join a project, but we don't think about onboarding a lot when it comes to open source.

Tom Cools (10:13):
And there's one thing that's been happening the past couple of years, and I don't know if you've seen it, but it's those labels "good for starter", "good first issue." But if you really look at those "good first issues," it's not always that good. I saw a couple that literally said "replace Postgres with direct connection with PgBouncer." One line and the label "good for starter." And I was like, if a starter sees this-- as an industry, we're trying to motivate people to contribute to open source, and then there's projects that do that kind of stuff and a starter goes: "Oh, I have learned I can contribute to open source. I'll look at the issue. Oh this is really hard. I don't even know what this is saying." So we need to, I think, as the open source community, we can be a bit better in helping onboard new people and not just slap the "good first issue" label on everything.

Tom Cools (11:08):
But I think what would really help is actually writing almost pseudo code in the issue and then say, "this is a good first issue, just implement these steps." And actually write it out. It's a bit tricky because contributors just want to close issues, or sometimes they are very focused on closing issues, issues, issues. And if it's a small change they think: "Oh, but I can do that in five minutes. Let me just take a quick look, merge requests, and it's finished." But if you want a really good first issue, it's those simple things. You write out the pseudo code, and then you say: "This is a good first issue. Look, I fully described what you need to implement. If you still need help after reading my description..."-- basically a sort of tutorial on doing a small change. That could be very valuable for people starting out with open source.

Theresa Mammarella (11:57):
Yeah, I think that's a really great tip. A lot of the things I see with those kind of first contribution labels are either they're from four years ago and nobody bothered to do them, and so you're like "is this even relevant anymore?" Or they're not complex enough to really help you understand the codebase, which is the whole point. So, I think that's a really interesting suggestion of giving sort of a halfway "here's how I would approach the problem." So, you can kind of help somebody dive in and get to know the project better.

Tom Cools (12:30):
Yeah, because you still need to be careful, because you say the issues don't dive deep enough to get to know the codebase. But I think it's-- implementing an issue like that to get to know the codebase is asking a lot from the contributor. They first need to read the codebase, understand the codebase, and then apply a change. And I think it's quite valuable to just give them a list of: "This is the steps that you need to do. Just do these things, and you'll touch a few pieces in the codebase. And next time you'll be ready to explore it a bit deeper." And I think most of those labels, as you say, sometimes they're so old, I think instead of "good first issue," it should say "we are desperate, nobody has picked up this issue in four years, which is desperate, so pleaseplease someone pick it up." But it's not a good-- it's quite often not a good first issue.

Theresa Mammarella (13:19):
Exactly.

Kadi Grigg (13:21):
Do you often see issues like that, that are super outdated, like four years old or just waiting for someone for desperate help?

Tom Cools (13:29):
Yeah. But, I must say I don't see a lot of them that are labeled as "good first issue." I see them as either they're not relevant enough to pick up, or there hasn't been time to pick it up. Sometimes quite literally, the open source owner doesn't know the answer to the issue. We can't find it, and then it stays open. That's a possibility.

Theresa Mammarella (13:52):
So after Dropwizard, where does your open source journey take you next, and what's it look like now?

Tom Cools (14:00):
So, for me I'm a consultant. So, open source basically means that I have the option-- if I have an issue in a framework, I can go to the framework and list an issue. I can try to do a pull request if it's, well, simple enough for me to not have to spend two weeks to learn the codebase of the open source project unless if I really have the time. So, that's the biggest part for me. And then open source, some of my silly-- so, whenever I show code on a conference talk that's also open source, I just dump all my knowledge in the repository and share it with other people. Because for me, putting things online and sharing the code is a good way to allow people access to what you're thinking. And it really enhances blog posts as well and videos that you make showing some code that really just gives them a different dimension, gives them way more information than they would otherwise have from your blog post. Because you can't-- it's a bit tricky to copy paste all the code in there and then be able to navigate it. And besides that, I'm quite a silly pants. So, I like to make weird little experiments and then put them online. And I think the one that I like the most-- because you both work at Sonatype, so that's kind of security dependency-based-- so, my most starred GitHub project, are you familiar with Rickroll?

Kadi Grigg (15:29):
Yes! I think it is so funny, and I have had several people do it to me, but every time I giggle when you see that video.

Tom Cools (15:36):
Yeah well, when you have a new hacker and they go to their browser, they see I have a website, I'm going to type (slash) wp-admin (dot) php just to see if the admin page of a WordPress site is available or something. They will try to not really hack, but just see is something really open here. So, what I did is I made a Spring Boot plugin, a Spring Boot starter, and you can configure paths or extensions like .php and when someone goes to your server and someone types admin.php-- well, you know it's a Spring Boot application, so it's never going to serve any PHP then it redirects you to Rickroll. That's all that started this.

Kadi Grigg (16:25):
That is amazing.

Tom Cools (16:25):
And the great thing is that it wasn't originally my idea but someone else implemented it for Node, I believe, and I was like: "Huh, I actually always wanted to know how to make a Spring Boot Starter. This seems like a good use case to make a Spring Boot Starter."

Kadi Grigg (16:41):
That is amazing.

Tom Cools (16:42):
And I put it online, and I said "open for contribution." It was actually my way to test out "what do I need to give other people, so that they would contribute to this as well." Like what kind of guidance do they need if they want to contribute to this. And two weeks later I had a merge request from someone from the Spring team to add additional features to to my little library. So, that was really fun. It was really fun. And then a while ago someone told me: "You know what, have you heard of Gitpods before? It's like something where you can have an online development environment." And now if you go to that pageI can show it to you later maybe there's one button that says "Open in Gitpod."

Tom Cools (17:32):
And when you click the button, the browser opens a remote desktop where you can actually change the code and create a pull request in the browser. So, you don't have to install anything locally. You don't have to install any IDE. You don't have to install Docker. Whatever you need is in that Gitpod, and it's just one button away. You click it, and it opens. And that's a real enabler for open source projects, I believe. Because one of the challenges that some people have with contributing to open source is just setting up their local environment. I think it's the same when you go to a new project. It's like, "here is the list of 50 things you need to install before you can write a line of code." But you can script that in Gitpod, and it will actually just start up a virtual server in the cloud somewhere. And it's ready to go. It can start working, and you don't have to worry about all the setup. So, that's one of the things that I added to that repository as well. So, you learn a lot if you try to open source things from the other side when you try to open source some of your code.

Theresa Mammarella (18:31):
Yeah, I love the idea of contributions being easier. And actually yesterday I made a contribution to a README for a project, and so I just used how you can go on the actual website instead of using Git. And it actually created the forked branch for me automatically, which I have never seen before. So, I don't know if that's a newer feature.

Tom Cools (18:53):
You mean the GitHub website then? Right?

Theresa Mammarella (18:55):
Yeah, I went in to edit, and then it just automatically made it instead of me having to do it. So, I don't know if that's been around for awhile, but I was very excited about it.

Tom Cools (19:04):
Yeah, I noticed yesterday as well. It's probably one of the easiest contributions you can do you. You see a spelling mistake in the README file, or you see that someone uses "mvn clean install"-- which you shouldn't be using people. Then you can easily change it without even having to open an IDE.

Theresa Mammarella (19:21):
Yeah, I love that it's getting even easier. So, what other tips do you have for maintainers to make their projects more accessible for new contributors?

Tom Cools (19:32):
So you both have seen my session, so I'm going to give a bit of context for the people who wouldn't have seen my session. To backpedal a little bit, I have a teacher's degree. So, while learning to become a teacher, you learn a lot about learning and teaching. One of the concepts that they tell you about is Lev Vygotsky's zone of proximal development, which is a very simple model that basically states, "there's a few things that you know now and based from where you are now, there's a couple of things that you can learn and there's a couple of things that you can't learn." For example, if right now you know how to do simple math, 2 + 2, they can probably learn multiplications. But thinking of some kind of weird algorithm or formula that will send us to the moon is going to be too complex to learn.

Tom Cools (20:21):
You need to take certain steps, and that's always what your teachers help you with. And I think when you're trying to onboard someone, if it's open source, or if it's just a regular project-- sounds a bit demeaning-- but a project at a company then I think it's really valuable to take that into account. First, look at-- someone comes onboard, okay, what do they already know? Do they know Java? Do they know Maven? To what degree do they know those two things? Because if you have a starter for example, I had a starter who had never used Spring before. He knew Java very well. He knew Quarkus really well. But we use Spring. So then, if you know where they are, then you can use that information to help them learn Spring. For example, most of the annotations are just slightly different when you're doing RestController in Spring or in Quarkus.

Tom Cools (21:11):
But that's something that you can use. You can really use what they already know. Now in open source, this is a bit more difficult, because you don't know who is going to onboard on your project. But what I think is really relevant there is prerequisites. And I think even on those "good to get started" issues, it could be valuable to add, "Hey, if you want to do this, we probably expect you to know something about Docker." If it's a Docker-related issue in your open source project, or "we expect you to at least know this and this feature and the Java language." I think that's one of the first one. Really scope, make it clear to the people who want to onboard, what do you need to know. And if you want to go one step further: "And here is where you can learn those things if you are only starting out in Java." For example, one of the courses that I often share is-- I don't know if you know Angie Jones Java Champion. She's amazing, and she has probably the best, at least one of the best, free Java courses online. So, when I have someone that's like, "Oh, I want to learn some Java by contributing to open source," I usually tell them take some time to learn some Java first, and here's a free course by Angie. So even when you see that people want to contribute to open source, try to get the bar as low as possible. I think that's probably the main thing. Keep the bar as low as possible. And actually I read this book by Felienne Hermans, which is called "The Programmer's Brain," and she has an entire section on how to onboard people in a better way.

Tom Cools (22:47):
I don't know everything by heart, but one of the things she says is "read code, give people just the exercise, summarize this piece of code, because when you are asked to work on something, change something in the code, really contribute to an issue-- you're asking a lot from them." You're asking them to read the code, to understand the code, just the lines of codes. But you're also asking them to understand the structure of the code. Then you're asking them, "please change something here." Which is quite a lot to put in your head. Like there's only so much processing power that our brains have to deal with this. So, even having code reading exercises just say, "just read this piece of code and see if you can make a summary." I know that this feels really weird, because it doesn't directly contribute to the open source project, but it can really help to onboard people to your open source project.

Tom Cools (23:45):
Say, "here's a piece of code, and I'm going to explain to you now what this piece of code exactly does." Because I was thinking about this a bit more, and I was like maybe-- and this is just an idea-- maybe we could have live coding sessions like on Twitch I'm going to work on this issue and I'm going to explain it like the people who are listening are five-- explain it like I'm five, the expression-- but I'm going to do it on a Twitch stream and hopefully someone sees it. And then you can tell them: "Hey, this was kind of how this piece of the code works. If you are interested in helping with that piece of the code, you can come onboard and can further help as well." So, if there's like a bigger codebase, and you have specific things where you want help from the open source community, it could really help to make a short tutorial just explaining that piece of the codebase and then saying, "hey, this issue" and maybe then label it with "this is for user management." And you make a user management video that shortly explains how user management works.

Tom Cools (24:49):
It doesn't have to be a video. Could also be a-- but something that really helps them to understand not just say "pull requests are welcome," was another comment I often see on issues. And that just doesn't work. We are asking them to do so much effort. They already made the effort to submit an issue. Maybe then be kind to those people that come and try to help you out.

Theresa Mammarella (25:12):
Yeah, that makes sense. I think just like in, if you're joining a team, there's a certain amount of onboarding effort that needs to happen to make someone successful, and that should really be the same as in open source as well.

Tom Cools (25:24):
Yeah, and things that I see most frequently is someone new joins the project. What's the first thing they have to do? Solve a small bug. "Oh, We have a small bug for you-- we've reserved it for you." What that means is: "Read our entire codebase. Try to figure out how it works, and then fix the issue." But then all the things they need to learn in that short period of time-- I've seen people just basically flip, especially like when someone comes straight out of school a junior developer. So, someone that just starts with their IT career. You give them that task. They feel stupid. And they feel stupid because they are just overwhelmed. And I'm saying they feel stupid because they're not stupid. They just have been given a task that makes them feel that inferior. Especially if you then have like a nasty lead developer that says, "oh but it's just a bug."

Tom Cools (26:18):
"Just." That word is really-- "It's just a bug. It's not that difficult. See, I'll do it for you in one minute." But the lead dev knows the entire codebase, knows the entire structure. So, as I said, most things I do start from a rant. This is kind of the rant that I'm doing in my next conference talk. So it's kind of related. But I think it applies to, especially applies to, open source development. We need to be friendlier towards the people that actually want to come help and don't put them in situations where they feel stupid just because we didn't explain things or didn't onboard them properly.

Kadi Grigg (26:54):
And I think that's a great thing in everyday life though too. You know what I mean? Whether you're onboarding in a new company, joining a new sports team that you do-- I mean, anything in life is what you can really apply that to. It's just leading with some compassion for people who are new to it.

Tom Cools (27:08):
Yeah, definitely. And I like the term "setting someone up for success." Doing everything possible so that they are successful. Even if that takes-- even if that means taking a step back and going a bit slower for one sprint just to make sure that they're decently onboarded, that just lasts long, a lifetime almost.

Theresa Mammarella (27:32):
I think it's great that you're talking about this, because there certainly is this strange culture that we have in software where you sort of-- you have to pay your dues, you have to suffer through those first few bugs when you join a team. And it doesn't have to be like that.

Tom Cools (27:45):
You have to suffer as much as the rest of the team is suffering to be a real developer, to put it cruelly. That's so much nonsense. We should be better than this. We should be helping especially-- I have kind of a soft spot for this, but there's a lot of people in our industry that feel like they're not welcome especially women or non-binary people that already feel kind of shunned based on your gender. But also people that graduated at a bootcamp instead of formal education. People that join our industry later. What are we doing when we onboard? We quite often, we make them feel more stupid and feel like they don't belong. And that's something that's just so disastrous for us as an industry. We should be way more welcoming and way more trying to make sure that people succeed instead of leaving them somewhere to suffer because we once suffered or for whatever reason that you might have.

Theresa Mammarella (28:49):
Absolutely. There can be a balance. I think the most success I've had onboarding a newer developer has been not assigning them a bug at first, but assigning a very small and very manageable feature. And then when they finished it, they were so excited that they didn't mind starting to do the bugs as much. Because it is valuable to solve bugs, but there needs to be some positive feelings there too, especially when you're volunteers.

Tom Cools (29:20):
At that point, you've already validated them that they're valid and that they belong. But if you're going to some kind of company, and they don't give you a decent onboarding at all, and they just let you work on features. But you don't understand the codebase and nobody wants to help you, like what does it do to-- I've seen people quit our industry because of that. And that makes me so angry that I talk on stage about it and almost rant to the audience. But it's something that's really struck a nerve for me to see good people leave our industry because we just don't care enough about each other, I think, in some ways.

Kadi Grigg (29:57):
So, Tom, we we're kind of at time, and we've talked about a few different topics here today. But I would like to get your final thoughts. Under the lens of today's conversation, what would you say is "wicked good development" to you?

Tom Cools (30:11):
What is wicked good development? It's a really good question. I'd say wicked good development is development that inflicts no pain to the developer creating it and anyone who has to work on it afterwards. And you can even flip it from "no pain" to "that gives a good feeling to whoever has to work on the codebase." And that could be the next developer that you onboard on your team. It could be the maintenance team that takes over after two years, and the project team just goes: "Yep, over the wall. Here you go. Good luck with it." If those people still have a good feeling when they see your codebase, then you've done some wicked good development.

Kadi Grigg (30:54):
Beautiful. Well, Tom, thank you so much for taking the time to be here today. We've really enjoyed speaking with you.

Tom Cools (30:59):
You're welcome.

Kadi Grigg (31:03):
Thanks for joining us for another episode of Wicked Good Development, brought to you by Sonatype. Our show was produced by me, Kadi Grigg. If you value our open source and cybersecurity content, please share it with your friends and give us a review on Apple Podcasts or Spotify. Check out our transcripts on Sonatype's blog and reach out to us directly with any questions at wickedgooddev@sonotype.com. See you next time.

Tags: Community, podcast, DevZone, Wicked Good Development

Written by Kadi Grigg

Kadi is passionate about the DevOps / DevSecOps community since her days of working with COBOL development and Mainframe solutions. At Sonatype, she collaborates with developers and security researchers and hosts Wicked Good Development, a podcast about the future of open source. When she's not working with the developer community, she loves running, traveling, and playing with her dog Milo.