Co-Editing Networks: Methods & Dynamics

• Co-Editing Networks are network representations that capture collaborative editing behaviors by mapping interactions such as sequential edits, code modifications, and shared editorial practices.
• They employ mathematical tools like temporal adjacency matrices, burstiness coefficients, and Levenshtein distance metrics to quantify editing efforts and predict cascades in activity.
• Applications span open source software, Wikipedia revisions, and multimodal narrative systems, providing insights into community dynamics, productivity, and quality control.

Co-editing networks are network representations of collaborative editing activity in which nodes may denote developers, editors, language communities, journals, or multimodal artifacts, and edges encode editing-based relations such as editing code previously written by another developer, editing after another editor in a revision sequence, statistically significant shared interest in editing the same concepts, or shared membership on editorial boards (Qarkaxhija et al., 30 Sep 2025, Ashford et al., 2019, Samoilenko et al., 2016, Baccini et al., 2019). As an analytic object, the co-editing network links low-level edit traces to meso- and macro-level phenomena including burstiness, activity cascades, controversy signatures, cultural borders, editorial power, productivity, churn, and the protocol design of real-time co-editors.

1. Definitions and major variants

Across research domains, the term denotes different but structurally related projections of editing behavior.

Setting	Nodes	Edge semantics
OSS developer co-editing	Developers	$A \to B$ when $A$ edits code previously written by $B$
Wikipedia revision network	Editors of one article	$v_i \to v_j$ when $v_i$ edits immediately after $v_j$
Multilingual co-editing similarity	Language editions	Weighted tie from significant shared interest in editing the same concepts
Interlocking editorship	Journals	Weighted tie by number of common editors

In Open Source Software, the central interpretive move is to treat one developer editing code previously written by another as a proxy for social interaction and potential social influence. The resulting network is temporal and directed, and it serves as the substrate on which “activity cascades” are defined and tested (Qarkaxhija et al., 30 Sep 2025). In line- and block-level mining, the same relation is formalized as a time-stamped event $(A,B;t,w)$, where $A$ modifies code originally authored by $B$ at time $t$, with effort weight $A$0 derived from textual change (Gote et al., 2019).

Wikipedia work uses two distinct network constructions. At the article level, a revision network is a simple directed graph in which an edge $A$1 means that editor $A$2 edited the article after editor $A$3; self-loops are excluded and repeated adjacency does not create multi-edges (Ashford et al., 2019). At the cross-language level, the nodes are 110 Wikipedia language editions and the edge weight $A$4 measures how strongly two language communities co-edit the same concepts beyond null-model expectations (Samoilenko et al., 2016).

A related but distinct one-mode projection appears in scholarly communication. An Interlocking Editorship network links journals that share editorial-board members, with edge weight equal to the number of common editors. In that setting, the network is interpreted as a map of editorial power and shared gatekeeping (Baccini et al., 2019).

2. Construction and mathematical representation

In Git-based software repositories, a canonical co-editing event is

$A$5

meaning that at time $A$6 developer $A$7 edited code previously written by developer $A$8. A temporal adjacency can be written as

$A$9

and a windowed weight as

$B$0

This event-level construction is extracted from Git histories by git2net, which decomposes commits into hunks, runs git blame on the parent revision, and reconstructs line-level or block-level ownership transfer (Qarkaxhija et al., 30 Sep 2025, Gote et al., 2019).

The finer-grained representation used in git2net is

$B$1

where $B$2 is often the Levenshtein distance between pre-edit and post-edit text, used as a proxy for editing effort. The tool also computes Shannon entropy,

$B$3

to identify high-entropy text-encoded binary content that would otherwise distort effort statistics (Gote et al., 2019).

For a Wikipedia article with revision history ordered by adjacent edits, the revision network is

$B$4

with no self-loops and no multi-edges. Conceptually, its adjacency matrix is

$B$5

This construction deliberately abstracts away from edit semantics and focuses on temporal interaction structure (Ashford et al., 2019).

For multilingual Wikipedia, co-editing is defined at the concept level. If $B$6 is the number of edits by language edition $B$7 on concept $B$8, then the empirical co-editing weight is

$B$9

With $v_i \to v_j$0 total edits, $v_i \to v_j$1, and $v_i \to v_j$2, the null expectation is

$v_i \to v_j$3

A concept-level z-score is

$v_i \to v_j$4

and the aggregate similarity edge is

$v_i \to v_j$5

This yields a statistically filtered co-editing similarity network among languages (Samoilenko et al., 2016).

3. Temporal dynamics, burstiness, and activity cascades

A major line of work studies co-editing networks as dynamic substrates for accelerated response processes. In OSS communities, commit histories are bursty at both project and developer level. Given commit times $v_i \to v_j$6, inter-event times are $v_i \to v_j$7, and the burstiness coefficient is

$v_i \to v_j$8

Empirically, individual-level mean burstiness is $v_i \to v_j$9 with standard deviation $v_i$0, versus shuffled mean $v_i$1; project-level mean is $v_i$2, and all projects satisfy $v_i$3 (Qarkaxhija et al., 30 Sep 2025).

The same study defines a co-edit $v_i$4 as a potential trigger for a fast response by $v_i$5. Let $v_i$6 be $v_i$7’s commit times. The response interval is

$v_i$8

where $v_i$9 is the first commit time of $v_j$0 after the co-edit. If the percentile rank of $v_j$1 within $v_j$2’s own historical inter-commit intervals is at most $v_j$3, the event is classified as a trigger. Cascades are then temporal chains

$v_j$4

in which every $v_j$5 is a trigger and $v_j$6. Using 100 temporally shuffled null realizations per project, the authors report that 56% (28/50) of projects show a statistically significant excess of cascades under temporal shuffling, with some effect sizes reaching roughly 27 standard deviations above the null mean. Cascades are typically shallow, with average depth about $v_j$7–$v_j$8 trigger events and about $v_j$9–$(A,B;t,w)$0 distinct developers per cascade (Qarkaxhija et al., 30 Sep 2025).

A more general dynamic formalism treats time-varying networks as a sequence $(A,B;t,w)$1 on a common vertex set. In a co-editing context, each $(A,B;t,w)$2 would be the co-editing graph in time window $(A,B;t,w)$3. Co-community structure is then captured by snapshot-specific membership matrices $(A,B;t,w)$4 and a shared co-membership matrix $(A,B;t,w)$5, estimated by

$(A,B;t,w)$6

This formulation is designed to recover persistent communities together with dynamic deviations (Zhang et al., 2011).

4. Higher-order structure and mesoscopic organization

Beyond dyads and paths, co-editing networks have been studied through motifs, communities, and cross-network comparison. For Wikipedia revision networks, motif analysis is based on the 13 connected directed triads and the Subgraph Ratio Profile. For triad type $(A,B;t,w)$7,

$(A,B;t,w)$8

and

$(A,B;t,w)$9

On 21,631 English Wikipedia articles, controversial articles show over-representation of triads 111D, 111U, and 201, and cluster at high values of the first principal component, which explains 53.7% of variance; PC2 explains 22.3%, and PC3 6.7% (Ashford et al., 2019).

At the cross-language scale, Infomap on the weighted co-editing similarity network identifies 21 multi-language clusters plus 9 languages forming their own clusters. English forms a single-language cluster. The strongest explanatory factors for cross-language co-editing similarity are bilingualism, shared language family, and shared religion, while geographic distance is the weakest among the tested hypotheses. In the full MRQAP model, adjusted $A$0 (Samoilenko et al., 2016).

Interlocking Editorship networks reveal another mesoscopic layer. Here journals are nodes, weights count shared editors, and Jaccard dissimilarity between journal editor sets is compared with analogous dissimilarities in co-citation and interlocking authorship. Across statistics, economics, and information and library sciences, the three network families are positively associated. The strongest distance correlation is always between co-citation and interlocking authorship, while interlocking editorship is consistently the sparsest network type. Its communities, however, have the highest modularity in all three fields: 0.400 in statistics, 0.528 in information and library sciences, and 0.444 in economics (Baccini et al., 2019).

5. Prediction, performance, and collaborative outcomes

Co-editing networks have been used not only descriptively but also for forecasting and performance analysis. In OSS communities, developer churn is modeled with Logistic Regression over non-overlapping 12-month windows, evaluated in a leave-one-repository-out setting with SMOTE and balanced class weights. Balanced accuracy ranges from about 58% to 84% across projects. The strongest features are Maximum Inactivity Time (1.011), Neighbors’ Max Inactivity Time (0.605), and Neighbors’ Mean Inactivity Time (0.467); among structural variables, Out-degree (0.364) and Distance to founder (0.263) are larger than In-degree (0.046) and Betweenness (0.008) (Qarkaxhija et al., 30 Sep 2025).

A related large-scale Git study uses more than 1.2 million commits and more than 25,000 developers to test whether productivity is higher when developers edit their own code than when they edit foreign code. Productivity is defined as

$A$1

with $A$2 the Levenshtein effort and $A$3 the inter-commit time. Across six OSS projects, mixed-effects models show a positive, statistically significant effect for the own-code fraction, with relative productivity increases ranging from about 14% in FFmpeg to about 128% in igraph when working on own rather than foreign code (Gote et al., 2019).

In Wikipedia WikiProjects, the coeditor network is the directed unweighted graph in which an edge from editor $A$4 to editor $A$5 exists if $A$6 edits an article and later $A$7 edits the same article. Project performance is

$A$8

where $A$9 and $B$0 are the numbers of Featured and Good Articles, and efficiency at grade threshold $B$1 is

$B$2

Empirically, low-degree coeditor networks are associated with both high performance and high efficiency. In the performance regression, standardized coefficients are −0.7 for log mean degree, −0.4 for log out-degree skew, and −0.33 for log mean path length (Platt et al., 2018).

6. Trust, quality assurance, and reviewer selection

A complementary line of work models collaborative editing platforms as trust networks and propagates article satisfaction rather than editing influence. The network is

$B$3

where $B$4 is the user set, $B$5 means that user $B$6 trusts user $B$7, $B$8 is trust, and $B$9 is the minimum satisfaction threshold for user $t$0. With a set of raters $t$1 and ratings $t$2, non-rater satisfaction is defined by

$t$3

while $t$4 for raters. Under the convention that users with no trust path to any rater receive $t$5, the system has a unique solution in $t$6 (Sekar et al., 2012).

Reviewer selection becomes the MAXIMUM-SATISFACTION problem: choose at most $t$7 raters to maximize the number of satisfied users. That problem is NP-hard by reduction from Maximum $t$8-Cover. The proposed greedy strategy iteratively adds the non-rater with highest marginal satisfaction gain. In simulations on directed Erdős–Rényi graphs with 10,000 users and uniform rater score $t$9, only about 20% of users need to review to satisfy almost everyone under typical parameter choices, and the marginal-satisfaction greedy algorithm substantially outperforms random selection and a simpler incoming-trust heuristic (Sekar et al., 2012).

This quality-control model is not itself a co-editing graph in the narrow sense. It is, however, a graph-theoretic overlay on collaborative editing platforms in which review effort, trust, and satisfaction can be optimized without requiring all participants to inspect the current version.

7. System architectures, controversies, and multimodal expansion

At the systems level, co-editing networks are also distributed infrastructures that propagate operations among replicas. OT and CRDT have often been presented as competing paradigms, but detailed comparative work argues that both follow the same general transformation approach for text co-editors: users generate position-based operations on external state, and the system must transform or reinterpret those operations so that replicas converge while preserving causality and user intention (Sun et al., 2019, Sun et al., 2018).

OT systems are typically organized around a Transparent Adaptation architecture with a Single-user application, a Collaboration Adapter, and a Generic Collaboration Engine. Canonical communication topologies include server-based OT, distributed OT with a message server, and fully distributed OT. The same comparative literature argues that the claim “OT needs a central server; CRDT doesn’t” is false: both OT and CRDT can use scalar or vector timestamps, both can be embedded in client–server or more distributed topologies, and actual CRDT-based co-editors still rely on servers for at least session management or broadcast (Sun et al., 2019).

The empirical asymmetry in deployment is clear in the surveyed literature. OT underlies systems such as Google Wave/Docs, ShareJS, CKEditor collaborative editing, Etherpad, Dropbox Paper, Box Notes, and Codox Apps, while CRDT-based text co-editors are mostly represented by smaller prototypes such as Teletype and Alchemy Book. The critique of CRDT in this setting focuses on hidden transformation steps, tombstone or identifier overhead, and unresolved correctness anomalies in specific sequence designs (Sun et al., 2018).

A different expansion of the concept appears in multimodal story-writing systems. Vistoria defines co-editing as synchronized, bidirectional manipulation of text and images treated as “co-equal narrative materials.” Its basic unit is a card containing an image, a corresponding story fragment, and object keywords; highlights, comments, and cluster-panel aggregations connect cards through shared characters, objects, and scenes. Operations such as lasso, collage, filters, and perspective shift propagate across modalities rather than within a single text stream (Fu et al., 17 Sep 2025). This suggests that the notion of a co-editing network is broadening from user–user and user–document projections toward networks of artifacts, references, and structurally mapped cross-modal entities.

Current research also delineates recurrent limitations. In OSS cascade analysis, the trigger threshold is fixed at the 25% quantile, cascade tracing is restricted to the top 20% most active initiators, and only Git co-editing is modeled, excluding issues, pull-request comments, mailing lists, and chat. In Wikipedia revision networks, temporal adjacency is assumed to represent meaningful interaction, while edit content and off-platform coordination are ignored. These constraints motivate multi-layer interaction models, semantic augmentation, and generative temporal models such as Hawkes processes as natural next steps (Qarkaxhija et al., 30 Sep 2025, Ashford et al., 2019).