Browse the ShareCode blog by topic

How the ShareCode topics are organised

Most blogs grow into an undifferentiated stream of posts that are hard to navigate once the archive passes a few dozen entries. We took a different approach. Every article on ShareCode is filed under a single topic — what we call a silo — so that a reader who arrives looking for one idea can follow a clear path through everything we have written around it, rather than scrolling a reverse-chronological feed and hoping to stumble onto something relevant.

A silo is more than a tag. Tags scatter a subject across an archive; a silo gathers it. When you open a topic, you are looking at a curated reading list that has been ordered deliberately, with each article aware of the others around it. The structure mirrors how people actually learn a subject — you rarely understand a hard idea from a single page. You read one explanation, hit a term you do not know, follow it, come back, and read the next layer. Grouping our writing this way turns the blog into something closer to a short course than a feed.

Each topic above collects the posts that belong together and links them to the next logical read. If you start with an article on conflict-free replicated data types, the related links will steer you toward operational transforms, presence and awareness protocols, and the trade-offs of building real-time collaboration on top of WebSockets. You are never more than a click from the next piece in the same line of thinking, and you can always step back up to this index to switch direction entirely.

What you will find here

The catalogue spans the engineering that goes into a collaborative code editor and the workflows developers build around one. Collaboration internals cover how multiple cursors stay in sync, how edits merge without a central lock, and how presence is broadcast to everyone in a session. Editor topics look at syntax highlighting, language detection, keyboard-driven workflows, and the small decisions that make an editor feel fast. Interview-focused pieces explain how to run a fair technical screen, what to look for in a live coding round, and how candidates can prepare without memorising trivia. Underneath all of it sits a set of foundations — data structures, networking, and the protocols the rest of the work depends on.

We keep the topic list short on purpose. A new topic only appears once there are enough well-researched articles to make it worth browsing as a group. That means the index stays useful: every entry leads somewhere substantial, and nothing is padded out to fill a category. If you are looking for a single definition rather than a full article, the glossary covers the core terms in a sentence or two each, and links back to the longer pieces that explain them in depth.

Real-time collaboration, from the inside

The collaboration topic is the heart of what ShareCode is built on, so it is also where our writing goes deepest. Letting two or more people type into the same document at the same time sounds simple until you try to build it. The moment edits arrive out of order, or two people change the same line within milliseconds of each other, you need a principled way to merge their intentions without losing anyone's work or freezing the editor while a server decides who wins.

Articles in this topic walk through the two dominant approaches to that problem. Operational transformation, the technique that powered the first generation of collaborative editors, rewrites incoming operations against the ones that have already been applied so that every client converges on the same result. Conflict-free replicated data types take a different route: they model the document so that concurrent edits commute by construction, which means clients can merge in any order and still agree. We explain where each shines, why CRDTs have become the more common choice for peer-to-peer and offline-friendly editors, and the cost they carry in metadata and memory. We also cover the supporting machinery that rarely gets written about — the awareness protocol that broadcasts cursors and selections, the relay that forwards binary updates without ever parsing your code, and the persistence layer that lets you close a tab and come back to the same document hours later.

Building and using a fast code editor

A code editor lives or dies on feel. Latency you can perceive, highlighting that lags a keystroke behind, or an autocomplete that fires at the wrong moment will drive developers away faster than any missing feature. The editor topic looks at how modern web editors stay responsive: incremental parsing so the whole file is not re-tokenised on every keystroke, virtualised rendering so a ten-thousand-line file scrolls as smoothly as a ten-line one, and the language tooling that turns plain text into something the editor understands.

Beyond the internals, this topic is practical. ShareCode supports more than fifty languages, and the articles here cover the workflows that make day-to-day coding quicker — multiple cursors, structural selection, keyboard shortcuts worth committing to muscle memory, and the download-and-share habits that keep your work safe. Whether you are building an editor or simply trying to get more out of one, the goal is the same: spend less time fighting the tool and more time writing code.

Technical interviews that respect everyone's time

A real-time editor is a natural home for live coding interviews, and many teams use ShareCode for exactly that. The interview topic is written for both sides of the table. For interviewers, it covers how to design a screen that measures the skills the role actually needs, how to give a candidate room to think out loud, and how to avoid the puzzle questions that test recall rather than engineering judgement. For candidates, it covers preparation that pays off — reasoning through a problem methodically, communicating trade-offs, and staying composed when the editor is shared and the clock is running.

The throughline is fairness. A good technical interview should feel like a conversation about how someone solves problems, not a gauntlet of trivia. We write about formats that surface real signal, the biases that creep into unstructured interviews, and how a shared editor with no setup friction lets the conversation start immediately instead of ten minutes into a screen-share.

The foundations everything rests on

Collaboration, editors, and interviews all sit on top of the same bedrock: data structures, networking, and the protocols that move bytes reliably between machines. The foundations topic exists so that the deeper articles do not have to re-explain the basics every time. Here you will find clear treatments of the concepts the rest of the catalogue assumes — how WebSockets keep a connection open for low-latency two-way messaging, why certain data structures make concurrent editing tractable, and how systems stay consistent when the network is slow or unreliable.

These pieces are written to stand on their own as well. If you are studying for an interview, brushing up on a concept you half remember, or simply curious about how the web's real-time features actually work, the foundations topic is a good place to start before climbing into the more specialised material.

How to use this page

Pick the topic that matches what you are trying to learn and open it. Each topic page lists its articles newest-first, shows how many pieces it contains, and surfaces the most recent one so you can tell at a glance whether it is actively maintained. From any article you can jump to related reading in the same topic or branch into an adjacent one. If none of the topics fit what you are after, use the suggestion link below — every request goes into the editorial queue and helps us decide what to write next.

Everything here is written by named engineers rather than an anonymous content team, and reviewed before it ships. That is why the catalogue grows slowly: we would rather publish one article that is genuinely worth your time than ten that are not. If a topic helps you, the best thing you can do is follow its related links and keep reading — the deeper you go into a silo, the more the pieces start to reinforce one another. And when you are ready to put any of it into practice, ShareCode itself is one click away: open a code space, share the link, and start writing code together in real time.