TLDR: We’ve renamed Fog Creek to Glitch, Inc. to represent our single-minded focus on Glitch. We’re hiring for a bunch of new positions (with more to come!) and welcoming a slate of new advisors. And it’s all in service of making Glitch one of the most important creative communities on the Internet, and having our company set the standard for thoughtful, ethical technology.

Back in 2000, two visionary founders, Joel Spolsky and Michael Pryor, envisioned a new tech company that would distinguish itself by the way it treated people — both its employees and its customers. Their belief was that being better to people would yield more invention, more innovation, and a much more pleasant place to work.

Well, they were right. The company they created, Fog Creek Software, has gone on to create multiple groundbreaking products and to help change the entire tech industry along the way.

From inventing Trello to co-creating Stack Overflow to pioneering bug tracking with FogBugz and launching other successful and influential products like Manuscript and Kiln and Copilot and CityDesk and many other experiments. Fog Creek has been a bastion of innovation for nearly two decades.

And today, we’re turning the page on that chapter for something new.

Becoming Glitch

When we started working on the project that would become Glitch, it was originally just part of our regular “Creek Week” process — the internal hackathons where members on our team come up with new ideas and try to inspire each other with cool projects. It became obvious pretty quickly that Glitch was something special.

Then earlier this year, when Glitch came out of beta, we saw an incredible groundswell. As a creative community, Glitch inspired people to create over a million apps in record time — including cutting-edge work in VR, machine learning, distributed apps, bots, and more. And Glitch has won the hearts of developers around the world who now feel that coding with other tools feels a lot more lonely and less productive. Just as importantly, Glitch has reminded an entire community that a healthy, independent, open web generates enormous value for everyone on the Internet, earning the attention and respect of many of the biggest players on the web.

One of the guiding principles for Glitch is that we should communicate with clarity, and that our purpose and goals should be self-evident in all we do. And that’s led us to recognize it’s time for us to become Glitch. It’s not just what we’re building, it’s who we are as a company. While the core values of Fog Creek still persist, we’ve also learned a lot and evolved a lot over the last two decades, and now our name and identity are evolving, too.

What’s Changing, What’s Not

In terms of Glitch as a community and as a product, nothing’s changing. We’re doubling down on being a friendly and welcoming community, and focusing our efforts and investment on extending our lead in innovative features that creators and developers love.

We’re holding tight to our values, honoring our core principles of valuing people — whether that’s our community members or the workers on our team. And we’re expanding our history of transparency and accountability, with meaningful efforts like publishing our entire employee handbook publicly. (It’s a Glitch app, naturally.) This lets us show the world how we put our values into practice. We also want to do more: Glitch, Inc. is designed to be a company that sets the bar on best practices for how we treat our community, customers, coworkers and collaborators.

There’s lots of news coming for Glitch as a product, too. We’re getting ready to open up Glitch Teams, to make it easy for your whole organization to collaborate on Glitch. (Tell your boss you want your team to be one of the first to use this new super-productive set of tools!) We’ll be building a powerful and valuable set of paid features on top of Teams to give even more options for organizations that want to get more out of Glitch, and to build a long-term sustainable business model for the platform and the company.

And we’re ecstatic to welcome a formidable slate of new advisors to help us grow Glitch, and expand our vision, and ensure that we practice the values we aspire to exemplify. Kimberly Bryant, Alan Cooper, Jason Goldman, and Franklin Leonard have a broad set of backgrounds covering everything from education to policy, user experience to filmmaking, social networks to social justice. And each of them brings unique expertise and insight into how we’re going to bring Glitch to millions more people around the world. We’re so thankful to them for joining us!

Join Us

That brings us to perhaps our most important announcement today: We want you to join us. Whether that’s as a member of the Glitch community, or by checking out the new job listings we’ve rolled out today (with more to come soon), we want you to be part of where Glitch is going.

Glitch is a very different kind of tech company, explicitly committed to setting the standard on thoughtful and ethical practices, and with an unparalleled track record of nonstop innovation for almost two decades. If that combination is appealing to you, take a look at the positions we’ve listed, and share the job openings with your friends who share those values.

Fog Creek is now Glitch! was originally published in Glitch: Make Better Software on Medium, where people are continuing the conversation by highlighting and responding to this story.

First, the fundamentals: For current Manuscript customers, nothing is changing today — neither functionality nor licensing. And good things are changing in the future. We see lots of good progress coming, like long-overdue platform improvements, modernization of infrastructure behind Manuscript, and a re-engagement with the community to revitalize one of the most venerable and respected tools for creating great software.

Manuscript has been part of Fog Creek’s DNA for nearly two decades. First as FogBugz, which pioneered the market for bug tracking and project management, and then later with the addition of Kiln, which was groundbreaking in its innovations around version control. Then, with last year’s launch of Manuscript on top of that FogBugz engine, came the expansion of the ambitions of the platform to provide all the core tools needed to make great software.

But honestly, we’ve been resource-constrained as a small company to do justice to Manuscript, especially as Glitch has taken off and demanded our attention, and the market for software project management tools has gotten more competitive. So recently, we started looking at whether we could find a new home for Manuscript that would provide it with the investment and focus needed to not just support the current users and functionality of the platform, but to expand both.

Today, we’re letting the world know that we think we’ve found that path forward, with the team at DevFactory. The same team that’s been developing and supporting Manuscript at Fog Creek has overseen a transition to DevFactory’s processes and infrastructure for weeks, ensuring that this transition is seamless for users.

We’re proud of the nearly 20-year history that starts with FogBugz, leads to Manuscript, and has brought us to this new chapter. We’re thankful to all the people who’ve used these tools over the years. And I want to thank in particular the many team members, past and present, who’ve helped create a platform that’s enabled so many people to do their best work.

Here’s to the next chapter in Manuscript’s evolution, and to the continued success of the innovative community who’ll continue to build inspiring work with the help of the platform.

Moving Forward with Manuscript was originally published in Glitch: Make Better Software on Medium, where people are continuing the conversation by highlighting and responding to this story.

We’re excited to reach the one million app milestone as it shows how we’ve created the easiest way for coders to create and collaborate online. With functionality like real-time collaborative editing, instant deployment, automatic secure hosting and Rewind, we’ve removed many of the technical barriers to getting started with building on the web. By turning “developer tools” into a set of creative and expressive tools, we’ve enabled people of any skill level to be able to create online.

So it makes sense that the millionth Glitch app was created by someone who’s learning to code. freeCodeCamp is a community that helps you learn to code and get experience by contributing to open source projects used by nonprofits. And it was a freeCodeCamp student learning Node.js used Glitch who created the project that marked the million-app milestone. freeCodeCamp was an early adopter of Glitch and their community members use it extensively to learn back-end development, testing, and security. Their approach is hands-on — through coding challenges and building projects, you learn to code, which is exactly the type of thing we wanted to help make more accessible when we set out building Glitch.

“Campers build their APIs on Glitch and then our platform hits their Glitch project endpoints and run tests against them.

We love Glitch because it abstracts away so much of the ambiguity of Linux and Git, and helps you focus on the coding itself.”

Quincy Larson, Founder and Teacher at freeCodeCamp

And best of all, those beginning coders like knowing that when they use Glitch, they’re using a tool that even some of the most experienced professional developers also use for their work.

Bringing Back the Creative Web

But Glitch is about more than apps. It’s helping people create the best of the web by enabling creativity like no tool has done before. Or, at least not since GeoCities. But most people on the web today weren’t around for the heyday of GeoCities, or NeoPets, or MySpace, or any of the other places where an earlier generation of creators got their start dabbling with code. They’ve never known a truly creative web, having grown up on an internet dominated by major social networks.

So we’re bringing that creative, personal, human web back.

With this milestone, we’re showing how a creative community can change the way the web is made to be more open and inclusive, and can come together to invent the cutting edge of the web. Glitch is a place where you’ll find cool apps, websites, and creations that you simply can’t find anywhere else. Think of this community’s future as being like YouTube, but for apps, bots, web art and VR instead of just videos.

We’ve been working hard to make it a welcoming community, whether you’re an experienced professional developer or you’re just getting started. A community where everybody feels comfortable expressing themselves and sharing their creations with the world. And in doing so we’re reminding some, and introducing others, to a fun, creative web that any of us can build. And it’s working. The result is: we’re growing fast!

We love Glitch and we want to do this thing right. We think that means remaining fiercely independent and opinionated. Now, we’re not some flighty startup — Glitch is bootstrapped by Fog Creek Software, the inventors of Trello and co-creators of Stack Overflow. We’re not building Glitch just so we can sell it to some big company in a year and let the community fall apart.

But running Glitch this way brings up an important issue: sustainability. How does a tiny little team support a huge community that’s going to change the web? Well, we’re going to need your help to get the word out about Glitch. We’re committed to making this a sustainable business for the long term. And we’ll be doing this in a few ways, but the first is with Glitch Teams.

Use Glitch at Work with Glitch Teams

From development and DevRel, to marketing and learning, we know many of you love Glitch too and want to use it at work. So we’re building our roadmap around the tools that help you adopt Glitch within your organization. We’re doing this based on feedback direct from the community, and it will include the things you’ve been asking for, such as:

• Team Member Authentication: Flexible, integrated authentication with providers that your team already uses to track and manage team members
• Flexible Project Permissions: Control over who can access or update different projects and pages
• Team Pages: Enabling discovery, remixing and reuse of private apps within teams
• Notifications: Get notified about key events as they happen on Glitch

But we’re keen to know what else your team would find valuable enough to pay for. Find out more about Glitch Teams and share your ideas with us!

Then please get back to building one of the next million apps on Glitch. We can’t wait to see what you create! 🎏🎆

We’ll be hosting a special event soon with the Glitch team, where you can ask us anything about the community, Glitch Teams and the future of Glitch itself.

Sign up and be first to hear details about this live event.

1 Million Apps on Glitch: The Creative Web is Back! was originally published in Glitch on Medium, where people are continuing the conversation by highlighting and responding to this story.

The tech world has had a little time to digest the dramatic news that Microsoft is acquiring GitHub, and is starting to form its opinions. Amidst the flurry of hot takes, most of the immediate responses focused on the obvious business value for Microsoft: boosting its connection to developers and helping its Azure cloud platform to compete with Amazon.

But as we’ve been creating Glitch, we’ve learned a lot about what happens when coders collaborate together in realtime, and this reveals a deeper insight into where coding is headed. It’s something far bigger than just hoping to encourage developers to use one cloud services provider instead of another.

A network of coders isn’t just useful as a way of collaborating on programming, but is perhaps even more important as insight into social behavior, and as a foundation for machine learning about the way coders work.

Cracking the Code

Right now on Glitch, millions of users have created, remixed and discover projects, and we’ve listened closely as they told us how we can make those community members more productive. As a result, we’ve begun exploring the power of networked coding. “What if JavaScript wins?” described the ecosystem around coding is increasingly driven by network effects, so there’s an opportunity in building tools and infrastructure which recognize that reality and take advantage of this new environment.

In short, the people who make software got networked just like their computers had been in the preceding decades.

— What if JavaScript Wins?

What’s Possible Now

Smart analysts like Ben Thompson have laid out why Microsoft would pay a premium for GitHub by describing the cost of acquiring developers for a platform. Microsoft’s own deck describing the deal emphasizes “the developer’s marketplace,” hinting at a sort of app store for coders, which could indeed be useful.

But the far greater value comes from radically increasing the number of people who can create software, while improving the quality of software that they make. That’s not incremental improvement in coding productivity, it’s an order of magnitude increase in who can create technology — a win for inclusion, innovation and invention as much as it is for productivity.

Imagine a few scenarios that networked coding makes possible:

• Analyze code that’s already been written, to understand which functions, methods and libraries are used most often. Then, use that data to build better support for these capabilities, or create new web services or infrastructure that can solve these problems more efficiently. (This is the potential that’s furthest along today.)
• Monitor new code as commits are made, seeing trending behaviors in design patterns, and gathering insight into repeated efforts that might be redundant, wasteful, or frustrating. You could even capture errors as they happen or provide examples of how others have solved similar problems.
• Identify the social relationships between collaborators, and the invisible network of connections between contributors to a project, to understand which people collaborate well together — or which people could collaborate together. On Glitch, the ability to just raise your hand to get help is already building relationships between coders, whether they’re on the same team or complete strangers, around the way they can collaborate together.
• And finally, and perhaps most excitingly, networked code provides a broad set of training data for machine learning about code that’s written in the real world. In the short term, this can provide better tools which anticipate the most common choices that coders make, but in the long term, we can identify likely mistakes or unexpected errors that make software less reliable, less maintainable, less secure, or more expensive.

Some parts of this are theoretically possible with GitHub today, and some rudimentary versions of these capabilities are starting to show up in tools from Microsoft and others, including Glitch. But most tools that try to solve these problems are resorting to brute-force indexing of code or commits after a person has already created their work.

Reaching the full potential of networked coding can’t just happen by trying to analyze “dead” code that’s locked away in old repositories. Instead, networked code requires being connected to creators while they’re coding, responding and even anticipating the work that they’re doing. (And no, not like Clippy — more like the way we share photos of an event with faraway friends so they’ll feel like they’re in the moment with us, together.)

A Place For Friends

When we started preparing to launch Glitch’s earliest versions, one of our internal goals was, “writing code anywhere else should feel lonely in comparison”. Though it’s still very early, we think we’re well on our way toward achieving that mission.

But in reflecting on that goal, we realized it connected with a lot of the values that we think are important for coding overall , like unlocking the creativity of more people, including those who don’t even think of themselves as coders. Or freeing up creativity by giving people room to experiment or even to make mistakes while still being supported by a community. And tapping into the latest advances in artificial intelligence to give people more confidence that the code they write is secure, stable, scalable, reliable, and legible.

By all means, we should get excited about the potential for new cloud services. And it’s great if more companies are competing harder to earn the attention of today’s developers. But given the central importance of code in shaping the future of culture and society, one of the most important things we can do to set a standard for code going forward, is to make sure it’s more connected.

It’s not just about code connecting to our devices and to our data, but code being a medium through which we form connections to one another. We can’t wait to see what you create!

It’s Not Just Code, It’s a Network was originally published in Glitch on Medium, where people are continuing the conversation by highlighting and responding to this story.

GitHub + Microsoft = Good 👍

Let’s put it short and sweet: Microsoft buying GitHub is likely to be good news for developers. There’s no better evidence of how Microsoft has been revitalized under the leadership of Satya Nadella than to point to bold moves like this, which would have seemed incredible (and also not seemed credible!) in the past. Old-timers can remember when Microsoft was often described as the Evil Empire, but their moves to embrace open source and non-Windows platforms have seemed sincere and sustained, and we’re happy to see that flourish.

Similarly, GitHub has earned its place as an indispensable developer platform through breaking ground as the first large-scale social coding experience over 10 years ago. Having strong leadership from Microsoft can only be good news, especially for developers using Microsoft platforms.

But if we have a concern, it’s that there hasn’t been a huge leap forward in social coding in the last decade. We simply haven’t seen enough innovation in recent years in the way that coders collaborate, and since every developer will be thinking about these big ideas right now, we wanted to paint a picture of what social coding could look like over the next decade. A lot of people will (understandably) be thinking about backing up their GitHub projects just in case, and we think you should use that opportunity to look at Glitch and consider if it’s time to rethink traditional views on version control entirely.

(Spoilers: If you’re using Glitch, you’ve already got a preview of where we’re headed. If you’re not, here’s how to import a GitHub repo to Glitch. If you have a Node app that you’ve built or like to use, start with that!)

A Decade of Building Better Version Control ⏪

First, some background. Many developers may not know this, but at Fog Creek, we have a deep background in distributed version control systems. We launched Kiln (now available as an integrated version control system in Manuscript) almost a decade ago with a number of groundbreaking features for teams to collaborate on coding. Our path was to take great project management and add version control to it, and this approach taught us a lot about how people can do their best coding together.

We learned exactly what parts of the typical commit-pull request-merge workflow were still far too difficult and complex to understand.

Based on what we had learned, and what we heard from the developer community, we started rethinking some of the assumptions about workflow and collaboration that everyone was taking for granted in version control. Then, earlier this year, we brought Glitch out of beta with a complete re-imagining of version control, and we called it Glitch Rewind. It uses regular git under the hood, but the user experience is a huge leap forward.

Glitch Rewind & Reinventing Social Coding 💡

Glitch does a few things nobody’s pulled off before:

• Glitch automatically commits your changes while you work to a git repo in the background — even with multiple simultaneous people editing the same file at the same time. Imagine if the basic commit process was as easy, and as multi-player, as editing in Google Docs. Even non-devs can do it instantly.
• Glitch Rewind lets you roll back commits on a project just by moving back a slider like you’re rewinding a video. If you want to work from that older version, just hit play and keep working. You’ll get a live preview of your changes as you slide around the timeline. Anybody who can play a YouTube video can revert git commits now. Even if you do know the arcane git command line options, you’ll prefer working this way most of the time.
• Under the hood, it’s all just git. This means your tools, processes, workflows, integrations and automations can move seamlessly over to projects on Glitch.
• We’re building on Glitch’s “remix” feature that lets you clone live, running, code and will make merging changes from remixes as easy as rewinding commits is today.
• Glitch’s project pages and user profiles are an open source project maintained on Glitch itself. That means if you want the community features and social networking features on Glitch to evolve, you can make it happen yourself, and become part of a vibrant new community when you do so.
• The business tools you use to collaborate on code should be a seamlessly connected part of the larger network where everyone codes together. Glitch for Teams is bringing all the power of Glitch’s collaboration to your work, but without the complexity of having to go through an enterprise procurement process.
• Glitch is also trying to be a better, more inclusive community with everything from a friendly and approachable design, to built-in tools for managing codes of conduct and licensing, to our unique Glitch Help feature — if you get stuck coding on Glitch, you can just raise your hand to ask for help!

We’ve got more coming, but you have to see it in action to really understand the magic.

What about other tools? 🤔

The skeptics among you must be thinking, “Well, that’s all fine, but we’ve got GitLab or BitBucket as alternatives now, why not just use those?” And those are great tools! But they make the same fundamental assumptions about workflow that all the older generation of tools — including our own — had settled upon.

We now think those assumptions didn’t try hard enough. This is where we want to raise the bar:

• The basic building block of social coding should be an app, not a commit. The default state of a project should be a functional, running app or site or bot, not a pile of code that you then have to figure out how to get running. (“Start from something that works.”)
• Creativity is enabled when everyone can make changes to code and try new things out without fear, thanks to automatically being able to undo any change.
• Every member of your team should be able to commit to a project, even if they’ve never coded before, don’t know what git is, or haven’t even heard of git.
• Even experienced developers shouldn’t have to memorize obscure command line tools for common tasks like reverting a commit. Very, very few developers feel confident about their expertise in git, yet nearly all have to make use of it. This mismatch helps make coding more stressful, less inclusive, and less fun.
• The social network where we show off our code should be as delightful and creative as networks where we find great photos or videos or music.
• The community platform that coders use to share their work should be open source, so that we can all improve it together. The business model behind a coding community should be transparent and sustainable, so we can trust it. And the company behind a coding community should be credible, with a track record of being accountable.

There’s a lot more — in fact, we wrote a whole list of the principles behind Glitch if you want to check it out. But the bottom line is simple: GitHub has radically changed coding in the last 10 years, and we should all celebrate this milestone for Microsoft and for the community. It’s a validation of an important idea: We don’t code alone.

This is also the perfect time to ask ourselves as coders and as creators, how we can set our sights far higher than merely being social while we code, and truly bring community and culture into the heart of how we create together.

That’s what Glitch is all about. We can’t wait to see what you create!

GitHub, Glitch and the Future of Social Coding was originally published in Glitch on Medium, where people are continuing the conversation by highlighting and responding to this story.

Around a decade ago, a big part of coding culture changed.

What had often been a solitary pursuit, or one where collaboration happened with a defined set of colleagues within a company or open source project, burst open into a much more intrinsically social experience. Everything from how we share code to how we find answers to how we discover new technologies became far more linked to the attitudes and actions of other programmers.

In short, the people who make software got networked just like their computers had been in the preceding decades.

The Networks

The impact of network effects on coding culture has manifested itself in many ways, but some of the most visible are worth examining:

• For knowledge about coding issues, and answers to common questions, Stack Overflow rose and quickly became a dominant source of reliable information about programming. (Requisite disclaimer: I’m on the board of Stack Overflow, though my experience here is based on being a coder who just relies on it for useful answers.) Though the barriers to participation in the Stack Overflow community are well-known, there’s no doubt that its enabling of a network of knowledge around coding answers amplified the discoverability of programming information, and accelerated the idea of social signal being a strong component of technology adoption. A framework or toolkit that has its own, actively answered tag on Stack Overflow is much more likely to get new adopters.
• A similar pattern followed for collaborating around code: GitHub rose a decade ago as a powerful platform for sharing each commit to a project. Though its value was presented as being about popularizing the then-nascent distributed version control tool Git, the social value of GitHub has extended to being a signal of the value or reliability of software hosted on the platform. Counting the number of stars or forks or watchers on a project acts as a proxy for how much the code can be trusted. GitHub has real barriers, like the difficulty of learning git or the obtuseness of organizing around changes to a project, rather than the project itself, and all of these factors can make it difficult for some users to participate in the network. But despite those barriers, social signals on GitHub deeply shape the adoption of tools and technologies by developers.
• Finally, there are the networked information sources for news and discussion, primary among them being Hacker News. Though it’s notoriously the most hostile of these large, networked coder communities, it inarguably helps promote and elevate new technologies and new ideas around how to create software. Hacker News’ amplification of tools often helps them reach critical mass in adoption, and discussion of a product is another form of social signal that many in the coding world use to judge a particular platform. To a lesser degree, more product-focused communities like Product Hunt also fulfill some of this function. (And Product Hunt does this while being far more welcoming.)

In each of these cases, if we look past the flaws of the communities that enable them, we see a deeper pattern: software being evaluated based on its social success and social merits, rather than just some ostensibly “objective” technical merit.

Technology has always existed in a social context, and evaluations of the risk or reliability of a tech platform have always relied on social indicators. But the acceleration of these patterns, and the extending of the social networks around code to include the majority of working coders, means that institutional indicators (like “which company funds its development?”) now come second to community-based signals.

Similarly, top-down indications of technical maturity like documentation (often an artifact of outside investment in making a technology accessible to a new audience) are complemented, or even eclipsed, by bottoms-up indicators like how many people have bookmarked a framework, or how many people answer comments about a toolkit. Even purely social factors like the number of participants in a Gitter or Slack chat room about a project, or the number of people who follow a project on social media, are all weighed when we look at new technology.

Then There’s The Law

Though nearly everything he shares on social media these days makes me want to smash my head into my desk, longtime software blogger Jeff Atwood has had a number of valuable insights over the years. Perhaps none was more prescient than the insight captured in his eponymous law:

[A]ny application that can be written in JavaScript, will eventually be written in JavaScript.

Jeff’s inspiration lay in the insightful “principle of least power” as articulated by Tim Berners-Lee, father of the web. But especially back when Jeff wrote that blog post, JavaScript was still considered something of a toy (for example, Node.js wouldn’t be invented for another 2 years), and the idea of everything being ported to the language seemed a bit absurd. Naturally, the internet being the internet, almost a dozen years later, there’s an entire community dedicated to documenting things being ported to, or rewritten in, JavaScript.

But Atwood’s law speaks to the ability to re-implement nearly any other code in JavaScript. Given that any Turing-complete language should be able to implement functionality written in other languages, that makes this observation amusing, but not particularly revelatory about what kinds of behaviors might emerge as a result. Atwood’s law says nothing about adoption of JavaScript, just its potential to express ideas implemented in other languages.

But What If JavaScript Is A Network?

There are a lot of things that are considered “JavaScript” these days. There’s the open language described in the ECMAscript standard. There are adjacent languages like TypeScript that offer niceties to coders in exchange for compatibility with the JavaScript ecosystem. There are environments like Node. There’s the power of instant access to years of coding effort through package management tools like npm. There is a nearly-infinite amount of infrastructure around the language, and even more infrastructure using the language to provide build tools or automation for other languages. And then there’s the ubiquity of JavaScript being interpreted within the web browsers on billions of devices around the world.

This breadth of contexts accounts for the popularity and dominance of JavaScript. Indeed, the most recent Stack Overflow survey of developers lists nearly 70% of them claiming JavaScript as one of the languages they use. (As above, some of the obstacles for participation in the Stack Overflow community can skew this kind of survey, so we should be mindful of those distortive effects, but the overall trend here is clear even if we account for those concerns.) And the percentage of coders using JavaScript keeps increasing, increasing by about 15% in just the last few years, even as other languages like Python keep growing as well.

What this suggests is that JavaScript may be reaching escape velocity as a network, and as an ecosystem of related technologies. To be clear, there’s no winner-takes-all here — domain-specific languages will always have their uniquely valuable areas of focus. But for general-purpose coding? Everything from spreadsheet macros to Internet of Things hardware seems to default to having JavaScript be one of the primary ways to make things programmable.

It’s impossible to say if this idea of evaluating a programming language as a social network is a valid way to judge the technology. But every indication is that the feedback loop around the JavaScript ecosystem is increasing in strength. Though most “serious” developer tools are insistently polyglot (and indeed, every indication is that most working coders do make use of more than one language in their work), it may make sense for forward-looking platforms to disproportionately invest in JavaScript for their futures.

Glitch ❤ JavaScript

Of course, I work on Glitch all day long, so you know our team has got an opinion on this. Don’t worry: Glitch can run code in almost any common language. We’ve got Python and PHP and Ruby projects happily running in the community.

But we’ve chosen JavaScript (and Node) as our primary platform for Glitch, the one we feature in our work. There are lots of reasons for this (I mean, have you seen the full-stack debugging that Glitch lets you do?!) but one of them is that we’re a small team and we want to make sure we’re betting on the technology that will provide the most value for our community. And we think our investment in the JavaScript ecosystem will only become more valuable over time.

We also look at the network value of apps, libraries, modules, and code snippets that live in the Glitch ecosystem, and we think focusing our attention will yield dividends as we start to build more tooling for coders and apply newer developments in machine learning to help make coding easier. Picking a domain helps ensure that the things we create are valuable and applicable and immediately useful, instead of diffuse efforts to serve all languages without really picking one to be great at.

Now, this isn’t carved in stone. If Haskell comes out of nowhere and gets baked into a billion browsers and they start teaching it to kids in grade school, Glitch is gonna be there. And there are definitely folks on the Glitch team who wish we could offer as great an experience on other languages as we do on JavaScript. But with trends where they are right now, we wanted to explain our rationale behind making a bigger bet on JavaScript and on Node, rather than just saying “we’re language-agnostic”. There’s theory, and thought, and a little bit of history, and a pretty good amount of data, and all of those signals indicate that something special is going on here.

The truth is, we’ve never seen one open language become a nearly-universal programming language for coders. We don’t know what kind of benefits might accrue if the majority of coding effort starts to happen in one language, unless there’s a particular reason to use a domain-specific language that insists we do otherwise.

We just might be on the precipice of an era in coding that’s unprecedented, where we might actually see something new in the patterns of adoption and usage of an entire programming language. That potential has us excited, and waiting with bated breath to see how the whole ecosystem plays out. But even more than that, we’re excited that all of these developments will allow the Glitch community to make apps that are even more expressive and meaningful, while being even easier to realize in code.

We can’t wait to see what you create!