devcarrot

Thoughts and ramblings from Nounder devcarrot

You and I will never have an @nouns.wtf email address, and yet, we could still communicate via email. You have your email address with provider A and I have mine with provider B. Provided my email address, you could compose a message to me and I could reply to your message. We each trust our providers to use systems that speak SMTP, expose us a mailbox over POP/IMAP, and be online most of the time. You don't have to care who I use, I don't have to care who you use; as long as they speak the same protocols, we can communicate and get on with our day. Provider A could specialize in ease of use for customers, Provider B could specialize in web UI that plays lowfi beats and has pretty themes.

Email is a federated system; a series of standards that define how participants (mail servers) communicate messages, a standard for discovery, and a standard for identity formats. Email providers are allowed to implement and expand upon those standards however they see fit. Postfix is a common mail transfer agent that's easily deployed to a single server and allows admins to provide their users an email address. GMail does not run on a single server running Postfix[citation needed] but can communicate just fine with a site running Postfix.

Community

In a community, I would expect that a participant is able to keep up to date with the activities and initiatives therein. Then, that community telegraphs their activities and what they intend to do via some publicly exposed interface. These updates would naturally have the audience of “someone assumed to not be in the community” and would push those updates to be more complete and not make assumptions around prior knowledge or whether the reader has seen internal chat messages.

Take the following examples

+----------------------------+ +----------------------------+
|                            | |                            |
| Proposal 420               | | Proposal 420               |
|                            | |                            |
| We would like to continue  | | Over the last 6 months the |
| making Nouns action figures| | Action Figure community has|
| and selling them on the    | | been developing and creat- |
| world market. If you've    | | ing high quality toys for  |
| been #figures you know how | | collectors.                |
| much reach we've been able | |                            |
| to have. Our sales reports | | Background                 |
| are available at           | | (History of community)     |
| private.team.link/report10 | |                            |
|                            | | Data                       |
| Ask                        | | (In-depth data)            |
| 69 ETH                     | |                            |
|                            | | Next Milestones            |
|                            | | (Recounting of the group's |
|                            | |  next objectives after     |
|                            | |  funding)                  |
|                            | |                            |
|                            | | Ask                        |
|                            | | 69 ETH                     |
|                            | |                            |
+----------------------------+ +----------------------------+

As a participant in the broader NounsDAO, which would you prefer to vote on? Which community would you rather be a part of? Removing the assumption of membership and internal knowledge actually makes communities more transparent and allows them to communicate a more complete vision. While it feels quite corporate and at times can be cumbersome; complete proposals, updates, and externally facing reports would make Nouns stronger and would make communities more accessible to contributors, peers, and prospective members.

Nouns Is Not One Community

While being a member of a Nounish community yields a sense of belonging and cooperation with other Nounish communities, I don't believe we're all required to be one community. Instead, Nouns should be thought of as a federation of communities. I enjoy collaboration and hanging out with members of Nounish communities, but I believe it's a disservice to you and me that there are areas where lines are blurred. Instead, I believe Nouns is caught between needing to become a Federation and clinging on to being a Community. We've outgrown being a single community.

A Stronger Federation

I would like to see “Nouns” treated more as a Federation of communities rather than a singular Community with sub-communities. These different communities can find and attract the people that best fit their objectives and style-of-work. Communities can then reduce the number of “customers” they have to serve from “everyone in the Discord, each with their own sub-community membership and responsibilities” to just “the DAO and internal members”.

Explicitly becoming a Federation will mean that communication coming out of a sub-community loses the assumption of “assume they know” and picks up “assume they don't know”. Which makes the communication easier for NounsDAO Communities to consume but also helps new DAO members get up to speed.

NounsDAO as a Federation would also become a slower-moving collective to make sweeping changes in – which is a good thing. The DAO has a long term vision and should not be treated the same as a community/pod/project. Communities can be quick to react or slow and steady, a Federation has to match the tempo of the sum of all its members – in order to make a change to the Federation, each Community therein must take action in order to agree.

This brings us to the topic of the last few months and more loudly the last few weeks...

Voting Against Discord

The Nounders have decided to recommend to the Nouns Foundation that it shut down the Nouns Discord. I've decided to cast my internal vote for setting a sunset date and winding down the Discord1. NounsDAO is naturally a long term, low tempo organization in aggregate. The opinions outlined above are my primary case as to why the Discord is a mismatch for a Federation and better fits a Community.

I believe that NounsDAO should have as few “official” interfaces as possible and that these venues should serve as an aggregation point for its sub-communities and proposal updates. (Refraining from any Section 230 talk) NounsDAO should act as a publisher and be unable to editorialize. As mentioned in the Nounders' recommendation we've had times where participants have called for the Discord to be editorialized by adding or removing channels or participants. Even the act of adding/not adding bots has been a form of editorializing. The NounsDAO should be free from having to make these decisions and instead provide the interface for sub-communities to make their official actions and develop the primitives for this interaction.

Something like an “Awesome Nouns” or community registry which is a pointer to Communities and what services they provide along with the Auction House and Governor should be the extent of NounsDAO's requirements. It could then be up to the DAO to define the requirements to be part of the “service catalog” and add any communities that meet those requirements.

Why I Was Hesitant

I will admit that early in the conversation I leaned into being devil's advocate – urging caution around closing the Discord. Not because I disagreed that a change to NounsDAO interaction and communication needed to be made, but to attempt being the mediating rod and keep my dislike of Discord as a platform in check. I enjoy Discord as a communication platform for smaller communities and think it was helpful in bootstrapping Nouns when it was a single Community. I'm naturally inclined to want mailing lists, IRC working group channels, and RFCs which runs counter to “move fast and break things” and I tend to be overly cautious with pushing back on other tooling because of it.

Assumption of Agreement

One thing that I've felt is: within Discord, there's an assumption of agreement in silence. If you posit an idea, proposal, or feeling within a channel and see no feedback, it's easy to take that as an assumption of agreement. While I don't necessarily disagree with most of the theories that people post in Discord, it's hard to collect thorough feedback and easy to feel as if you've missed the window for feedback.

Online at the Right Time

Nouns disrupted the NFT space in different aspects but its most immediately visible aspect was its distribution model. “One Noun. Every Day. Forever.” is more than a branding slogan, it’s a challenge to traditional governance and distribution models. Rather than rewarding the fastest to mint a token or early founders with the vast majority of tokens, a governance slow start provided Nouns the opportunity to find its feet along the way and dilute early voices from gaining too much power. Real-time chat is a fundamental mismatch with Nouns ethos as it rewards the first, the loudest, and the earliest anchored.

T+1 (Nouns After Discord)

It's reasonable feedback to say “so you want to shut down Discord, then what?” It's the Nounders' recommendation that we set a sunset date for the Discord, giving the Federation some time to build plans and Communities to spin up. But if we were to just click it off tonight, let's pretend for a moment...

So, we've just shut down Discord, now what? Communities already have their own Discords, those continue to run along on their own. People post memes, say gm, and have voice calls to talk about projects. There's likely a scramble to set up the Nouner validation in each Discord and some work better than others. Some people probably spin up a “New Nouns” Discord server of their own and begin administrating them in their own vision. People join a handful of these with the people they like and they can discus proposals as syndicates and share ideas.

The weekly Nouner and Community calls likely continue, but not in a centralized Discord. Someone will build their own agenda act more like a journalist and capture a bunch of participants. People will subscribe to Nouns News, Nouns Newsletter, Nounish News, Nouny News, and a dozen more until the highest quality are discovered (and then disrupted). Individuals and Communities creating proposals will make their first draft (RFC) and share it with a handful of Communities for initial feedback. They'll attend the Twitter Spaces Circuit and join community Discord calls. People will reply to their Discourse post with questions, and @ them on Twitter. This iteration and Q&A process will lead to a more complete proposals and “oh I hadn't thought of that!”

Nouners will begin to experiment with alternative funding models, we'll see rolling rounds of funding, we'll see further innovation on delegation marketplaces, we'll see development of “minimum Nounish standards” and Communites that prove it wrong, and we'll see Communities further develop and attract strong communicators.

The quality of proposals will increase and more work will happen in public. Because proposals will be unable to rely on the assumption that the reader has been in the relevant channels, proposers will have to be more thorough and present the relevant background. Shopping proposal drafts around will provide additional and more focused feedback.

The United Nations of DAOs does not need to exist as a single Discord.

Congratulations, you've made it to the end of devcarrot rambling. Now have yourself a biscuit and go build something fun.

Footnotes: 1: Herein, “The Discord” refers to the “Nouns” Discord at discord.gg/nouns

noun.pics is a little service that I run that has one mission: send you an image of the Noun you want as fast as possible. In this post I'd like to dive a little deeper into the constraints that the system runs into, why we care about transit time, and how noun.pics could be even faster.

Quick! Blink!

*blink*

Researchers tell us that the human blink lasts around 100-150 milliseconds1. The web likes to use it as a measuring stick for “instantaneous”, in part because our brains are trained to ignore blank spaces for that amount of time. Others argue that around 400ms is the upper bound for interactivity and user feedback2.

In an eerie coincidence, it takes approximately 133 milliseconds for light to travel once around the equator, meaning that even light traveling around the globe should appear instant to us.

This red block is displayed on screen for 100ms every 900ms. Pretty quick right?

Recently, an update to noun.pics has meant the server can respond to a request with the full picture of a Noun in less than 8 milliseconds. By keeping each Noun ready and waiting in memory we don't have to wait for hard drives, network traffic, or Ethereum nodes to give you that 32px-by-32px beauty. But wait, the title says “the 100ms SVG”, where's all the extra milliseconds? In reality – or at least our reality – we have to factor in how data moves around in the real world when we talk about services' ability to quickly provide data to users.

To paint a quick picture: The global Internet is built from tens of thousands of different service providers, all working together to ensure that a packet of data can make it from a device on one side of the planet to the other. Most of the long-haul Internet traffic is carried by massive fibre optic cables that travel over land or under the sea. These cables carry signals encoded in light pulses emitted by powerful lasers. This means the data within the cable has a speed limit – the speed of light.

Noun.pics currently runs within a single datacenter. That means that your request for a Noun must transit your local ISP's network, make it to a big transit provider, and probably traverse one of the massive undersea cables. Then, after one of our servers has processed the request, the packets of data that make up the response must make their way all the way back to you. For most of its journey that packet of data is encoded as pulses of light flying through cables, again constrained by the speed of light. At a certain point, any optimization that's done at the server level won't yield a noticeable difference to the end user because of that transit time.

As of today, noun.pics should receive and service your request in less than 100ms for most users. This 100ms is made up of your request transiting the Internet to the datacenter housing noun.pics, a server receiving that request, translating the Noun into a series of electrical impulses that represent the image, and that signal making it all the way back to you. While everyone will have a different distance to cover, I'm considering 100ms a reasonable estimate for a the following reasons:

  • If you were on the opposite side of the planet from the datacenter it would take approximately 133ms for your request to make it around the globe. While you may not really be at the exact opposite side of the planet, your path also won't be a straight line.
  • Consumer hardware (modems, WiFi access points, and last mile equipment) can inject some latency on the order of 10-20ms regardless of your location in relation to the datacenter
  • Most consumers are a few short hops away from major backbones so once after a few milliseconds your request is on a fast pipe nearly directly to the datacenter

Click this link to Noun 100. It should show up faster than you can notice, faster than that red block from earlier was on your screen, and all through the magic of the global Internet.

Take a moment to thank all the network operators, cable layers, trench diggers, undersea cable ship captains, networking hardware designers, datacenter constructors, and ISP engineers around the world for making it so that we can move jpegs about as fast as physics will allow.

For those curious on how noun.pics will improve on the 100ms barrier: next up will be increasing the service's global footprint so that there are servers are physically closer to you. The closer they are the less far the pulses of light have to go, the less time we have to wait for those annoying laws of physics.

Footnotes:

1: https://www.ucl.ac.uk/news/2005/jul/blink-and-you-miss-it 2: https://lawsofux.com/doherty-threshold/

Alternate Nouns Frontends

Nouns.wtf is the reference implementation for interacting with the Nouns Protocol. Users can bid on the daily auction, create and vote on proposals, or peruse the historic auctions. We designed nouns.wtf to be fast, easy to use, and stable. Since the residency of brianj we’ve seen the addition of more thorough DAO information and design improvements. But nouns.wtf doesn’t have to be the full picture, there’s plenty of space in the sandbox for us all to play.

Nounish Federation

The blockchain ecosystem is built in-part on federation, even if we don’t acknowledge it every day. Technology, design, and finance come together to build systems with standardized interfaces and common languages. Building permission-less and accessible contracts naturally encourages interoperability and building of alternatives.

From Wikipedia:

A federation is a group of computing or network providers agreeing upon standards of operation in a collective fashion.

Projects like Mastodon and other federated microblogging platforms have been building federated alternatives to social media giants for those concerned about privacy or want to own their experience. Rather than having a one-size-fits-all or one-site-serves-all approach, these federated instances have agreed upon a standardized format called ActivityPub for exchanging messages between instances and gossiping between themselves.

A standardized protocol allows different groups to design and build implementations that serve them or their community best. This is where we can build Nounish Federation.

Just like some instances in the federated social media space may prioritize posting pictures, snappy interfaces, or interfaces that accommodate different abilities we can start to build interfaces to the Nouns protocol that facilitate interaction differently through alternative frontends and other people running frontends to the Nouns protocol.

We've already built the first layer of standards in the Nouns Token, Nouns Auction House, and Nouns DAO contracts which are all accessible via any Ethereum node or JSON-RPC provider using one of the many Web3 libraries in various languages.

Why More Frontends?

The Nouns ecosystem is growing every day, as is the DAO of DAO model. As more people join the Nouns DAO directly or indirectly through sub DAOs more people depend on the ability to interact with the Nouns Protocol. The protocol itself is built on Ethereum making it an unstoppable application, but a nice Web3 application makes it much easier to interact with that application. By the nature of the Internet nouns.wtf is a centralized site that we need to keep operational and well configured so that people can interact with the protocol in an easy way.

There are standard availability risks with a single centralized frontend. A single web app run by a group of humans will naturally have some availability issues – even though we aim for the most reliable system we can. It’s likely that everyone has experienced an outage with their bank, an internet provider outage, or some other failure that prevented them from accessing something important.

The Nouns Protocol doesn’t need a centralized frontend though. Anyone can clone the open source reference implementation and run their own, fully disconnected from the centralized instance that the Nouns Foundation operates. The Nouns Protocol is open for anyone to interact with it, we just run one interface.

This could mean that if nouns.wtf were to break for an hour, people could go to alternative frontends and interact with the exact same protocol – the same daily auction, the same DAO proposals, and the same tokens; whether that was an instance that someone ran for themselves or one operated by a group of people.

While insuring against a single point of failure is a great reason for alternative frontends some people may just prefer a different frontend.

There’s no law in the Nouns Protocol saying that a frontend to interact with it must look like nouns.wtf or that it must provide the same functionality. Someone may prefer a minimalist interface that only displays information about the daily auction. A sub DAO may make their website an alternate frontend by including the ability to interact with the Nouns Protocol along-side their internal voting tool within their website. Folks could even choose to trust nobody and run their own private instance with their own Ethereum node – able to control every interaction with the blockchain without trusting anyone else. As the Ethereum network evolves there may be frontends that focus exclusively on some experimental technology. All of these can take place without affecting any of the other frontends and simultaneously making the Nouns Protocol more resilient.

Where Can We Go From Here?

Additional instances of nouns.wtf can be deployed today using the free tier of many vendors. Someone could sign up for a free Netlify account and a free Alchemy or Infura account and deploy their own instance of the Nouns webapp for free.

We’ve built @nouns/sdk to make building an alternative frontend easier as well. With helpers to find contract addresses on different networks, decode images, and to interact with the contracts it’s ready for imagination. Whether that’s a different translation, working with some experimental technologies, or building new functionality the Nouns Protocol is open for experimentation.

If you're interested in running your own Nouns frontend, stop by #developers in the Nouns discord.