The site uses cookies that you may not want. Continued use means acceptance. For more information see our privacy policy.

Twitter’s Mixture

Dang, shoulda written about an edit button.

Although I first used Twitter around 2008, I didn’t start using it regularly until a few years into the dark ages of Donald John Trump, looking for some light. In general, using social media without a set or clique or cohort or whatever word you want isn’t that easy. A lot of the informal rules and norms aren’t written down, can vary by subculture, and unless you have people to help you understand them, it’s pretty bewildering.

Social media has rough edges that don’t seem to be getting smoothed out. This post looks at one of them: bad mixtures.

Social media (and, to a lesser extent, the web in general) has a blender effect. Instead of a nice balanced meal of an entree, some sides, a hunk of bread, a glass of water, and maybe some dessert, Twitter dumps them all into a blender and end up with a nutraloaf-style mixture.

All the various accounts are coming at you with a bunch of different contexts and tones. Their avatars are the same regardless of what they are saying. You see the cute puppy dog, the business headshot, the cartoon, or whatever the hell my avatar is supposed to be (?), telling you some tale of humor or outrage. It’s very body-snatcher-esque, a constant branding clashing with the highs and lows of content.

There are some modest ways to tweak the blender. Twitter Lists let you toss particular accounts together by some common quality. It works well for accounts that stick to one type of content. But every individual’s account has its own blender effects, so while Lists might help on the average day, they inevitably fail from time to time, when you find the feeds inadvertently conspire to produce another info-sip of yuck. And if you have enough coverage of different accounts, it’s likely at least one subset will be having a bad-news day.

Some of this mixing works to Twitter’s favor. The diamonds in the rough reinforce you to keep scrolling away in hopes of finding the next one: a random reinforcement schedule. But it’s awfully jarring in between. You don’t get a balanced diet without significant efforts to curate your experience. On any given day, the compounding of various accounts posting bad news can doom your scroll. Or you can be in a serious mood and suddenly see a bunch of fluffies to distract you.

Compared to the newspapers, where editors dealt with multiple sections and worked to balance the content and ads, cutting to fit or padding to fill, Twitter is a Pacific Gyre of awful bits, where we hope to glimpse the rare dolphin or whale.


But here’s the thing: the model has an answer. Social media runs on user contribution. The users do most of the work already, adding, amplifying, and filtering content. They can do more. Add category and tone or mood options to tweets. Let people who retweet or like a tweet add their own curation on top of it, in case the “Cool” thing they retweet is really “Lame” to their mind. Is it sad funny pretty ugly hot stupid wild depressing far-fetched down-to-earth food-for-thought or whatever (pronounced what-ever)?

And then let users choose to see the good news together, the bad news together. Give us the choice. Let us separate the Sports from the Politics (until we hit a story about a sporty politician or what have you). Hashtags are a good way to search, but they don’t put the tweets into buckets and most tweets have no hashtags.

The idea is that social media, that Twitter, does not have to be a mixture of whatever these accounts we follow happen to surface, rather than something with an extra layer of filtering atop that. Let users do what they do best and help each other out.

Perhaps as machine learning matures, automatic classifiers that fit users needs will become available, but until then, shouldn’t Twitter users have moderation and filtering tools that are at least as effective as Slashdot’s were 20 years ago?

The Distributed Would-be Web 3.0

The transition from Web 1.0 to Web 2.0 should inform any future upgrade.

The cryptocoin community wants to make Web 3.0 some kind of distributed-systems push where everything self-assembles and auto-contracts and has to depend on proof-of-whatever in order to function. Not exactly sure what it has to do with the web itself, but they’re trying to call it Web 3.0.

With the Web-version meme being resurged, it’s a good time to consider what Web 1.0 was, what Web 2.0 was, and what Web 3.0 could be.

Web 1.0

Actually unversioned, the original web had design limits imposed by the technology and computing speed of the day. It was full of proprietary extensions and oddities like blink and marquee and embedded MIDIs.

At this stage, many companies were still trying to get online at all. Websites still had “under construction” and “pardon our progress” type stuff. There was the Blue Ribbon Campaign to keep free speech online.

But the applications and systems of Web 1.0 were limited in certain respects. They were static, often not built by the server but hand-written. We were served simpler pages for a simpler time.

Web 2.0

In one word, Web 2.0 was about AJAX, which was actually six words: asynchronous javascript and extensible markup language. Rather than every user interaction triggering a pageload, it would rewrite parts of the document on the fly.

The utility of the term Web 2.0 was the fact that it pointed to user-facing changes. Under the hood there have been other changes in how the web works, but they were more gradual, and they didn’t have the same kind of surfer-facing impact.

The rise of web applications is basically forgotten. It has completely blended in to our brains. Nobody thinks twice when we see new content appear in a feed or when moving mail around in a web interface without intervening page-loads.


As we try to formulate what Web 3.0 could be, it’s important to recognize the type of shift it implied when we went from Web 1.0 to Web 2.0. It represented a change that helped on both sides: users got nicer pages, and developers could send small chunks rather than rebuild the entire page with every action.

The Distributed Web 3.0

The cryptocoin community’s version is a distributed system. Different parts of current applications could be handled by independent services, with coordination happening by magic and smart contracts. Smart contracts are a way that computers can sell or buy resources without human intervention.

Let’s say you break the system into a few parts:

  • Content
  • Language
  • UI or design
  • Advertising

The user wants to look at some piece of content. They request it from a distribution system, which sees the user speaks a different language than the content. It invokes a translation service first, before requesting a design appropriate for the user’s preferences (print or mobile or desktop or VR). Finally the design site-agent asks for appropriate advertising given the user’s location, language, whatever other factors. The user gets back their hyper-custom piece of content.


It’s hard to see what a smart-contract, proof-of-whatever would really deliver users over our current systems. It’s not to say that distributed applications aren’t a nice idea where they make sense. It is simply that it doesn’t seem to have the same kind of win-times-N benefits that the previous revolution did.

Security, reproducibility, caching, all sorts of questions come forth with a distributed web. They may be solved, but even if they are, they don’t provide an AJAX-style gain to users.

For other purposes, there are similar questions for distributed systems. How a distributed equivalent of Amazon might operate, for example. It would need some kind of curation mechanism, which Amazon is already pretty bad at. But where is the curation mechanism for a distributed marketplace? Any reasonable approach could be adopted agnostic of whether it applied to a distributed site or one like Amazon.

In some ways, due to technological maturity and, more importantly, business and social adoption, there may never be a true Web 3.0. Seeing how the tracking and advertising industries have metastasized, the web itself is less inviting all the time. One might look to Gemini, a successor to the old Gopher protocol, rather than try to breathe fresh life into an increasingly dystopian web.

What is Data Infrastructure?

In place of hot air about the definition of infrastructure, some thoughts about data infrastructure.

Data infrastructure is something like a road, or maybe a bridge. It’s a set of standards that allows data systems and consumers of data to operate without too much effort. DNS, the domain system, is infrastructure, translating readable names into numeric addresses and adding a layer of abstraction to things so that addresses can change. With paved land and spans, you don’t have to load sacks on a burro to carry goods through an untamed land, up and down hills, fording rivers, gazing at the stars and bouncing from landmark to landmark to find your way. Data infrastructure should work the same way. The modern internet needs more data infrastructure.

In email, we have the problem of spam. To deal with spam, many systems have been developed to filter it, to block spammers, and so on. It isn’t perfect, but it generally works. But we haven’t generalized that infrastructure to other problems. Some things, like anti-virus scanning of mail, uses some of the same systems, but each is generally its own thing. Other places, we see ad blockers and browsers have lists of malicious websites to warn users. Some data infrastructure exists here, but could be more generalized.

Other places, we see no real data infrastructure. Several times per year I read about journalists and others who are targets of harassment campaigns online. The social systems lack the same kind of filter technologies that email has. But it could be generalized. It should be generalized.

Identity, the ability to create a digitally-signed identity and authenticate with websites, would be a great and welcome form of data infrastructure. It has risks if it lets government censors snuff out dissent, but that already happens too often. A correctly described identity system would allow for multiple identities or multiple expressions of an identity depending on where and how it’s used.

The advertising industry already tries to create identity tokens, but users have limited control over them. Some laws get passed to try to give control, and now every website has to tell you about cookies, but you still don’t have control, you just have an extra piece of cyber garbage floating atop every website.

Infrastructure lowers friction. Building websites has a key barrier: user-sign-up. The easier it becomes for a user to sign-up, the less advantage incumbents have. That is paramount for competitiveness in many online spaces. This and other barriers are the sort that data infrastructure should break down, in the same way that the transcontinental railroad and other major infrastructure projects opened up lands for new cities and new economies.

Other commerce-related data infrastructure changes would be welcome. One is simple resource links that are platform-agnostic. They would let you link to a song without linking to a particular music service. Or link to a video game without pointing at a specific store. That kind of infrastructure helps to allow competition without forcing fans to show favorites or act as advertisers without their consent.


As the internet matures, opportunities arise to define and build data infrastructure. It took humans thousands of years to figure out roads and city planning (and we still get it wrong sometimes), but as we settle into patterns of use and behavior, and as we continue to have more data capacities, we need to be looking at ways to generalize our tools into outright infrastructure that supports the smooth flow of activities of all sorts.

What are the internet’s rivers that we can send boats down? Where are its mountains, requiring us to seek passes or blast tunnels? What will be the critical pieces of infrastructure that let computers do more work, rather than pretend to be a fancy form of paper?