Failed Abstractions: Interfaces Gone Wild – A Series

Author: Asher Wolfstein

Published under the auspices of the University of Neo-Transylvania Experimental Research

This series will tackle a fundamental architectural challenge in modern computational systems theory: the accepted, and even expected phenomenon in which an artifact, model, interface, or machine functions as a surrogate for an entity located within a distinct semantic context, yet the justification for this authority is not intrinsic to the system itself, and instead the relation that warrants its authority remains external to the resulting system, is available only through auxiliary metadata or institutional knowledge, or is reduced to a set of distinctions insufficient for reproduction of the the subsequent process.

Surrogacy can take on various forms, such as being granted authority to represent, being assigned the role of standing in, being given the power to function as a proxy, being accredited to encode or embody, or being placed in charge of capturing the original construct.

The Meaning Of Translation

Throughout this series, translation refers to the utilitarian process by which heterogeneous, yet canonical representational descriptions are permitted to replace more granular and semantically distinct processes in a non-monotonic manner reminiscent of a menagerie. This may occur through representational conversion, semantic elaboration, operational substitution, approximation, resolution, projection, concealment, interpretation, or realization.

The reader will note that the title of this series concerns abstractions that “fail,” not that all abstractions “fail.”

In this intellectual vein, then, I’m not implying that every abstraction is defective. If that were the case, the proposed opportunities for accountable extension would also amount to failures. Abstractive techniques are the indispensable means by which software is made analyzable, portable, efficient, compositional, and all-around usable.

Abstractive techniques are indispensable in humans’ attempts to interface with their powerful machines, as computers exhibit greater accuracy in performing calculations than the human brain. It is thus only through abstractions that we can manipulate the computer to perform operations ranging from simple mathematics to complex algebra, and from low-level to high-level instructions. Primary among these mathematical abstractions are binary arithmetic, floating-point numbers, and logical algorithms.

And such abstraction continues beyond hardware implementations. Programming languages, compilers, and operating systems, all abstractions, enable the programmer to configure the computer with greater ease. Indeed, it is the programmer’s job to warp this computational tool so that far more complex algorithms and massive amounts of data can be processed beyond the constraints of the human brain.

With abstractions enabling programmers to encode imperatives of ever-expanding expression, cryptographic analysis, weather forecasting models, and quantum system simulation, each requiring extreme precision and speed, are within reach. Such speed, in particular, remains elusive to even the densest and wrinkliest of biological brains.

The issue at the core of this series is both particular and broad-ranging in scope: translation-based abstraction devalues meaning when the translation becomes an authoritative view, despite its support, losses, context, or effects no longer being represented with sufficient fidelity to justify the identity, equivalence, completeness, or illustrative power attributed to it.

This isn’t to say that the newly minted view isn’t useful, as it can greatly expand expressive power for the knowledgeable programmer. “Knowledgeable” here is the key, as the inverse is also true: when semantic context and domain are lost, the person studying the material—be it a student, a debugger, or an auditor—finds it increasingly difficult to pierce the opaque veil that the ‘lossy’ abstraction constructs.

As a result, understanding, verifying, or meaningfully interacting with the system becomes an arduous task for anyone lacking specialized, often tacit, knowledge of the original context.

The Meaning Of Semantic Context

Moreover, in this series, semantic context refers to the coherent domain of meaning or set of rules where the concepts, operations, and meanings are controlled, for instance, the differences between the implementation of forms seen by users and the internal memory structures that enable them. Even though similar, this specific usage is intentionally more inclusive than other common terms, such as semantic domain, used in denotational semantics to refer to the mathematical objects representing program meanings, or operational context, which emphasizes environmental and execution-specific conditions.

For example, in a typical compiler pipeline, the input Abstract Syntax Tree is embedded in the semantic context of user-facing constructs. In contrast, the generated Intermediate Representation is in the semantic context of target-execution primitives. The process of authorizing an Intermediate-Representation Node to represent a source-level expression depends not only on formal translation rules, but also on the logical negative space: which distinctions from the source context are preserved or flattened.

To wax philosophical, the ontological status of semantic contexts remains, to an extent, an open question:

• Are semantic contexts metaphysically real divisions? Are the coming Layers Of Abstraction unavoidable facts that exist apart from our intellectual understanding? Or,
• Are semantic contexts purely conceptual instruments, useful for organizing and reasoning about arbitrary systems?

My view, narrowed to computational architecture and software engineering in this context, rests on the utility of semantic contexts, which lies in their explanatory and organizational power. Any commitment to their fundamental metaphysical reality will produce very scant fruit by my estimation, so I do not do so.

By highlighting the idea of a semantic context, as I’ve done here, I will be able to unify situations in which meaning, rules, and the authority to represent are situated within the mind, but are not necessarily mathematically fixed.

In some sense, I’d call myself an instrumentalist philosopher who regards contexts as a practical structuring device for organizing stable patterns of meaning and authority in software, without treating their division as an objective reality.

Such an attitude toward the issue aligns with the approach to semantics and language used in David Bohm’s “The Rheomode” in his work Wholeness and the Implicate Order (1980), which is, unsurprisingly, one of my favorite books on this kind of thing. According to Bohm, distinctions that we observe in the physical world do not belong to the intrinsic nature of things but are projections of our mind, as determined by the language we use and the way we think.

For example, we might divide the planet’s population into “good people” and “bad people.” But then comes the necessary question of the metric being employed. Because any sense of value, as in the good or the bad, the positive or the negative, rests purely on conscious interpretation and not on any kind of intrinsic quality, it’s very easy to see that such a sweeping and binary division is one of pure personality bias. Empirically, we can see this within any political structure or argument that establishes the authority of “us versus them.”

In adopting an inclusive notion of semantic context, I mean that software systems may contain various domains or representations that appear to have strict boundaries, but even within a single layer they remain strongly interconnected. Just like in Bohm’s theory, any separation is just an abstract product of the human mind.

Although the mechanisms of institutions and conventions are frequently invoked when establishing authority in software systems, semantic legitimacy must ultimately be based on an objective agreement between behavior and the specification, on verifiable relationships between representations across different contexts, or on a translation’s justification terms that can be accessed by independent auditors.

Although unusual to include in such a series, this discussion overlaps with philosophical issues surrounding meaning and representation, such as those of reference and authority as raised by philosophers like Frege, Kripke, and Wittgenstein:

• The distinction that Frege drew between sense (Sinn) and reference (Bedeutung) laid the foundation for crucial insights about how language communicates meaning and refers to objects in reality.
• Kripke’s theory of reference, based on causation, criticized descriptive approaches by emphasizing the historical and social links between words and their referents.
• Wittgenstein, particularly in his later works, stressed the use and practice of language games when discussing issues of meaning, which  exemplify the role of usage and convention in questions of semantic legitimacy.

My series draws on the distinction between conventional and objective accounts of meaning. I hope to engage with analytic philosophical claims regarding semantic externalism and the justification of representational claims through concrete examples from software engineering, but we’ll see if that pans out.

Semantic externalism, developed by Hilary Putnam and Tyler Burge, holds that the meaning of an expression is determined not only by the internal states and conventions of the agent or system but also by external factors, such as the environment and linguistic community. The issue here is how the semantic authority in representation may be justified:

Does a computer model or abstraction become an authority because of its conventionality, or ought it to be based on some objective relationship with what it represents?

The analysis throughout this series aims to clarify not only how authority is conferred, whether by institutional practices, technical conventions, or formal mappings, but also the principled basis on which such authority can be justified. This becomes an ethical question when one considers the way computational machines and their operating software interact with the world and society at large.

In regard to engineering, there are concrete consequences of such a stance. First of all, it means that designers have to see these semantic contexts as actual tools for delineating interfaces, clarifying their borders, and reasoning about system behavior, rather than as unavoidable background assumptions of ontological categories. By focusing on the organizational roles in these contexts, engineers can adopt flexible abstractions tailored to the needs of different domains, document how authority and responsibility are allocated, and make boundaries between representations more transparent and accessible.

I argue that the proposed perspective ought to influence how decisions are made regarding the formalization of translation relations, the maintenance of certain distinctions, and the justification of the reliability of abstract objects for maintenance.

The primary objective of my approach is to avoid basing claims of representation on convention or convenience and instead to ground such claims in objective relations of representation, and that this process is the ethical choice.

In software development, such an approach involves clearly defining relationships between abstract concepts and their concrete instantiations, mapping user-visible concepts to their implementations, and, hopefully, empirically demonstrating the behavior of a particular computational system. By grounding representational authority in objective criteria, such as transparency, accountability, and testability, the series advocates for a more robust and principled approach to meaning in computational systems.

I believe that this approach, which I outline below, is sensitive to both philosophical insight and engineering practice.

Bottom-Driven Semantic Monotonicity

The alternative framework advanced throughout this series is Bottom-Driven Semantic Monotonicity.

The central claim of the framework lies in the observation that the basic principle underlying abstraction is not the transformation of the referent into an easily understandable form for cognition but rather differentiation and integration: the discovery of commensurable units, the exclusion of their differential measures, and the retention of their identities as the objective basis for the concept, which is made possible by their economy.

This elegant explanation of abstraction makes it possible to construct an enhanced framework of integration without substitution: the larger expanse of reason introduces a new way of understanding the differentiated objects while retaining their identities, operative relations, and the evidential path by which they give the abstraction its meaning.

The solution proposed here is Bottom-Driven Semantic Monotonicity: a framework that eliminates translation boundaries through enforcement of all higher-level semantics emerging exclusively as consistent extensions of a single, fixed Submachine. In this system of thought and engineering practice, every construct—syntactic, semantic, or domain-level—must obey the binding constraints imposed by the substrate’s operational identity. I refer to this principle of restraint as the Dominance Condition of the Submachine.

It may very well be possible that, regarding the base machine as the standard of truth, not the subject of reinterpretation, an entirely new class of computational systems becomes possible: transparent, honest, and coherent by construction.

However, I must temper such back-of-the-book, blurb-like optimism and advise the reader to take in such vistas with due diligence, however exciting they may be. I’d much rather a future advocate travel towards the near-unseen frontier rather than teleport into the sim naked.

To elaborate:

The lower machine, the Submachine, is characterized by its Dominance Condition, which states that any dominating construction must be an accountable extension of its specific Submachine: it must preserve the relevant inherited identities and behaviors.

Imagine a software stack that runs all the way down to the machine’s inner hardware. Each layer ideally represents an increase in abstraction, reducing complexity for the end user. When the user clicks a button on a program, the computer’s peripheral device sends a signal to the components responsible for handling that input. This signal is passed between various layers, each interpreting and reinterpreting it at increasingly abstract levels of context (and, consequently, more referential machine instructions) as the device works to produce a human-understandable outcome.

A concrete visualization focusing on pure implementation might put such an instance as:

mouse → peripheral device → processor → machine code ( ← compilation ← source code ) → script, maybe (e.g. Python) → graphical device → on-screen output

You can see in this sequence that there is a sidecar process where it’s most likely (in most examples) where a programmer came in at some point and compiled a sequence of source code written in a high-level language into an executable artifact. This sidecar is exemplary in illustrating the obscurantism of the current stack: the executable artifact alone does not convey the original source code to the auditing user.

To introduce the concept, I have so far utilized the terms “higher” and “lower”; however, they are not my preferred descriptors. I prefer the terms “dominant” and “sub-”.

You might have noticed some blurring between a “layer” in a software stack and actual machines. This is due to my preference for using the term “machine” rather than “layer.”

I’ve discovered these preferences produce a shorter learning curve and a greater ease of use when formalizing the model in mathematical terms. A consequence of this is the use of the terms Dominant Machine and Submachine when talking about “higher-” and “lower layers.”

And there are reasons for these preferences, the primary being that I’m not describing a “software stack.” As will become clearer as we go, if the Foundational Substrate (Submachine 0) closely corresponds to the hardware of a particular host, then what I’m actually describing is an operational “tower” of increasingly abstract machines.

If each Dominant Machine serves as a monotonic extension of a Submachine by virtue of its Dominance Condition, then it follows that each Dominant is also a Machine. The only difference between the two is in the organization or perspective of the Dominant towards the Submachine, otherwise referred to as its Projection.

Using the terms “stack,” “layer,” “higher,” and “lower” may predispose the reader to bring the baggage of those terms as their carry-on for the journey through the shortcomings of common abstractions, and I want to avoid the confusions that would come with that.

For nearly a century, the practice of computer science has tolerated a non-obvious blind spot: the belief that proper abstraction reduces cognitive load, and that this reduction can only be done through translation.

Higher-level languages are lowered into intermediate forms, then again into bytecode, and finally into machine instructions that bear little resemblance to the conceptual models they are meant to implement. This is treated as an unavoidable sacrifice, and understandably so, since the machines that perform the computations bear little resemblance to our own methods of problem-solving.

That is to say that computers can’t, and don’t, ‘understand’ what they’re ‘doing’ so much as we’ve assigned meanings to bits, then bytes, then sequences of bytes, and so on. Getting results from these computational machines requires massive layers of abstraction itself.

Absent the proper care, which is again understandable, every layer of this stack becomes a point of fragile contention because every act of translation is a cognitive surgical amputation. Meaning becomes dispersed through the layers, each with its own (entirely different) take on the same process, and the only hope of discovering its integrity is found in enigmatically advanced tool chains.

This series is my introduction to rejecting that entire edifice.

In my intellectual travels, I have found little pushback to the acceptance of this situation. I myself fell victim to the notion that assembly programming was a “black art” mastered only by accomplished career programmers, hardware engineers, and university researchers, and this was because the layer on top of it, being the compiler, seemed near-obscurantist by nature.

But having learned more about machine code, compilers, interpreters, and parsers through a gradual process of tail-bound osmosis, as one does, I came to realize that it need not be like this. All that’s needed is some careful discernment and a willingness to question “what already works.”

The basis of my proposed interpretive system and engineering framework, Bottom-Drive Semantic Monotonicity, is simple: a system can never generate clarity when clarity itself isn’t the primary concern in its construction.

And the fact is, development of a semantic model based on the concept of translation implies that what is true must be distorted to be usable, a phrase reminiscent of a famous interpretation of Kant that reads, “one perceives by misperceiving.” Such a semantic model is the epistemological stance of someone who believes their own mind cannot be trusted until a committee of tools has certified it.

I am not interested in such systems.

Instead of constructing abstractions above the machine and coercing them downward through compilation, we construct abstractions within the machine and allow them to proliferate upward without disconnecting from their origin. In this framework, Dominating semantics are restrained by the simple and absolute Dominance Condition of the Submachine. That is to say, they must remain consistent with the Submachine’s behavior. Nothing built on top may contradict what lies beneath, while nothing emergent may escape the binding constraints of the Foundational Substrate.

The result is a control system in which abstractions may freely enlarge themselves provided they never violate the Dominance Condition produced by the Submachine’s own Operator Blindness.

This metaphorical blindness towards the Dominant’s operation is not an unfortunate defect or necessary evil, but a design condition: the Submachine need not understand what the Dominant Machines are doing; it only need enforce consistency on every procedure they undertake.

This causes meaning to flow upward through the tower, rather than downward, because authority is now positioned at the foundation rather than being composed of the whims of the end-user. The illusion of independence and autonomy that programmers enjoy now will persist only because the Submachine 0 permits it behind its blindfold.

From a personal point of view, I must admit that this framework wasn’t developed entirely out of academic interest. Instead, it arose from the way modern computation spreads responsibility among a wide variety of architectures, compilers, interpreters, and parsers, each dealing with a kind of circus-like collection of issues that, in my opinion, all belonged to a single entity. The result? My frustration at learning it.

But which entity, and why not address that one?

In the traditional set-up, abstraction becomes a trapeze-like evasive maneuver, and translation a ritual sacrifice towards clarity. But philosophically, this style of abstraction (like many) has left much to be desired. I would rather my systems remain clean, rational, and answerable to their own premises. If an abstraction is worth having, it should not require a distortion to sustain it.

The framework presented here is my attempt at eliminating this distortion.

By enforcing a monotonic relationship between layers, one where each new semantic domain must be a faithful extension of the machine beneath it, we are able to dissolve the compiler stack entirely. Parsing ceases to be an external algorithm and becomes a native expression of machine behavior. Abstract syntax trees become machine states, not products. Language constructs are no longer interpreted; they are machine configurations. Execution is no longer a separate phase but a direct traversal of the same continuous semantic structure.

In short, we replace translation with emergence.

At least, that’s the idea. We’ll see if that pans out, as I’m still working on it. This is simply the first draft I’m willing to share publicly.

More fundamentally, the proposal rests on the epistemic principle that semantic authority should be grounded in objectively specifiable relations, such as verifiable mappings and explicit projection obligations, rather than merely in accepted practice or institutional convention. This Dominance Condition aligns with, but is more demanding than, justification models in verification systems, requiring demonstrable and independently checkable correspondence across semantic contexts.

A Dominant’s semantic account is not assumed to have privilege to become authoritative merely because it creates an orderly organization as it might in other frameworks.

It must earn the right to be obeyed by exposing a clear correspondence between the Dominant Machine and the Submachines found beneath it, assuring that claims about identity, behavior, and meaning rest on demonstrable relations rather than convention or the programmer’s unspoken needs.

I must note, in all fairness, that the above provenance elements are not free: in high-performance environments, latency and resource constraints are often extremely tight, so much so that maintaining explicit mappings and provenance may be an overhead that outweighs the benefits of increased accountability.

Likewise, in simple systems where abstractions are minimal, and authority chains are trivially preserved, such rigorous tracking may be unnecessary or redundant.

These two concerns, however, fail to apply the framework and practice to the appropriate processes. Production code that doesn’t require the type of introspection that Bottom-Driven Semantic Monotonicity provides can opt to run “in production,” and eliminate the cruft that remains incredibly useful for development. And executables that do require this introspection may slice and dice minimal triggers that maintain a minimum of symbolic tags.

This series will look at the main forms through which traditional abstractions pass semantic authority from one representation, interpretation, or machine to another, and it will show how such transfers are able to conceal the evidence that supports them, place the obligation for their preservation onto external parties, and break the continuity of identity and action across the various computational layers.

It is my intention to examine various concepts, including parsing, compiling, and optimizing, as well as denotational semantics, runtime mediation, application programming interfaces (gone wild!), and serialization… hopefully, it’s all very tentative.

My plan is to construct an analysis of the circumstances under which traditional abstraction leads to semantic fragmentation, thus specifying the architectural mistakes Bottom-Driven Semantic Monotonicity aims to fix without risk.

The Series As Tentatively Planned

1. Translation as a Transfer of Semantic Authority will define the three principal families of translation, establish the epistemological question of grounding, describe the conventional pipeline of authorities, and introduce the failure modes that will be investigated throughout the series.
2. Source-to-Source Translation and Desugaring will consider the connection between surface forms, core languages, expansions, generated identities, and source explanations.
3. Parsing as Artifact Production will analyze the ways in which source evidence becomes lexical and syntactic authority, especially in regard to ambiguity, recovery, rejected possibilities, and the link between admission and execution.
4. Compilation and Lowering will examine the preservation claims that describe the implementation of high-level operations in terms of low-level instructions, which may differ in cost, failure, and observation from those at the source level.
5. Intermediate-Representation Staging will study the succession of compiler representations, their local invariants, and the conditions under which several useful views can remain accounts of one artifact rather than become unrelated program identities.
6. Optimization and Program Rewriting will examine the context-based notion of equivalence and how an optimized plan may overwrite itself and the observational constraints that originally led to it.
7. Bytecode and Virtual-Machine Abstraction will treat the virtual machine as an operational jurisdiction whose portability and managed services require an explicit relation to physical execution.
8. Interpretation and Runtime Mediation will make evaluation state, dispatch, allocation, exceptions, scheduling, and other apparently automatic runtime effects part of the semantic account.
9. Just-in-Time Rewriting and Profile-Guided Specialization will follow assumptions, profiles, generated variants, invalidation, and deoptimization through a machine whose active implementation changes during execution.
10. Linking, Loading, and Late Binding will examine the environmental facts and resolution policies through which symbolic names acquire operative providers.
11. Abstract-Machine Substitution will consider the relation between a formally convenient operational model and the concrete or virtual machine that realizes it.
12. Denotational Mapping will consider the mathematics of meaning as a semantic description which may be warranted without being exhaustively identical with execution.
13. Abstract Interpretation and Approximation will distinguish legitimate loss under a stated approximation contract from the later denial of distinctions the analysis deliberately omitted.
14. Refinement from Specification to Implementation will ask how top-down correctness relations can be responsive to material conditions that are absent from the authoritative specification.
15. Meta-Circular Interpretation, Self-Hosting, and Language Stacks will evaluate reflective systems whose explanatory reach may remain enclosed above the substrate that enables them.
16. Encapsulation, APIs, and Information Hiding will distinguish limited access from the obfuscation of accountability, while retaining the requirements of privacy and capability.
17. Serialization, Protocols, and Normalization will follow the identity, aliasing, ordering, provenance, and context through encoding and decoding across storage or network boundaries.
18. And lastly, From Failed Abstractions to Accountable Extension will compare these methods across common dimensions, state the formal contrast, work through one expression under both architectures, consider costs and limitations, and present a reusable audit for abstraction boundaries.

About The Series As A Series

I hope that the essays will be arranged in such a way that the earlier section on the computational pipeline provides examples for the later ones which deal with formal and institutional issues, while each essay focused on a particular method will establish its own terminology and be capable of being read on its own.

Assertions regarding established techniques are made in a cautious manner, whereas the suggested monotonic reformulations are treated as engineering hypotheses. This analysis is carried out without regard to traditional organizations, and the views set out here represent a principled and independent position rather than being in line with any specific institutional authority.

Hope This Tickles Your Brain!

This is a concept that I’ve been developing for the last 10 months in private, off the Internet. This has unfortunately been to my detriment because there are individuals who believe they have the authority to judge my life based entirely on what is and isn’t put on the Internet. And, unsurprisingly, it’s an untenable situation in terms of ‘doing it right,’ as it’s meant to be, in my opinion:

• If I put everything up, I’m “violating my own privacy” (I shit you not) and inviting everyone in the world to abuse me as I moronically “take the bait.”
• If I put very little to nothing up except what I feel necessary and driven to put up due to outside influences, then it’s proof that I’m obsessed with those outside influences, have no friends, don’t touch grass, and am a manchild “ruunnning back to” Christ; I can’t do it.

The reality is somewhere in the middle and frankly, not that interesting, as it always is. You’ve seen pretty much every thought I’ve had over the situation I’ve found myself thrust into without my consent for the last 19 months because I’ve posted it, sans the “final analysis.” And there’ll be one, but not today.

Liana Kerzner likes to imagine other people’s lives as revolving entirely around her. If she pays my husband to work on her computer game, well, then he mustn’t spend evening time with his own husband discussing the “spouse of a team member’s” own computer creation, because, I guess, she owns every minute of his existence.

Really beating that rap there.

If I’m posting criticisms, mockery, anger, and frustration, then that must be the only focus of my life to the detriment of everything else.

Well, with this hospitalization, I will admit, and have already, that there was an element of obsessive worry and engagement, one that I propose Kerzner intentionally exacerbated for content. I notice her latest drama hooks are more centered on old stalker(s) than on new ones, frankly. And, like I’ve always written, I speculate it’s because that one’s safe.

Note that I’m not admitting I’m a stalker here; I’m simply using Liana’s terminology when describing very mundane and normal adult conflicts with non-conflict-averse individuals who proactively maintain their rights.

I’m not safe. (As in, Liana Kerzner doesn’t find my discourse to be ‘safe’ by her standards, not that I nEeD a WeLfArE cHeCk L I A N A…)

*sigh*

The truth is I’ve been working on a number of things for the past 10, shit, more than 10 months; *counts on fingers* come to think of it, I’m not sure how many months, I just got used to writing 10.

The data will eventually tell me.

Those things include:

• Finishing the TRS-80 Color Computer I/II/III emulator that I was implementing in Godot using Godot Rust.
• This concept of Bottom-Driven Semantic Monotonicity.
• Concepts beyond this one that entail more implementation, such as
  • The Semantic Function framework, which leads into
  • Dynamic Resolution (it’s a special form, hence the capitalization),
  • “Parserless” parsing systems that enable more universal contextual grammars,
  • “Traverseless” database systems, and even
  • Compression and decompression techniques based on a wildly different take regarding how one might interpret stored data (at least that I know of),
  • and more.

I actually have a life outside of social media and the Internet.

In fact, I’ve pretty much ceased traditional social media engagement for now, and I most likely will not be starting back up again. I’m glad to kiss Twitter/X goodbye forever for finally becoming the cesspool it always kinda was. And I’m happy enough to bid BlueSky et al. adieu because their moderation policies and system actually help abusers rather than hinder them.

It’s just that my life is targeted fairly inward as I have a robust and extensive ‘inner world’ of thoughts, concepts, memories, emotions, and projects that I constantly draw upon.

I mean, all of that up there? That’s all my “head work,” as in, a lot just sits in my head until I barf it out, which, here you go! There’s also “computer work” where I implement things, including a “parser-based” game engine (未惑Engine), a deterministic machine-learning prototype, and some website stuff, all of which I’m still working on… in private, for now.

I dislike the idea of having to develop everything “in public,” in front of a camera, posting tenuous updates every week or every couple of days, because I have no idea what I’m going to be doing at any given time.

That last phenomenon is partially why I wasn’t on the development team, or even a silent collaborator for BOSSFIGHT: Song of Sparklemuffin. That’s really not just one fag in a “pack of lies,” as Kerzner might put it (sans the fag part, that’s too clutches pearls for her apparently). Her lawyer told me so, and you can find more evidence supporting me at BossFightGame.com.

Me: Look at all this evidence and consistency!

Liana: If I say it’s lies, it’s lies okaay, it’s not in my nature to lie so it’s the truth, trust me bro…

Truly ridiculous person.

Too much evidence is a sign we planned it; too little evidence is a sign we have nothing and are all bluster, just like not posting anything else is a sign of a self-loathing “broken nobody” (Audrey) obsession, but posting nothing is a sign of not having a life or friends, despite not everything being on the Internet… but posting too much is setting myself up to have everyone up in my business as I “violate my own privacy,” which I refer to as “choosing to disclose,” like Kerzner does, every fucking week, about five times a week.

Truly ridiculous, and frankly, not worth much of my time anymore.

I think she’s sore about that.

I can see it in her eyes, as they allow me to look into the mind of my hater and…

*SLAP*

Oh, fuck, sorry.

*shakes head*

Forgot who I was there for a second and thought I could actually be as great and insightful as the award-winning Liana Kerzner.

Liana, you have to be talking about Emily Schooley because I ain’t gonna write to your nobody organization I’ve never heard of in who-knows-where Canada. You got a stupid fundraising award, yay. I’ve gotten awards too, but we all know they’re fake, right?

The point of this dripping sarcasm is to illustrate that Liana Kerzner still thinks she’s the center of our world.

I suppose “it’s a good thing” when the broken nobodies of the world accept their lot.

This is all to say that there is no fixed timetable for this series; each essay will appear when I have had the time and clarity to develop its argument properly, although I am genuinely excited to continue the work.

I also want to be candid that sustaining a project of this scope can be difficult when both the writing and its author feel buried and obscure.

If you find the project worthwhile and would like to encourage its continuation, a donation through Ko-fi would provide practical support as well as the welcome knowledge that the work has reached someone, and that encouragement would make a meaningful difference to my motivation as I develop the remaining posts.