What even is Ecma? (Part 1)

Twice a year, I come back from an Ecma International ExecCom meeting on behalf of TC39. It's the biannual gathering of Ecma's executive committee, where a good chunk of the organization's real administrative work actually happens, and where officers of the various TCs (Technical Committees) come together to present status reports, catch up on what's going on across the org, and respond to whatever initiatives are currently in motion.

To some readers, that opening sentence is already an exciting glimpse into something they'd been curious about. For everyone else, it's a pile of jargon. Fair enough.

Despite several of us dedicating large parts of our lives to this standards organization — the one that governs the development of what happens to be one of the most widely used programming languages on the planet, powering the web and basically anything with a UI — there's a wide gap between how the people inside the system perceive their work and how everyone else experiences it. Most JavaScript developers I talk to have no clear sense of what Ecma is, who runs it, or how any of it relates to the language they use every day.

And why should they have that sense? Because the more visible the governance of JavaScript is to the people using it, the more accountable we become, and the more responsible we have to be. That matters more now than it used to. In an AI-assisted development world, the average JavaScript developer is spending less time writing code and more time explaining what they want to a coding agent. The language decisions we make flow downstream through the models and into the prompts people write.

So: a field guide to Ecma, in more detail than I've put in one place before. This is Part 1, covering the organization itself. Part 2 will dig into three of the committees in detail: TC39 (ECMAScript), TC53 (ECMAScript modules for embedded systems) and TC55 (Web-interoperable server runtimes), where the actual JavaScript language lives.

Ecma International

ECMA used to be an acronym (for "European Computer Manufacturers' Association"). It isn't anymore — it's a proper noun now (like npm). Ecma International is a standards development organization based in Geneva, Switzerland, similar to other standards bodies like ISO, W3C, and the Unicode Consortium. Historically it has maintained a broad portfolio of technology standards (including the CD-ROM format for instance), but today it's best known as the home of the ECMAScript language specification. That is to say, JavaScript.

Members are organizations, not people

Here's the first thing that trips people up: the members of Ecma are companies and organizations, not individuals. You and I, as individuals, can participate as delegates or invited experts, but we don't hold membership. Generally, it's either your direct employer, the non-profit/open-source project you volunteer for or academic institution you're a part of that does.

Ecma has five categories of members, who each pay a flat annual membership fee that hasn't changed for over 25 years.

Between them, these members send delegates to the various technical committees, and Ecma's own staff supports that work from the secretariat. Most of the people you meet around Ecma are technical contributors employed by one of these member organizations.

How Ecma is governed

Ecma's structure has a clear hierarchy, so let me walk it from the top.

flowchart
    ga["General Assembly"]
    mn["Management"]
    sc["Secretariat"]
    ec["Executive Committee"]
    tc["Technical Committees"]
    tg["Task Groups"]
    st["Standards"]
    tr["Technical Reports"]
    ga --> mn
    ga --> sc
    ga --> ec
    mn --> tc
    sc --> tc
    ec --> tc
    tc --> tg
    tc & tg .-> st & tr

The General Assembly

The General Assembly, or GA, is the highest authority in Ecma. Every member sends one representative. In practice, the GA is mostly a formal body — it ratifies final standards and votes on the big-picture questions — and it delegates day-to-day work downward.

Management

Ecma's management is three elected officers, chosen from within the GA:

The Secretariat

If the management is the elected leadership, the secretariat is the staff — the people who actually work at Ecma and keep the organization running day to day.

I want to single Aki out. She is genuinely one of the most helpful people in the whole organization, and a lot of what makes the communication between the committees and Ecma leadership actually work is her doing. She translates between highly technical, motivated TC members and the more bureaucratic parts of the organization, and she's extremely good at it.

Samina, as Secretary General, keeps the lights on and keeps us all pointed at a unified goal. As TC chairs, those of us who serve in that role try to support that direction by constantly steering our committees toward productivity and consensus rather than friction.

The Executive Committee

The ExeCom is the body that I mentioned in the beginning that meets twice every year. It's an elected group that makes recommendations to the GA on business, legal, managerial, and organizational matters, including specific things like organizing, adding, and dissolving technical committees. It runs the organization between GA meetings.

Its current composition is:

Several of the non-ordinary-member ExecCom seats are held by people active in TC39 — Ross, Peter, and Mikhail among them. That's not an accident. It's useful for us to have people in the ExecCom who know the TC side intimately and can translate in both directions.

Technical committees and task groups

This is where the actual technical work happens: the ECMAScript specification, the Internationalization API, the recently-chartered TC55 on web interoperability. That's all for Part 2.

Related organizations

Ecma has cooperation agreements and liaisons with a handful of related bodies. The list is short enough to name in full:

The shape of the org

The General Assembly sits on top. It formally controls the secretariat, the ExecCom, and management, all of which shape what the TCs can do. In practice, the GA is mostly a ratifying body. The ExecCom, being smaller and more active, actually runs the organization between GA meetings. And the TCs, where the real technical work lives, operate under that framework.

That last layer is where JavaScript, the language itself, actually gets made. That's where Part 2 picks up: a closer look at the technical committees, especially TC39, TC53 and TC55. Stay tuned.