DEV Community: Boris Orekhov

🧠 I Trained a Massive Word2Vec Model on 13 Billion Russian Fiction Words — Here’s What Happened

Boris Orekhov — Mon, 07 Sep 2026 06:14:00 +0000

TL;DR: I built a lemma‑based Word2Vec model (CBOW, 300d) on a huge corpus of Russian fiction (13B tokens → 7.3B after cleaning). You can load it with Gensim and explore semantic neighborhoods of words like слово, язык, речь. The model captures literary semantics without stop words or grammar tags. Check it out on Hugging Face.

Why another word2vec for Russian?

Most pre‑trained Russian word2vec models are trained on web crawls, news, or mixed corpora. That’s fine for general NLP, but fiction has its own semantic rules. Poetic metaphors, archaic vocabulary, and author‑specific styles shift vector spaces.

I wanted a model that:

Is trained exclusively on fiction (from classic to modern authors).
Uses lemmas (no inflection noise).
Is small enough to ship (197 MB for the main model, plus two 5.8 GB arrays).
Lets researchers and developers play with literary semantics.

So I built one. And I’m sharing it under the MIT license.

The Corpus by Numbers

Metric	Value
Raw words before preprocessing	13.98 B
After lemmatization & stop‑word removal	7.36 B
Sentences (after cleaning short ones)	1.36 B
Paragraphs processed	~539 M

Stop words: removed using this list.

Lemmatizer: Yandex Mystem.

Sentence splitter: razdel.sentenize.

All lemmas are lowercase, dictionary form, no part‑of‑speech tags (saves time & space).

Training Details

import gensim

data = gensim.models.word2vec.LineSentence('splitted_lemmed_lines.txt')
model = gensim.models.Word2Vec(
    data,
    vector_size=300,
    window=10,
    min_count=2,
    sg=0          # CBOW (faster, good for large corpora)
)
model.save('cbow_300_10.model')

CBOW, not skip‑gram – slightly better syntactic capture for fiction.
Window size 10 – balances local and long‑range dependencies.
Min count 2 – very rare words become noise; keep it clean.

The training script is plain Gensim – no weird dependencies. You can retrain or fine‑tune if you have more data.

What’s Inside the Download?

When you clone from Hugging Face, you get:

cbow_300_10.model (197 MB) – the main Gensim model object
cbow_300_10.model.syn1neg.npy (5.8 GB) – negative sampling weights
cbow_300_10.model.wv.vectors.npy (5.8 GB) – the actual word vectors
README.md, tst.py – docs and a test script

Yes, the two .npy files are large. But you can load the model without loading both if you only need similarities (Gensim does lazy loading). Or use model.wv directly.

Quick Start – Get Similar Words

import gensim

model = gensim.models.Word2Vec.load("cbow_300_10.model")

# Look at closest neighbours of "слово" (word)
for word, score in model.wv.most_similar("слово", topn=10):
    print(f"{word}: {score:.4f}")

Output:

фраза: 0.7941
словечко: 0.6602
слог: 0.6322
реплика: 0.6015
словосочетание: 0.5928
изречение: 0.5818
высказывание: 0.5800
глагол: 0.5735
эпитет: 0.5615
сентенция: 0.5556

Notice how epithet and verb pop up – the model clearly learned linguistic meta‑concepts from fiction.

Now try язык (language / tongue):

наречие (adverb) 0.6684
диалект 0.6095
латынь 0.5892
язычок (little tongue) 0.5698
алфавит 0.5039
грамматика 0.5027
суахили 0.4977
идиома 0.4952
иврит 0.4950
произношение 0.4927

And речь (speech):

монолог 0.6400
спич 0.5914
тирада 0.5900
фраза 0.5652
диалог 0.5477
проповедь 0.5334
слово 0.5217
разглагольствование 0.5193
филиппика 0.5184
декламация 0.5147

Cool Things You Can Do

Author style analysis – Compare vector spaces of Tolstoy vs. modern authors.
Semantic change over time – Not directly, but you can train separate models for 19th and 20th century subsets.
Genre classification – Fiction vs. non‑fiction (though this model is pure fiction, so it will be biased).
Creative writing tools – Find thematic associations, generate metaphor candidates.
Educational – Show how word geometry reflects literary concepts.

Known Limitations (Read Before You Complain)

No POS tags – All lemmas are ambiguous (e.g., стекло could be noun “glass” or past tense of “to flow”). That’s a conscious trade‑off for performance.
Only lemmas – No inflected forms. Want слова, слову, словом? You won’t find them; use the lemma слово.
Fiction bias – This model will perform poorly on legal documents, tweets, or technical manuals. But that’s the point.
Large memory footprint – The full model takes ~12 GB on disk. However, you can load just the vectors with KeyedVectors.load() to save RAM.

Comparison with Other Russian Word2Vec Models

Model	Corpus	Size	POS	Availability
This one	Fiction, 13B words	300d	No	MIT, HF
w2v-russian-tolstoy	Only Tolstoy	300d	No	MIT, HF
w2v-russian-19c-fiction-lemmas	19th century prose	300d	No	HF
RusVectores (web+news)	Mixed, ~20B	300d	Yes (tags)	CC BY‑SA

If you need a general‑purpose model with grammatical info, go for RusVectores. If you work with literary analysis, this one is your friend.

Why You Should Star / Share / Fork

📦 Ready to use – pip install gensim and model = gensim.models.Word2Vec.load(...)
🧪 Reproducible – Full preprocessing script included in the HF repo.
📚 Academically referenced – Several papers already used it (see README).
🚀 Lightweight core – The 197 MB model loads in seconds; the big .npy files are optional.

Get the Model

Hugging Face: nevmenandr/w2v-russian-fiction

License: MIT

Clone with git lfs or download via huggingface_hub:

from huggingface_hub import snapshot_download
snapshot_download(repo_id="nevmenandr/w2v-russian-fiction", local_dir="./w2v_model")

What I’d Love to See in the Comments

🧩 Use cases – Are you doing computational literary studies? Building a Russian story generator? Tell me!
🐛 Issues / improvements – Did you find a bug? A word that should be a lemma but isn’t?
📊 Benchmarks – How does it perform on your task compared to other models?
🧠 Funny analogies – Run model.most_similar(positive=['царь', 'женщина'], negative=['мужчина']) and share the result. (Hint: it’s not “царица” – fiction is weird.)

Final Code Snippet – Try It Yourself

import gensim

model = gensim.models.Word2Vec.load("cbow_300_10.model")

# Find words similar to "поэт" (poet)
print("Neighbors of поэт:")
for w, s in model.wv.most_similar("поэт", topn=5):
    print(f"  {w}: {s:.4f}")

# Analogy: Москва : Россия = Париж : ?
result = model.wv.most_similar(positive=["Франция", "Москва"], negative=["Россия"], topn=1)
print(f"\nМосква / Россия ≈ Париж / {result[0][0]} (score {result[0][1]:.4f})")

Run it. Play with it. Break it. Then tell me in the comments what you found.

Happy vector hunting! 🧙‍♂️

P.S. The model is called cbow_300_10.model – old‑school name, but it works like a charm.

How I Ended Up Publishing My Coding Journey – and Why CoderLegion Made It Worthwhile

Boris Orekhov — Tue, 01 Sep 2026 22:50:00 +0000

A few weeks ago, I received an unexpected message.

It came from the CoderLegion community team. They'd noticed my engagement on the site and asked if I'd be interested in sharing my programming journey as part of their "Developer Stories" series.

My first reaction? Skepticism, if I'm honest. I've been around long enough to know how these things usually go. Platforms reach out, they promise visibility, they ask for content, and then... crickets. Your carefully written piece gets buried under an avalanche of "10 JavaScript Tips You Won't Believe" and disappears into the void.

But something about their approach felt different. They were direct, genuine, and – most importantly – they'd actually read what I'd written before reaching out. That's rarer than you'd think.

"But I'm not a real developer"

I felt I should be upfront. I replied that I'm not a professional software engineer – I'm a researcher, a scientist, a humanities guy who learned to code out of necessity. My code has never been production-grade, I've cut more corners than I care to admit, and my early work still makes me wince in hindsight.

Would that kind of story still be of interest?

Their response was immediate and unequivocal: "Absolutely."

No gatekeeping. No "well, let's see if it fits our editorial direction." Just a straightforward recognition that a researcher's pragmatic, messy, real-world coding journey might actually be more relatable than another polished success story from a FAANG engineer.

That was the moment I decided to say yes.

From philology to Python – and everything in between

I wrote the piece over a couple of days. It wasn't difficult – the memories came flooding back. PHP without templates, Perl without use strict;, Python without a debugger, all held together with hope and echo statements. My "server" was shared hosting that ran CGI scripts, and my "database" was a handful of MySQL tables that today I'd replace with a JSON file.

The story wrote itself, really.

When I sent it over, I braced myself for edits, rewrites, or the dreaded "this is great, but could you make it more technical?" None of that happened.

Why CoderLegion stands out

Now that the piece is live, I want to share a few thoughts about the platform itself – because it genuinely deserves attention.

1. It's a small community, and that's a good thing

Platforms like DEV.to have become enormous. That's great for reach, but it also means your carefully crafted post competes with thousands of others. Unless you're writing about the latest JavaScript framework or AI trend, you're shouting into the void.

On CoderLegion, the community is smaller, but the engagement feels more genuine. My posts there get modest view counts – but they're still several times higher than on DEV.to. People actually read, reflect, and respond. It reminds me of the early internet, where community meant something.

2. They treat contributors like humans, not content factories

This is the big one. The person who reached out didn't just send a template email and move on. They read my work, understood its value, and engaged in a thoughtful, personal conversation throughout the entire process. The editorial support was light-touch but effective – they helped my story shine without making it theirs.

Too many platforms treat contributors as interchangeable content providers. CoderLegion doesn't.

3. They allow republishing

This might seem like a small thing, but it matters. CoderLegion permits authors to share content that's already appeared elsewhere. I haven't taken advantage of it yet, but knowing that I can – without being locked into exclusivity – lowers the barrier to participation significantly. It's a flexible, author-friendly policy that respects your time and effort.

What I'd tell other developers

If you're considering sharing your journey, here's my advice: don't overthink it.

You don't need to be a rockstar developer. You don't need to have built the next unicorn startup or contributed to major open-source projects. Your story – with all its false starts, bad habits, and lessons learned the hard way – is probably more valuable than you realise. Because somewhere out there, someone is making the same mistakes you did, and they'd benefit from hearing that it's okay.

Platforms like CoderLegion exist precisely to tell those stories.

Final thoughts

The piece went live recently, and I've already shared it with my Telegram audience. The response has been warm – several fellow researchers and self-taught coders reached out to say they saw themselves in the narrative.

That's the whole point, isn't it? To connect, to reassure, to remind each other that we're all figuring it out as we go.

So here's my public thank-you to the CoderLegion team. Thank you for reaching out, for trusting my story, for handling it with care, and for building a space where imperfect journeys are welcomed.

I'll be writing more about the experience on DEV.to soon – but for now, if you're curious, here's the piece itself:

https://coderlegion.com/25394/from-philology-to-python-how-i-fell-into-coding-and-why-my-code-still-makes-me-wince

And to anyone reading this: if you have a story to tell, tell it. You might be surprised who listens.

How to Actually Determine Authorship with a Computer (And Why Most People Get It Wrong)

Boris Orekhov — Thu, 27 Aug 2026 05:56:00 +0000

TL;DR: Most “computer‑based” author attribution you see on the internet is junk. Average word length? TF‑IDF + cosine similarity? Please. There’s a method that actually works – it’s called Delta, it’s 20 years old, and you can run it with a few clicks in R. Let me show you why the naive approaches fail and how real stylometry is done.

The problem with “obvious” methods

We’ve all seen it: someone grabs a few texts, computes average word distribution or most frequent words, draws a pretty line chart, and declares they can tell who wrote what.

Spoiler: they can’t.

A famous example – in 2018, a data scientist tried to identify the anonymous New York Times op‑ed “I Am Part of the Resistance Inside the Trump Administration”. He used TF‑IDF on Trump administration members’ tweets, computed cosine similarity, and concluded… the most likely author was Trump himself (or someone from State Department). Not very convicing.

That’s not science – that’s cargo‑cult data analysis.

Even worse, a 2023 book Python for Hackers dedicates a whole chapter to stylometry, yet it uses average word length and plots line charts copied from 19th‑century geophysicist Thomas Mendenhall. Yes, the same Mendenhall who thought word‑length distributions would work like spectral analysis of chemical elements.

Spoiler: they don’t. Grzybek (2007) already buried that idea.

So if those methods are garbage, what actually works?

Enter John Burrows and the Delta method (2002)

Burrows proposed a surprisingly simple distance measure between texts – Delta. It uses only the 100–500 most frequent words (mostly function words like “the”, “and”, “of” – not content words). That’s genius, because it ignores topic and focuses on style.

Here’s the intuition:

For each text, compute the relative frequency of each frequent word.
Convert to z‑scores (how many standard deviations above/below the corpus average).
Delta between two texts = mean absolute difference of their z‑scores across all words.

Small Delta → stylistically similar → probably same author.

No neural networks. No thousands of parameters. Just robust statistics.

And it works. On English, Russian, Arabic, Ancient Greek, even Chinese (yes, despite no clear word boundaries). Nobody knows exactly why – but it has been validated on hundreds of test cases.

How to run it without writing a single line of R

There’s an R package called stylo (Kestemont et al., 2016). It has a point‑and‑click GUI.

install.packages('stylo')
library(stylo)
stylo()   # GUI opens

You put your texts in a folder named corpus. Name files like author_title.txt – stylo automatically colors by author in the output.

It produces a dendrogram (cluster tree). If the method works, texts by the same author cluster together.

I tested 24 Russian prose texts (Lermontov, Chekhov, Leskov, Gogol). One unknown text (“???”) was supposed to be by Leskov. Result: 23 out of 24 correctly clustered. Only one early Chekhov story drifted to Lermontov – because Delta is sensitive to author’s evolution over time.

The unknown text landed right with Leskov.

Not perfect – but far better than random guessing.

Case studies that (sort of) worked

Rowling / Galbraith (2013)

When J.K. Rowling published The Cuckoo’s Calling as “Robert Galbraith”, stylometrists quickly identified her as the author. Rowling later confessed. A model case, right?

Well… stylo includes a galbraith dataset. I ran it. The data are hand‑picked: authors from different centuries and genres, making Rowling stand out artificially. A more honest test? Still works, but less dramatic. Always question your benchmark.

The Quiet Don (Sholokhov)

The famous Russian novel has been suspected to be plagiarised from Fyodor Kryukov. Delta analysis (using 100+ texts) shows:

It’s not Kryukov.
“Don Stories” (signed Sholokhov) and “The Quiet Don” cluster together → same author.

Politics aside, the data are clear.

Bitcoin white paper (Satoshi Nakamoto)

Here the method is abused. The white paper has only ~3700 words – well below the recommended 10k+ minimum. Still, curious minds ran it: the paper clustered with Craig Wright.

Should you trust that? Absolutely not. But it’s fun.

Where Delta breaks (and why you should care)

Different genres – comparing a play to a novel makes no sense. Remove the play.
Theological texts – for unknown reasons, Delta often fails on religious writings. Atheist algorithm?
Short texts (< 10,000 words) – too noisy. Don’t even try.
Authors who change style radically – early vs. late Chekhov can look like different people.

So it’s not magic. But when used correctly, it’s the best we have.

For the curious programmer

If you want to dig deeper:

Burrows, J. F. (2002). Delta: A Measure of Stylistic Difference.
stylo package: https://github.com/computationalstylistics/stylo
My colleague’s visualisation (better than dendrograms): distributions of intra‑author vs inter‑author distances.

And a fascinating book: Passwords: Philology, Security, Authentication by B. Lennon (2018) – it traces the common roots of cryptography and stylometry. The first US crypto‑analysis unit hired… English professors who argued over Shakespeare’s authorship.

Final verdict

Next time someone shows you a line chart of average word lengths to “prove” who wrote something, send them this post. Real authorship attribution is harder – but also more reliable when you use proper methods like Delta.

And remember: if the text is shorter than 10,000 words, just walk away. No method can save you.

Try it yourself:

Download a few texts by two different authors (>10k words each), name them author1_title.txt, run stylo(), and see if they separate. You’ll be surprised how well it works.

Chess plays as data for word2vec models

Boris Orekhov — Mon, 17 Aug 2026 05:42:00 +0000

♟️ You shall know a piece by the company it keeps

Chess plays as data for word2vec models

Programmers, have you ever looked at a PGN file and thought: this looks like a language?

What if we trained word2vec on 5.4 million chess games, treating each move as a word and each game as a sentence? Would the vectors capture anything about chess strategy? Or would it be nonsense?

I asked exactly that. And the results are surprisingly… meaningful.

🔗 Original preprint: arXiv:2407.19600

🧩 The core idea

Word2vec relies on the distributional hypothesis: a word’s meaning is defined by its context (neighbouring words).

Orekhov’s move: apply the same to chess moves.

He built 18 different models from a corpus of ~5.4M high‑level games (≈840M moves).

Two main approaches:

Type 1 – moves only (each move = a word, game = sentence)
Type 2 – moves + board state (each “sentence” = current position + the move)

Then: train word2vec (skip‑gram / CBOW), get dense vectors (300‑500 dims), and run the usual NLP tricks – nearest neighbours, odd‑one‑out, analogies, t‑SNE visualisations.

🔍 What the model learned (without ever seeing a board)

Test	Result
Quasi‑synonyms	Closest vectors to `Pe2e4` are `Pe2e3`, `Ng1f3`, `Pd2d4` – exactly what you’d expect.
Odd one out	`[Pe2e4, Ng1f3, Pd2d4, Bf1c4, Nb1c3, Pb4b5]` → `Pb4b5` is flagged (edge pawn move, rarely an opening).
Analogies	`king - man + woman ≈ queen` for words. For chess: `Pe2e4 - Pf2f4 + pe7e5` suggests `pe7e6` (French Defence). Works.
Castling detection	`Ke1g1` (short castling) → closest vectors include `Rh1f1` and `Ke1c1`. The model learned that king and rook move together.
Endgame clusters	t‑SNE shows extremely clean, piece‑separated clusters. Openings are messy (all similar).
Bishop colour	Light‑squared and dark‑squared bishops form different clusters – the model learned chess‑relevant semantics.
Captures as “POS tags”	Adding `_CAP` / `_N` made moves cluster by destination square instead of source piece. A new kind of “part of speech” for chess.

📊 Over 68% of moves have at least 3 of their 10 nearest neighbours being the same piece moving to the same square. That’s not random – it’s structural.

🤯 The most beautiful visualisation

The model trained on games without queens produced a perfectly symmetric t‑SNE plot – white moves on one side, black moves mirrored.

The algorithm had no concept of “colour” as a feature. Yet the distributional signal was so strong that the two colour spaces separated like antipodal points on a sphere.

⚠️ The honest conclusion (refreshing for a paper)

“I don't see how this representation can be used productively. It's unlikely to help engines or humans choose the best move. But in a purely academic sense, it captures something important about the nature of the game.”

No overhyped “this will revolutionise chess AI”. Just a clean, curious application of NLP to a symbolic system – and it works.

🧰 For the hacker’s toolbox

All models are public on HuggingFace: nevmenandr/w2v-chess
Code & data: PGN corpus of 5.4M games (freely available online)
Techniques used: word2vec, t‑SNE, cosine distance, analogies, “stemming” (removing source square), part‑of‑speech tags for captures

📚 Cite this work

APA

Orekhov, B. (2024). You shall know a piece by the company it keeps. Chess plays as a data for word2vec models. arXiv preprint. https://arxiv.org/abs/2407.19600

IEEE

B. Orekhov, “You shall know a piece by the company it keeps. Chess plays as a data for word2vec models,” 2024. [Online]. Available: arXiv:2407.19600

MLA

Orekhov, Boris. “You Shall Know a Piece by the Company It Keeps. Chess Plays as a Data for Word2vec Models.” arXiv, 2024, https://arxiv.org/abs/2407.19600.

BibTeX

@misc{orekhov2024shallknowpiececompany,
      title={You shall know a piece by the company it keeps. Chess plays as a data for word2vec models}, 
      author={Boris Orekhov},
      year={2024},
      eprint={2407.19600},
      archivePrefix={arXiv},
      primaryClass={cs.CL},
      url={https://arxiv.org/abs/2407.19600}, 
}

👉 Would you run word2vec on Go games? Poker hands? Protein folding sequences? The method is language‑agnostic – and that’s the real lesson.

Natural Languages vs. Programming Languages

Boris Orekhov — Fri, 07 Aug 2026 05:30:00 +0000

Natural Languages vs. Programming Languages: Same Word, Different Worlds

We call them both “languages” – but does a for loop have anything in common with a love poem? Turns out, yes and no. And the differences are way more interesting than you might think.

The Reason We Have Languages (Either Kind)

Languages exist to pass information around. Human languages gave us tribes, then kingdoms, then sci-fi novels about interstellar travel – written centuries before anyone ever left Earth. That’s flexibility.

Computers, on the other hand, speak machine code: raw numbers and arithmetic operations. BB 11 01 means something to a CPU, but to a human? It’s a headache. So in the late 1950s, we invented programming languages – a human-readable middle layer that gets translated into machine code. That’s why you can write if user.is_active: instead of pushing hex bytes around.

How Human Languages Lie (and Why Code Doesn’t)

Russian says “dождь идёт” – “the rain walks”. English says “it rains” – “it rain-verbs”. French says “il pleut”. None of them are true: there’s no walker, no “it”, just water falling from the sky. Human languages force reality into their own grammar.

Machine code has zero such illusions. It’s brutally literal: take this number, add that number, put the result there. No metaphors, no actors, no walking rain.

Low‑Level vs High‑Level – It’s Not a Class Thing

“Low‑level” languages (like assembly) stay close to the machine – you tell the CPU every tiny step. “High‑level” languages (Python, JavaScript) let you say “make it pretty, I don’t care how”. The naming reflects our narcissism: humans at the top, computers at the bottom.

The Real Killer Difference: Narration vs Commands

What do we do most with natural language? We tell stories.

I woke up dressed in an armchair,

In my own flat among familiar walls…

Now try to write that in C. All you get are assertions: I_am = dressed; I_am = awake; my_location = armchair; Clunky, right? Programming languages are built almost entirely for the imperative mood – do this, go there, set that. They’re instruction manuals, not novels.

Want to talk about the past? Good luck. Natural languages handle tense effortlessly. In code, the past doesn’t matter unless you explicitly store it. And concepts like “spiritual thirst” (Pushkin’s famous line) can’t be mapped to a variable – thirst = 0 is just an empty box, not a longing.

But People Still Write Poetry in Code

Yes, really. There are esoteric languages like Shakespeare, where the source code looks like a Renaissance play. And people have written poems in Python and JavaScript – some for everyone, some for the elite few. The results are awkward, fascinating, and beautifully absurd.

Bottom Line

Both language families have words and grammar. But natural grammars are universal – they can describe anything from a rainy street to a broken heart. Programming grammars are narrow, laser‑focused on giving commands. One tells stories, the other gives orders. And that’s why you can’t import a soul.

Chess & Computer Tech Today – A Programmer’s Take

Boris Orekhov — Mon, 27 Jul 2026 05:25:00 +0000

Chess & Computer Tech Today – A Programmer’s Take

Remember when beating a human at chess was the holy grail of AI? In 1972, it was literally the benchmark. Fast forward to today: a random office desktop crushes any grandmaster. Game over? Not even close.

Chess didn’t die – it went full cyberpunk. And as a programmer who barely knows a fork from a fianchetto (my Lichess rating is ~800), I’ve become obsessed with how code reshaped this ancient game. Here’s what every dev should care about.

1. Analysis engines – the real MVP

Every chess move today gets instantly judged by an engine. That little “thermometer” on stream? It’s a live eval bar. One blunder, and the score tanks from +2 to -3 – you feel the drama.

But here’s the fun part for us: I built vector models of chess games using word2vec. Treating moves like words in a sentence. Preprint here: arxiv.org/abs/2407.19600. Turns out, chess positions embed nicely into vector space. Who knew?

2. Cheating – from SMS to… sex toys?

Cheating in chess is not like doping. A single engine move at the right moment = game over. So offline tournaments scan players like airport security.

But the real WTF moment: during the 2022 Carlsen–Niemann scandal, Elon Musk suggested Niemann might have received moves via a remote-controlled vibrating sex toy hidden inside his body. Yes, seriously.

And how would you encode a chess move without Bluetooth? French team at 2010 Olympiad used SMS + captain standing near imaginary chessboard squares. Programmers, think about it: you could encode a move with just 2 vibrations (source square, target square). Someone even wrote Python demo for that.

3. Online chess – pre-moves, flag-hunting, and lag

Online blitz (3+0, 3+1) is a different beast. Premoves let you queue your next move while opponent thinks. Click, and it executes instantly when their move arrives. No physical clock button. No “oops I dropped the knight”.

But then you get flag-hunting – players in losing positions spam premoves hoping the winner runs out of time. Old-school champ Kramnik calls it unethical. New generation says “it’s in the rules”.

The ultimate test? A 2024 match between Kramnik (legend, hates flag-hunting) and Jospem (online phenom, suspected cheater). Half the games OTB, half online, same room back-to-back. Result: inconclusive. But the drama? Chef’s kiss. Also, organizers printed fresh laptops – Windows updates caused lag only for one player. Conspiracy? Probably just Windows.

Why it matters for devs

Chess is no longer about “intelligence”. It’s about psychology, emotion, and… code. We built machines that play perfect chess, then humans kept playing anyway. Now we’re debating: does a premove change the nature of the game? Is online chess “real” chess? Can we detect cheaters from move statistics?

These are our questions – systems design, anomaly detection, real-time constraints, UI/UX of time controls.

And the best part? No definitive answers. Just like software engineering.

Combinatorics of Beads

Boris Orekhov — Fri, 17 Jul 2026 05:10:00 +0000

🧩 Combinatorics of Beads: When Tang Poetry Meets Chess in Python

What if you could shuffle classical Chinese verses using chess moves — and get weird, wonderful new poetry?

If you’ve ever read Hermann Hesse’s The Glass Bead Game, you know the feeling: a mysterious, intellectual game where players combine symbols from music, math, art, and literature to create beautiful, useless patterns. Hesse never explained the rules. He wanted every reader to invent their own.

So I did. With Python.

Meet Chess Bead Game – a small Python package that lets Tang dynasty poems (8 lines × 7 characters + punctuation = 8×8 grid) play a game of chess against themselves. Each character is a square. Every move swaps two characters. After 40 moves, the poem becomes… something else.

And something surprisingly poetic.

🎯 The Rules (such as they are)

Take a classical Chinese poem from the Tang era (7 characters per line, 8 lines → 8×8 board).
Load a real chess game from a PGN file.
For each move: swap the characters on the from and to squares.
Watch the original text mutate – step by step, move by move.
No practical purpose whatsoever. ✔️

That’s it. Pure, useless, beautiful combinatorial art.

🐍 Show Me the Code

import chess_bead as cb

game = cb.Game()           # loads a random poem + a random chess game
verses = game.start_game() # run all moves

viz = cb.Viz(verses, game.author, game.title)
viz.gif()                  # creates an animation of the whole transformation

That’s literally it. Two lines to shuffle an 8th‑century poem using a Kasparov‑vs‑Topalov knight sacrifice.

📜 Before & After (with Machine Translation)

Original poem (anonymous Tang style):

新婦去年胼手足，
衣不暇縫蠶廢簇。
白頭使我憂家事，
還如夜裏燒殘燭。
當初為取傍人語，
豈道如今自辛苦。
在時縱嫌織絹遲，
有絲不上鄰家機。

Translation (DeepL):

Last year the bride’s hands and feet were calloused,
No time to sew, silkworms abandoned in their frames.
White hair makes me worry about family matters,
Like a candle burning low in the night.
At first I listened to other people’s gossip,
How could I know I’d suffer so myself?
Back then I complained that weaving silk was too slow,
But now I have silk – yet won’t use the neighbor’s loom.

After 10 chess moves – same characters, completely new order:

新裏去年胼手家，
衣不暇婦憂廢簇。
白頭使我蠶足事，
還如夜織燒殘不。
當初為嫌絲人語，
豈道縫今自辛苦。
在時縱取傍絹遲，
有如燭上鄰家機。

New translation:

Last year in the inner chamber, calloused hands stayed home,
No time for the woman – worries over wasted silk frames.
White hair makes me busy with silkworm matters,
Yet like weaving at night, burning the candle but not quite.
At first I disliked the gossiping people,
How did I know the seams would now be stiff with toil?
Back then I freely took the silk, but too slow,
It's like a candle on the neighbor's loom.

The two versions enter a dialogue. The banal candle becomes surreal. Helplessness turns into defiant.

♟️ Why Programmers Will Love This

It’s completely useless – perfect for a side project.
Combinatorial explosion – 64! possible permutations, but constrained by chess move legality.
Data mashing – poetry × chess × machine translation × animation.
Plug‑and‑play architecture – easily extend to other text grids (Latin hexameters? Haiku? ASCII art?).
Python package on PyPI – pip install chess_bead and you’re ready.

The package already includes:

A small corpus of Tang‑style 8×8 poems.
PGN parser for real chess games.
GIF generator (shows each move as a frame).
DeepL integration? No, but you can pipe the output yourself.

🧠 The Bigger Picture

Hesse dreamed of a game that weaves together mathematics, music, astronomy, Greek, Latin, and Chinese wisdom. This is one tiny step: chess (rules) + Chinese poetry (data) + randomness (deterministic but emergent).

The next steps? Add mathematical sequences, musical notation, ancient Greek fragments, maybe a SPARQL endpoint to Wikidata. Imagine a game where a Beethoven motif, a line from Ovid, and a tangram shape swap places according to chess rules.

Yes, it’s absurd.

Yes, it’s beautiful.

Yes, I want to see the GIF.

📦 Get It / Try It

PyPI: chess_bead
Docs: chess-bead.readthedocs.io
GitHub: github.com/nevmenandr/chess_bead

pip install chess_bead

Then run the 3‑line script above and watch poetry disintegrate into art.

🎼 “Let it resound in our games, in our whole life, in everything we create and endure!”

― Hermann Hesse (paraphrased)

Inspired by Alexander Genis’s confession: “In *The Glass Bead Game, I was only interested in the game itself. Everything else – just because.”*

When Code Speaks Latin and Acts Like Shakespeare

Boris Orekhov — Tue, 07 Jul 2026 05:02:00 +0000

When Code Speaks Latin and Acts Like Shakespeare Or why programmers secretly love useless beauty

You’d think poetry and programming are light-years apart. They aren’t. Their intersection is the charming, useless zone where engineers become artists.

🧠 Natural languages vs. code

Linguistics isn’t pure humanities — it’s closer to biology. But programming languages have words, syntax, and expressiveness. Just like in human speech, you can say anything in any programming language. The difference? How many lines you write and how much cruft the CPU swallows.

Latin lets you say “the generation that will beget even worse” in one tight phrase. Russian? Awkward illiteracy. Same in code: Python is concise but hides massive overhead. Assembly is verbose but brutally efficient.

🔁 The assignment quirk

Most languages write x = 5 (right to left).

R flips it: 5 -> x.

It’s a tiny rebellion against how we think.

📜 Poetry in binary?

Victor Pelevin once joked about writing poems in assembly — “fewer rhyming problems in binary.” A wink at the myth that poetry needs rhymes. (It doesn’t. Ask the Japanese or ancient Greeks.)

🎭 Esoteric languages: beauty without utility

These are languages built not to solve problems, but to amuse, provoke, and confuse.

1. Perligata — code in Latin

No fixed word order. Declensions do the work.

nexto stringum reperimentum da = assign to $next the position in a string.

Free order, just like Latin poetry. The creator: “If you ask ‘Why?’ – the answer won’t make sense anyway.”

Pure humanities fuel.

2. Shakespeare — programs as Elizabethan plays

Variables are characters (Romeo, Juliet).

Logic is hidden in dialogue: “Thou art as villainous as the square root of Romeo!”

It can only add, subtract, and print. But it looks like a postmodern play.

💡 Why this matters for devs

Because not every line of code needs to ship to production. Sometimes you write for the weird joy of it. These languages remind us that programming is also a form of expression — absurd, beautiful, and deeply human.

“If you have to ask ‘Why?’, then the answer probably won’t make any sense to you either.”

Enjoyed this? Share with a colleague who secretly writes poetry in their comments. Or someone who still thinks Latin is useless. 😉

A Skeptical Review of Critical Code Studies

Boris Orekhov — Sat, 27 Jun 2026 04:45:00 +0000

Is Code Really a “Social Text”? A Skeptical Review of Critical Code Studies

TL;DR: A sharp academic review takes aim at Mark C. Marino’s Critical Code Studies (MIT Press, 2020). The verdict? Lots of hype, some interesting cases, but little real code analysis. If you’re a programmer who rolls your eyes at postmodern buzzwords, this one’s for you.

📖 The Book in a Nutshell

Marino argues that code has escaped the programmer’s dungeon and entered mainstream culture. Code is no longer just a tool – it’s a social text whose meaning changes with every new reader (lawyers, poets, activists, etc.). The book promises a literary‑style reading of software, drawing on postcolonial, feminist, and queer theory.

🔍 What the Review Says (Boris Orekhov, Digital Humanities, 2026)

Me, Boris Orekhov - a digital humanities scholar - is not impressed. My main gripes:

Overblown claims – “Audience of code has exploded!” Really? When was the last time a climate change debate hinged on reading source code? I call it cherry‑picking.
Case‑dropping, not analysis – We get anecdotes: a protest sign in C, a feminist PHP app, the Transborder Immigrant Tool. But actual code examination is superficial. A license phrase (“no warranties”) is noted as tragicomic – that’s about it.
Lost the plot – Marino sets up a story about two programmers competing for a job, then… never finishes it. This happens every 10‑15 pages.
Postmodern catechism – The book wears its ideology on its sleeve (postcolonial, queer, feminist). Fine, but it substitutes slogans for rational argument. Systematic methodology? Nowhere.
Missing prior work – My own 2015 paper on code as poetry, and Black’s 2015 Mozilla history (which does a real textual analysis), are ignored.

🤖 The Elephant in the Room: LLMs

The book was written when only humans wrote code. Now LLMs generate code without intention or social context. That guts Marino’s entire framework of authorial social meaning.

🎯 Final Verdict

“This book is less a scientific study and more a cabinet of curiosities – or a postmodern art exhibit catalog dressed as a monograph.”

It might find its audience, but don’t expect a toolkit for actually reading code.

👩‍💻 Why Should Programmers Care?

Because the gap between how we write code and how humanities scholars talk about it is huge. This review gives you an honest, critical look at one of the most hyped books in “software studies.” You’ll learn:

Why calling code a “text” is both obvious and misleading
Why social‑justice lenses often skip the actual for loops
What happens when ideology meets semicolons

And you’ll get a good laugh at academic overreach.

📄 Read the Full Review (PDF)

👉 Critical Code Studies review – Orekhov 2026

📚 Cite the Original Review

APA

Orekhov, B. (2026). Рецензия на книгу Марка К. Марино «Критические исследования кода» [Review of Critical Code Studies, by M. C. Marino]. Цифровые гуманитарные исследования, (1), 114–121. https://doi.org/10.31860/cgi-2026-1-114-121

MLA

Orekhov, Boris. “Рецензия на книгу Марка К. Марино «Критические исследования кода».” Review of Critical Code Studies, by Mark C. Marino. Цифровые гуманитарные исследования, no. 1, 2026, pp. 114–121. DOI: 10.31860/cgi-2026-1-114-121.

Chicago

Orekhov, Boris. “Рецензия на книгу Марка К. Марино «Критические исследования кода».” Review of Critical Code Studies, by Mark C. Marino. Цифровые гуманитарные исследования 1 (2026): 114–121. https://doi.org/10.31860/cgi-2026-1-114-121.

BibTeX

@review{Orekhov2026code,
  title = {Рецензия на книгу Марка К. Марино «Критические исследования кода»},
  author = {Орехов, Борис},
  year = {2026},
  doi = {10.31860/cgi-2026-1-114-121},
  journal = {Цифровые гуманитарные исследования},
  number = {1},
  pages = {114--121}
}

💬 Let’s Discuss

Have you read Critical Code Studies? Do you think code has a “social life” beyond its function? Drop your take in the comments – and share this post if you want more honest, no‑BS book reviews for devs.

CriticalCodeStudies #BookReview #SoftwareStudies #Programming #DigitalHumanities

Poetry in Code

Boris Orekhov — Wed, 17 Jun 2026 04:08:00 +0000

Poetry in Code: When Code Becomes Poetry

Have you ever written poetry in Java? Or C++? It turns out there’s a whole genre at the intersection of programming and poetry — code poetry. Not just poems about computers or programmers, but actual executable programs that are also poetic texts.

Ten years ago I published a paper proposing a method for analysing such works. Here are the key ideas — I think the dev.to community will find them interesting.

What is it?

Imagine writing code in Java, Python, or even CSS — it runs and works. But at the same time, the source code itself reads like a poem: rhythm, metre, imagery.

Here’s an example from Habr (2013):

if (newGame) resources.free();

s = FILENAME + 3;

setLocation(); load(s);

loadDialog.process();

try { setGamerColor(RED); }
catch(Exception e) { reset(); }

while (notReady) { object.make();
  if (resourceNotFound) break; }

byte result; // change to int!

music();

System.out.print("");

This Java code can be compiled and executed. And when read aloud, it follows a strict trochaic tetrameter. The author deliberately arranged the accents so that the rhythm aligns with the poetic metre.

How to classify such works?

In the paper I proposed three main analytical criteria:

1. Programming language choice

High‑level languages (Python, PHP, Perl) — closer to humans, accessible to a wider audience.
Low‑level languages (assembly) — elitist, requiring deep expertise.
Dead languages (Pascal, Cobol) — like Latin poetry, archaic.

Example from a Stanford poetry slam (C++):

class For_every {
public:
  void ngular(){cout << endl << "I";};
  void que(){cout<<"f";};
  void ng(){cout<<"w";};
  void ghting(){cout << "d";};
  void ving(){cout << "e";};
  void on(){cout << " n";};
};

int main() {
  For_every i;
  i.ngular(); i.quet(); i.ng();
  i.ving(); i.ghting();
  i.vidual(); i.on();
}

Thanks to variable names (i, us) and method names, the sequence produces a phrase: "I fought we will surely seperately" — the theme of “I vs. we”.

2. Functional load

What does the program do? Even if pragmatically “useless”, the program’s intended behaviour matters.

Example: an infinite loop in C as a metaphor for addiction:

void addiction() {
  int mind = 1;
  while (true) {
    mind = mind + 1;
    if (mind < 0) break;
  }
}

An infinite loop is usually considered a bug, but here it becomes an artistic device.

3. Dependence on natural language

Can code poetry avoid relying on English? That’s the holy grail. Most authors use English words as variable names — e.g., an SQL query:

INSERT ‘your hand’ INTO ‘mine’
SELECT ‘restaurant’ FROM ‘nearby’
WHERE ‘you would’ LIKE ‘to date’;

This is essentially English wrapped in SQL syntax. But if one could express meaning purely through the programming language itself (without borrowed natural language) — that would be a new art form, understandable to any developer regardless of their mother tongue.

Not just “normal” languages

At the Code Poetry Slam (Stanford, 2013–2015), even non‑Turing‑complete languages like CSS or lists of HTTP status codes are accepted.

For example:

201 created
200 OK
100 continue
303 see other
302 found
409 conflict
403 forbidden
520 origin error
...

These are Apache web server response codes. But arranged like this, they evoke a lyrical mood — reminiscent of human life with its errors, redirects, and successes.

Or CSS:

.ocean {
  color: cornflowerblue;
  pitch: high;
  overflow: visible;
}
.boat {
  color: firebrick;
  transform: rotate(94deg);
  float: none;
}
.rescue-team {
  visibility: visible;
}

That’s already a narrative about a capsized boat and a rescue team.

What’s next?

I think this practice is more than a hype. Behind it are:

therapeutic relief (programmers unwind through creativity);
carnivalisation of professional language;
the search for new expressive means.

Of course, when the element of contrast wears off, the wave may subside. But for now, such texts keep appearing, and a subculture has already formed around them. Over time, researchers will amass a whole corpus of “poetic programs”.

Link to the full paper

If you want to dive deeper, here’s the PDF (in Russian, but with an English abstract and plenty of code examples):

🔗 https://nevmenandr.github.io/portfolio/assets/pdf/21.pdf

APA citation:

Orekhov, B. (2016). Stikhi v programmnom kode: sovremennyy opyt i metodika analiza [Poetry in program code: Contemporary experience and analysis methods]. Kritika i Semiotika, (2), 94–101. https://nevmenandr.github.io/portfolio/assets/pdf/21.pdf

BibTeX citation:

@article{Orekhov2015programmpoetry,
  title = {Стихи в программном коде: современный опыт и методика анализа},
  author = {Орехов, Борис},
  year = {2016},
  journal = {Критика и семиотика},
  number = {2},
  pages = {94--101},
  issn = {2307-1737},
  keywords = {poetry discourse, poetic text analysis, programming languages}
}

Let me know in the comments — have you ever tried writing “code poetry”? Or do you know other examples? 👨‍💻📜

Verse Markup Language (VML)

Boris Orekhov — Sun, 07 Jun 2026 04:02:53 +0000

Verse Markup Language (VML): When Poetry Meets Code

Have you ever tried to make a computer understand a poem? Not just find rhymes, but parse where the author is, where the title is, where the epigraph is, and where the actual verses are? If so, you know how quickly “plain text” becomes a headache.

I’m Boris Orekhov, and I created VML (Verse Markup Language) — a minimalist markup language that turns the chaos of poetic text into a machine-readable structure. And yes, it’s already working on real‑world corpora (e.g., the Bashkir Poetry Corpus with >10,000 poems).

A note on language: The full VML specification is written in Russian. However, given the current state of machine translation (DeepL, GPT-4, etc.), this is hardly a barrier. Anyone can obtain an accurate, readable English version in seconds. The tag names and syntax are language-agnostic anyway — <a>, <&>, <n> work the same in any idiom.

Why not TEI, JSON, or Markdown?

TEI – a beast. It can handle anything, but marking up a single poem feels like writing a new gospel in XML. Impossible for handling for humanists.
JSON – great for machines, but a humanist will close their laptop in horror.
Markdown – fine for documentation, but not for strict metadata markup.

VML is a text format that stays human‑readable and is easy to parse. Its tags are short (<a>, <&>, <n>, <rm>), the hierarchy is strict, and learning it takes 5 minutes.

Minimal example

<a> William Blake
<&> Tyger Tyger, burning bright,
In the forests of the night,
What immortal hand or eye,
Could frame thy fearful symmetry?

<a> – author (stays active until the next <a>)
<&> – the first line of the poem (incipit). Without it, the document is invalid.

From this you can already extract the author, the title (none here), the list of lines, and even count them.

Adding structure

<a> Emily Dickinson
<rm> Hope is the thing with feathers   <-- epigraph (prose insert)
<&> “Hope” is the thing with feathers -
That perches in the soul -
And sings the tune without the words -
And never stops - at all -
<*> And sweetest - in the Gale - is heard -
And sore must be the storm -
That could abash the little Bird
That kept so many warm -

<rm> – prose insert (epigraph, dedication, stage direction). Each line gets its own <rm>. Poetry parser skips it.
<*> – start of a stanza. Stanzas are separated by repeated <*>.

Poetry cycles

<nn> Sonnets to the Young Man
<n> Sonnet 1
<&> From fairest creatures we desire increase...
<n> Sonnet 2
<&> When forty winters shall beseige thy brow...
</nn>

<nn> ... </nn> – a cycle. Inside are several poems, each with its own title <n> and incipit <&>.

What if an epigraph appears before an incipit without a title?

Two poems in a row, and the second has an epigraph. How do you avoid attaching the epigraph to the first poem? VML provides <&&> – an explicit start of a new poem before an incipit:

<a> John Keats
<&> A thing of beauty is a joy for ever...
...
<&&>
<rm> Epigraph to “Ode to a Nightingale”
<rm> “Thou wast not born for death, immortal Bird!”
<&> My heart aches, and a drowsy numbness pains...

For the geeks: “ladder” layout

If you’re a verse scholar, you might need explicit “ladder” markup:

For example Mayakovsky:

<&> Я волком бы <l-2> выгрыз <l-3> бюрократизм.

Tools

The repository contains:

Validator (vml_validator.py) – checks syntax, nesting, escaping.
Counter (vml_counter.py) – outputs statistics: authors, poems, lines, cycles.

python3 vml_validator.py poem.vml
python3 vml_counter.py poem.vml

Where is it already used?

Bashkir Poetry Corpus (http://web-corpora.net/bashcorpus/) – more than 10,000 poems marked up in VML. Based on this corpus, a monograph (Orekhov, 2019) and several articles on quantitative verse studies have been published.

Who is it for?

Humanists who want to build their own corpus without learning XML/JSON.
Developers who need to extract metadata from poems for NLP tasks (author, date, metre, stanza structure).
Digital Humanities enthusiasts looking for a simple, open standard.

Biblio

Orekhov, B. V. (2019). Bashkirskiy stikh XX veka. Korpusnoye issledovaniye [Bashkir Verse of the 20th Century: A Corpus Study]. Saint Petersburg: Aleteya. 344 p. ISBN 978-5-907189-29-4. (In Russian)

P.S. What about escaping?

In real poems, sequences like <a> almost never appear as part of the text. But just in case, escaping exists: \<a> will be treated as plain <a> and won’t break the parser.

Discussion in the comments is welcome. Do you use any formats for poetry markup? Would you like to try VML? Feel free to open issues on GitHub – any feedback is valuable.

Boris Orekhov, 2026

Programming as text creation

Boris Orekhov — Thu, 20 Mar 2025 07:45:26 +0000

I am a philologist and I need to write texts: scientific papers, popularization articles. But sometimes I want to write code. I often treat code as natural language texts. Just as sometimes you want to try your hand at a new genre, you want to leave behind and offer the community code in a programming language that is not your primary language.

I used to write a lot in Perl, it was my second language, but now I've thoroughly forgotten it. However, for sentimental reasons I'd like to have Perl code in my github account, so I had to remember it.

I tried using ChatGPT to accomplish the task I wanted, but never got the results I wanted. I had to write code the old fashioned way and work out the rules of the language.

I plan to write some more applications (useful and just beautiful) in different programming languages in the near future and make them available to the public.