User:I am islptng/On PSTF's Plagiarism

This is a personal record by User:I am islptng based on publicly available diffs and design documents. It is not intended to harass, but to document the origin of specific syntax elements.

The Inspiration Theft: How PSTF Turned My SLet into Frankenstein's Monster

By islptng (9th grade, language designer) With the help of AI, but all referenced pages are public and timestamped

Introduction

This document compares three languages – my SLet 3.0, PSTF's Mutzerium, and PSTF's Septem Lingua – and documents clear structural similarities that go beyond coincidence or general inspiration. I also include a brief observation about a personal announcement that was closely mimicked.

My goal is not to destroy anyone's reputation, but to: - Clarify the origin of several unique command names and syntax choices. - Show how they were adopted without proper attribution or understanding. - Suggest a constructive path forward for anyone who genuinely wants to learn language design.

A note upfront: Copying someone else's distinctive syntax without attribution is not "inspiration" – it is, at best, careless borrowing, and at worst, a form of plagiarism. This document aims to expose the pattern, not the person.

Part I: Mutzerium – Structural Similarities with SLet 3.0

Mutzerium's command set and data types show a very close resemblance to SLet 3.0. Below is a side‑by‑side comparison.

1. Core Commands

SLet 3.0 vs Mutzerium

SLet 3.0 (mine)	Mutzerium (PSTF)	Notes
former – numerator of fraction, first of pair	former – same	Identical name and semantics
latter – denominator, second of pair	latter – same	Identical name and semantics
swap – reciprocal of number, swap pair elements	swap – same, plus “swap poles in tuple”	Same core, extended to a different data type
opposite – negate number, not boolean	opposite – same	Identical name and semantics
add, or, multiply, and	Same, with infix aliases +, |, *, &	Prefix commands copied, infix forms added later
divide, floordiv, modulo, range	Same, with //, %, etc.	Direct parallel
filtrate – filter set by condition	Same	Identical name and semantics
size – length of set/string	Same	Identical name and semantics

The names former and latter are not common in programming – most languages use first/second, head/tail, or car/cdr. Their presence in Mutzerium, with identical semantics, suggests direct adoption from SLet 3.0 rather than independent design. This is not a case of convergent evolution; it is reuse without credit.

2. Misapplication of Core Abstractions

In SLet 3.0, former and latter are defined for pairs – a fundamental 2‑element structure. I designed pairs because sets are unordered, and I needed an ordered way to build lists; a pair is the simplest ordered container.

In Mutzerium, PSTF introduces tuples (arbitrary‑length sequences) and then uses former/latter to refer to the first and last elements of a tuple. This is semantically inconsistent: a tuple of 5 elements does not have a clear "former" and "latter" in the same sense as a pair. Similarly, swap is described as swapping "the two pole objects in tuple A" – a phrase that has no clear meaning for tuples longer than 2.

This suggests that the commands were adopted without understanding the underlying rationale. The result is confusion rather than clarity – a direct consequence of copying without comprehension.

3. A Misplaced Joke: str(Infinity) vs. str(undefined)

In our joint project GaoErFu (where I contributed the majority of the design and implementation), I defined:

• str(NaN) → "0/0" – a rational representation of an undefined numeric result.
• str(Infinity) → "1/0" – division by zero yields infinity.
• str(undefined) → the full lyrics of “99 Bottles of Beer on the Wall” – a humorous nod to infinite recursion when referencing an undefined variable.

In Mutzerium, PSTF wrote:

• str(NaN) → "" (empty string – no clear rationale)
• str(Infinity) → "99 bottles of beer"

The beer joke was attached to the wrong constant. This is not a critical technical error, but it shows carelessness in adopting even non‑essential features – he copied a joke without remembering where it came from or what it meant.

4. Redundant Infix Aliases and Fluff

SLet 3.0 was deliberately prefix‑only: add x y, divide x y. This was a conscious choice for consistency and simplicity.

Mutzerium adds infix aliases (+, -, *, /, etc.) alongside the prefix commands. This creates redundancy and increases the learning curve without adding semantic value. It also adds commands like goodbye and pass, which are essentially joke commands – despite PSTF's own rule (in Septem Lingua) that joke commands are prohibited. This undermines the credibility of his language designs: they appear bloated and inconsistent.

5. Implementation Status

My SLet 3.0 has a working 407‑line Python interpreter. My later language SletScript, which I spent over a year developing through 3 major version iterations, 5 algorithmic rewrites, and 6 months of debugging, is a 1500‑line working implementation. Both actually run.

As of the time of this writing, Mutzerium has no known interpreter. Its page lists a "To Do" section that includes implementing Brainfuck and Conway's Game of Life – but none of these have been completed. This pattern (paper specifications without working code) is consistent across several of PSTF's language designs. It is easy to copy a spec; it is hard to build a working system.

Part II: Septem Lingua – Syntax Adoption from My Other Work

Septem Lingua is PSTF's language built around the theme of "7". Two of its syntactic features closely match my earlier designs.

1. The <- Assignment Operator

I proposed <- as an assignment operator in an earlier idea (separate from SLet). The rationale was: - The arrow visually represents data flow from right to left. - By using <- for assignment, the = symbol is freed for equality comparison – a clean separation of roles (as seen in R, Pascal, etc.).

Septem Lingua adopts <- for assignment but retains == for equality. As a result, = is unused, and both assignment and comparison require two‑character operators. The semantic rationale behind <- – freeing = – was not carried over, making the adoption superficial. This is a missed opportunity: he got the symbol but not the philosophy.

2. The [} {] Comment Syntax

In my language SletScript, I had already used all conventional bracket pairs ((), [], {}) for other syntactic purposes. Lacking any unused symmetrical delimiter, I improvised with [} {] – a mismatched pair that, as a whole, is mirror‑symmetric. It was a forced solution.

Septem Lingua uses the exact same [} {] syntax for block comments. Unlike SletScript, Septem Lingua has several unused symbol combinations available (e.g., #| |#, /* */). The adoption of this specific, unconventional syntax appears to be a direct reference to SletScript, but without explicit credit to SletScript itself. My name appears in the Septem Lingua development team list, but with the note "In time-space travel, unable to participate" – a phrase I originally used myself, but which sidelines me as an inactive contributor. Using my unique syntax without proper attribution is misleading to readers who may assume it originated with him.

3. Forced "7" Patterns

Septem Lingua's entire design is structured around the number 7 (7 rules, 7 commands, 7 operators, 7 libraries, etc.). While this is a stylistic choice, it has led to redundant distinctions – for example, both != and <> are defined as separate operators, despite being mathematically equivalent. This appears to be driven more by numerology than by practical language design. It adds complexity without benefit, and it dilutes the language's usability.

Appendix: A Curious Parallel in Personal Announcements

This is a minor observation, not a core part of the above evidence.

In September 2026, I posted a notice on my user page:

<big><big><big><big>'''Important!'''</big><br>
As I have already become a Grade 9 student since September, I'm not so active as before, both on conwaylife.com and esolangs.org.
</big><br><br></big></big>

Shortly afterward, PSTF posted a nearly identical message on his own user page (since reverted):

<big><big><big><big><strong>Since I'm now in Grade VII, I'll be less active than before. I'll be active on every weekend.</strong></big></big></big></big>

The structure, formatting, and phrasing are strikingly similar, with only the grade number and a weekend note changed. While this does not affect the technical claims above, it suggests a broader pattern of copying beyond language design – even personal life updates are not immune.

Conclusion: A Call for Proper Attribution and Implementation

PSTF's languages show clear structural and syntactic parallels to my earlier work, particularly SLet 3.0 and SletScript. The core commands (former, latter, swap, opposite, filtrate) are not generic enough to appear by coincidence. The <- operator and the unconventional [} {] comment syntax are also strong indicators of direct inspiration.

Copying without proper attribution is not acceptable. It misleads the community about the origin of these features, and it devalues the work of the original creator. However, I do not believe this is malicious. It appears to be enthusiasm without enough technical depth to implement independently. PSTF is young (currently in Grade 7) and clearly passionate about language design. The best way forward is not to attack, but to encourage him to:

1. Write an interpreter for his languages – even a simple one – before publishing further specifications. 2. Explicitly credit the sources he draws inspiration from, rather than burying them in a footnote or omitting them entirely. 3. Understand the "why" behind each command – not just copy the "what" – so that his designs can evolve meaningfully.

I am open to discussing these issues directly. My own work (SLet, SletScript, etc.) is publicly available, and I am happy to explain the reasoning behind any design choice. I would rather see PSTF become a competent language designer than continue to produce paper‑only languages that borrow heavily without proper understanding.

To PSTF: If you are reading this, know that I am not your enemy. I am someone who has walked the path you're trying to walk. I invite you to start from the bottom – write a parser, write a VM, and then we can talk about "inspiration" on equal footing. Until then, please add clear attribution where it is due, and consider implementing one of your designs before announcing the next one.

---