The Law Banning Foreign Words... in Software Development

Apologies and Acknowledgments

The limits of my language mean the limits of my world. — foreign agent Ludwig Wittgenstein.

I offer unobfuscated — I beg your pardon, unmasked — apologies to the Thought Police for once having the audacity to publish the article "An Appeal to Publishers: Please Don't Translate Technical Terms."

I also want to express gratitude to the defenders of the Russian language for resolving issues head-on. Just like with Max — I beg your pardon, "Maks" — instead of winning through competition, as everyone including China has done, they simply ban and throttle everything.

Terms — Codewords

Primitives

Boolean — logical.
Short — shorty.
Integer — whole.
Long — lengthy.
Float — floaty.
Double — doubled.

var xyz = 666L;
double fz168 = -100.0;
var progress = xyz * fz168;

The Java compiler can infer that xyz is a lengthy. And the Java Virtual Machine will perform numeric promotion, setting progress to the same type as fz168.

Functional Operators

Map — associate.
Reduce — shrivel.
Fold — unfold, accordingly, Folder — folding-bed.
Debounce — cancel-the-bouncing.
Zip — zipper.

// reactive changes, just like the life of a Russian citizen
import io.reactivex.rxjava3.core.Observable
import java.util.concurrent.TimeUnit
import kotlin.math.max

data class Strike(val title: String, val loss: Int)

/** how much harder/softer the next strike hits */
data class Context(val title: String, val multiplier: Double)

fun main() {
    val strikes: Observable<Strike> = Observable.just(
        Strike("Inflation", loss = 20),
        Strike("Blocking/restricting access to platforms", loss = 30),
        Strike("Loss of built-up audience (TG/Instagram)", loss = 25),
        Strike("No vacancies at foreign companies", loss = 30),
        Strike("New regulatory requirements (e.g., Law 168-FZ)", loss = 25)
    )
    .zipWith(Observable.interval(0, 90, TimeUnit.MILLISECONDS)) { u, _ -> u }

    val contextNoise: Observable<Context> =
        Observable.just(
            Context("Transitional noise: open then closed", 1.0),
            Context("Stabilization: clearer how to live", 0.85),
            Context("New wave of restrictions/risks", 1.15),
            Context("Settled down again", 0.9)
        )
        .zipWith(Observable.interval(0, 200, TimeUnit.MILLISECONDS)) { k, _ -> k }

    val stableContext = contextNoise.debounce(120, TimeUnit.MILLISECONDS)

    val strikeInContext = Observable.zip(strikes, stableContext) { u, k -> u to k }

    val start = 100
    val remaining = strikeInContext.map { (u, k) ->
        val realLoss = (u.loss * k.multiplier).toInt()
        u.title to realLoss
    }.reduce(start) { acc, (_, loss) ->
        max(0, acc - loss)
    }

    remaining.subscribe { println("Result: remaining opportunities: $it") }

    Thread.sleep(2000)
}

GIT — Government Instrument of Labor

Pull Request — infusion request.
Merge Conflicts — flush conflicts.
Commit — deposit.
Git status — front-line briefing.
Git clone — GIT reproduction.
branch — twig.
origin — motherland.
master — overlord.

Examples of conversations with colleagues:

— I'll step out to take a leak, then I'll pour in the infusion request.
— Do the reproduction, branch your twigs from the motherland overlord.

Development Management

Feature — whim.
Framework — skeleton.
API — OMG (Official Messaging Gazette).
Cache — granary.
Roadmap — map of the unattainable.
Sprint — dash.
Release — admission to the people.
Rate Limit — the limit of politeness.

A Call Not to Sit Idle

We cannot sit idle! I call upon everyone who cares about the linguistic future of Russian software development to join the work on the open-source dictionary — KODOCLOBb!