 Hey everybody, I'm Anil Dash from Glitch and as some of you might know, Glitch is a tool that lets anybody easily create a full stack web app right in their browser and hopefully have fun doing it. It's also a community where people code together, collaborate together, share the apps and the projects they've created and it's really been something special over the last couple of years to watch it grow. But what I wanted to do is share some of the lessons we learned that are applicable way beyond any one product or any one company. And interestingly, there are sort of two key lessons that are particularly relevant to the OpenJS community. One of the first insights we had was what seemed like a small idea at first, that we don't code alone. And, you know, we started at sort of a superficial level thinking about the fact that you could edit code together and that was where that idea really started. But the more we talked about it, the more we thought about it, the deeper that idea seeped. I'm going to come back to that. One of the other early choices we made was that while any programming language or any toolkit can work on Glitch, we were going to focus. We were going to make a choice, a decision about what community we wanted to be part of and the choice we made was to support JavaScript. Now, obviously, that's not that radical a choice to make these days. But you go back a couple years ago and it wasn't as obvious, because the truth is what we've seen the trajectory of JavaScript over the last several years is extraordinary. These days, the majority of developers who work in the world have JavaScript as part of their toolkit. Now, it might be for build scripts, it might be something that's helping out as they use another programming language, but it's there. And that's radical because there's no point in history before now where there's been a programming language that most developers use. It's really extraordinary and it's gone kind of unremarked that this milestone happened. But it speaks to the power of what JavaScript is. And the truth is that's a question worth asking. What is JavaScript? Because it's not just a language and it's not even just a family of languages. I mean, these days we see TypeScript is so ascendant, the tools are so good, and I'm old school enough, I remember back when we had JScript, an action script. Does anybody still remember JScript? I mean, there's been a family of languages and tools for a long time. So what's different? Well, a lot of times the reflex when we talk about what's different is to go to thinking about the language itself. Maybe it's the way it uses curly brackets and semicolons. Maybe it's something to do with inheritance. And the truth is those things matter. Those things matter as a programming language becomes more popular. But a lot of those things were in place when it started 25 years ago. And yet there's been a renaissance over the last decade, let's call it the last 10 to 12 years, where JavaScript has just been ascendant and is actually accelerating in its importance in the ecosystem. And so when we start to ask the question of why, especially in the case of a company like ours, a team like ours that's making a bet on JavaScript as the foundation of what we do, we need to understand why it has become so central to the way that all of us work. And what we realized is JavaScript has become a network, maybe even a network of networks. And that's not an obvious statement to make. We can talk about it as a language. We can talk about it as a runtime. We can talk about it as a lot of different things. But talking about JavaScript as a network is a little bit, well, controversial to some people. So I want to explain why I say that. In what ways is JavaScript a network? What does that even mean? Well, take a look at the period in which JavaScript has taken off over the last decade and see what other tools and technologies and platforms have been ascended at the same time. Let's look at sharing answers with each other on Stack Overflow. Let's look at sharing code on GitHub and the other places that we store our code. And let's look at the ability to reuse each other's work easily with NPM. And there are many, many other tools that could fall into these categories, but these are the ones that are sort of anchors to this experience. And what you find is there are networks effects building around coding in JavaScript that are unlike anything we've seen before and really unlike anything in any other language. Because while obviously there are tons of different languages used on GitHub and tons of different languages that get questions answered on Stack Overflow, we're not seeing that same network effect take place as we're seeing in JavaScript groups becoming the glue that binds really almost the whole programming world together. In fact, if we want to understand these behaviors and the shape of the activity around JavaScript, it starts to look more like almost a social network. It looks like the apps we use to keep in touch with our friends or that we use to share photos. It doesn't follow the typical pattern of a programming language, especially because most languages of a certain age start to crescendo and then decrease in popularity. They become irrelevant, but that's not the case here. So now when we start to think of maybe there is a social network that is formed around JavaScript, the question arises of whose network is it? Who is it designed for? Who had the idea to create these things and who's welcome on that network? And these questions are important because we've had those same questions arise on conventional social networks, right? We think of, well, a lot of times the flaws. In my case, I think of, say, Instagram having filters for many years that didn't work for my skin tone or a lot of other people's skin tones. Or I think of Twitter and how long it took for them to address issues of abuse or harassment on the platform. Or platforms like Facebook or WhatsApp or YouTube and how much they've struggled with misinformation that has led to real harm in the world. Social networks can have a lot of unexpected side effects. And if the programming languages that we're using are becoming part of a sort of equivalent to a social network, well, then we have to understand who that network was designed for and who it serves. Just as importantly, we have to think about the ideas that underpin the creation of these networks because there are a lot of assumptions that go into creating any technology. Sometimes there are common set of values. Sometimes there are common set of delusions. And in either case, it's really, really important to understand what those assumptions are so that we know what it is we're actually building together. I think the values often get expressed as stories. And so we can ask the question of what stories do we tell? And I grew up in a time when even before open source had become as popular as it would become or as much the default in how we collaborate together. And there were narratives that were told then. One of the phrases that kept coming up all the time that open source was valuable because many eyes make all bugs shallow. And then a lot later, people talked about how software is becoming more influential in the world. And we started to hear that phrase, software is eating the world. There are lots of other sort of pithy phrases like these. But I picked these out as two of the most common that you tend to hear, especially at conferences like this one. But also just in the general discussion about how software, technology, the tools that we use and the tools that we make are impacting the world around us. One of the biggest questions is, are the goals of the people that share these stories the same as the goals that we have? I'm not so sure. Because when we think about a network being created and we think about what the negative and positive implications could be, we have to really, really interrogate that question because there's a non-obvious truth here, which is that networks have power. And power exists in a context. And that power can be conveyed to the people who are on the network or can be denied to the people who are excluded from that network. There's a lot of these dynamics that I think actually are really obvious to us when we think about social networks but are not obvious to us when we think about programming language networks. Give me a small example. I've had this experience a number of times, probably all of you have had this if you've been coding for more than a few years, where I picked a toolkit, a framework that I really like and I made it part of my standard dev setup and that was how I'd start up new projects. And at first it was awesome because I got really good at it and I felt like I could just whip up an app really quickly that would solve my needs or that would feel like it was really productive and rewarding to me. And then after a while I noticed that I would get sort of teasing jokes from other people and they were kind of kidding, kind of not. Or people started saying, oh, you're still using that framework because there's like the new hotness and I don't know why you haven't moved on to it. And it started to feel like being, frankly, out of fashion. It's a little weird way to think about a programming framework but it was definitely that sense that the network was moving on without me. And it manifested in a lot of different ways. We start to see fewer updates on that toolkit from the creators, whether they're the core committers or the company that owns it. That framework starts to become something that decays over time. That framework starts to become something where the documentation comes a little bit out of date. And that's just a minor example. That was just something where I felt honestly a little bit coerced into I better move on to a new framework. This thing is, well, not the thing I should use anymore, even though it still solves the problem that I wanted it to solve. But there are a lot deeper problems that can come from the network having this impact on us, especially if you think about the idea of software eating the world. Because the network impacts people who are not coders and not programmers. You know, the truth is the world of non-coders has started to think of us as authorities on domains that we don't necessarily know anything about. But you think about data. We know it is something that is dirty and often inaccurate and often has the same bugs as the software that created it. We know it's imperfect. But outside of the world of coders, people treat data as if it were authoritative and correct. They treat it like it's the truth. We would never assume the data we get are the truth. And so that's a lesson that's often not obvious to people who don't code. And that keeps repeating in more and more serious ways. The network of programmers in the world is having impact on spaces that we didn't even know we would impact. One of the ones that jumps out to me most clearly, it's going back a few years ago, several years ago now, when I first started hearing about the increased attention to police violence here in the United States. And a lot of the solutions that were proposed going back years and years now involve technology. They involve things like body cameras for the police. And the idea was that, well, to use the programmers' phrase, many eyes make bugs shallow. The idea was that lots of people seeing and witnessing police violence happening would cause it to stop happening. And truthfully, until four or five years ago, I believed that too, because it had been framed in the rhetoric of the software industry, the technology that was eating the world. I bought into it. I believed, well, you know, this might fix these problems. This might fix these bugs in society. And the truth is, as we've painfully seen, it doesn't. There were some incorrect assumptions here. Using the logic of software in a world that has nothing to do with software doesn't work. Using a technological solution to a problem that is cultural and social doesn't work. And I didn't catch it. I didn't want to see it. I wanted to believe that our technologies would help. And there was a deeper lesson here, which is that violence wasn't seen as a bug by the systems it was being reported to. The videos could show up and they wouldn't fix the problem. Technology was not the answer. And so there are limits to these networks. There are limits to how technological approaches can fix the problems we have in society. Think of it from a technology standpoint, you can't fix the lower levels of the stack beneath the tools that you're using. You know, reporting a bug is meaningless if the institution you're reporting it to doesn't consider it a problem and won't fix it. That's a lesson that was painful for me to learn but not obviously nearly as painful as the impact that it's had on society because politicians believed it, elected officials believed it, many people believed that if we would just apply technology to a social problem, it would work, but it's not enough. Now that's not to say that networks don't give us power, they do, but only in certain ways. The network of technology that we create can move power around within people in that network but it can't bring new people in, right? And it also can't challenge us to interrogate what are the assumptions that network was built around. Because as painful as that example was, there's also a lot of power, there's honestly a lot of hope that I see. Because we joke about the size of our node modules directory, right? And how it's so easy to just pull down gigabytes of code that we don't even know what they're doing. But the truth of it is we can instantly, almost automatically reuse the work of thousands of other coders around the world, millions of lines of code. It's almost automatic to be able to not just stand on the shoulders of giants, but take advantage of the brain power and the generosity of programmers around the world. And I think about the way we share code and share answers with each other and it's almost like we take it for granted, but this is an extraordinary act of kindness that coders extend to one another. It's actually the most positive and optimistic sense of the work that we could do is to say, I hope a stranger might find this valuable someday and that it lightens their load, it makes them more able to create the things they wanna create. I mean, that is honestly, well, that's the promise of technology, right? And so there are two sides to this. There is this great optimistic and altruistic sense of how we share our great technologies with one another, but there's also that reality we all know where even aside from the profound social ills, we know every open source library we use might have bugs in it. We've all seen times when a bug goes unfixed for years and years, nobody looked at that code. You know, the theory might be many eyes make bugs shallow, but a lot of times many eyes are looking at something else. We keep assuming somebody else is gonna fix that bug. And a lot of times somebody else thinks we're going to. And that is what we have to really challenge ourselves on because we have also seen the positive potential. All of us have had that moment where a bug gets fixed for us almost for free, right? We do an update of our dependencies and all of a sudden that thing that we had been struggling with is fixed almost magically, we're able to extend that to each other to the people that are already in the network. And it does feel like magic. I mean, I think about even just from a language standpoint, the fact that we talk about dependencies, we depend on one another to help each other out to solve our problems, to fix our bugs, but we only extend that to the small number of people who are able to clear the hurdles to be part of a community like this one. So I've tried to challenge myself a little bit about whose choices I am accepting unquestioningly. You know, the truth is every day I use tools made by organizations that I don't agree with. Every day I use software and code made by companies that I would like to not support. And I feel the other side of that very acutely too. You know, I work at a company where at Glitch we do hope you use our tools, but I know that people need to make their own judgments about do I feel good about using these tools? Do I feel like I'm supporting something I can believe in? And so we've pushed ourselves to think about, can we have a business model that doesn't involve surveillance-based business models? We're not doing creepy things with people's data. We're not reselling their information to somebody else. But it's hard because we also have to compete against companies that do do those things. And so we end up with imperfect answers. I am not preaching about, we do the one right thing by any means. I'm not pointing any fingers at anybody that I wouldn't point at myself. I just think that we have to push each other to work a little bit harder and think a little bit harder about who is making the choices around the technologies that we use, who we're supporting when we use them, and who we're excluding when we strengthen our networks and give power to our networks, but don't think about who's excluded from those networks. What I'm hoping is that we can challenge each other and that we can see our acts of creation and collaboration and coding and take pride rightfully in the fact that there is such a generous spirit. You know, I see it every time I go to any event with coders. There is just this genuine sense of camaraderie and a willingness to share knowledge, to share insights. But a lot of times we don't push hard enough around thinking about how others take the code we make the ideas we share, apply them to problems that may not be appropriate for, apply them to situations that we didn't anticipate and cause real harm. And so we need to lift that importance of those ideas. We need to challenge each other about our responsibility to one another. And I think most importantly, we need to remember that we don't code alone. We are always coding in collaboration with thousands or millions of people around the world. And we are also always creating in an environment there are billions more who don't have a say. We have to be mindful of the fact that we are part of a network, a community that has a tremendous amount of power. And we have to be responsible in the ways that we wield that power. I'm gonna challenge myself to try and do better in those regards. And I'm gonna ask all of you to do the same. And I hope we'll each hold each other accountable as we do. And I hope that we'll deliver on the promise that we all had the first time we ever wrote a line of code that we thought we could make something useful. We thought we could solve real problems. We thought we can maybe even make the world a little bit better. And I think if we hold each other accountable that's exactly what we'll do. Thank you all for your time.