JaiPLC.txt

Jai Checklist
by Colin McMillen, Jason Reed, and Elly Fong-Jones, 2011-10-10
updated by BoppreH, 2024-01-24

You appear to be advocating a new:
[ ] functional  [X] imperative  [X] object-oriented  [ ] stack-based  [X] concurrent
[ ] interpreted  [X] compiled  [ ] JIT  [ ] cloud  [ ] AI  [ ] beginner-friendly
[ ] academic-friendly  [ ] visual  [ ] sharable  [ ] esoteric
[ ] memory safe  [X] memory unsafe  [ ] provable  [ ] Turing-incomplete
[X] statically-typed  [ ] dynamically-typed  [ ] completely incomprehensible
programming language. Your language will not work, and here's why:

You appear to believe that:
[X] Syntax is what makes programming difficult
[ ] Performance is:
    [ ] not relevant anymore  [X] worth any and all sacrifices
    [X] independent from language design
[ ] AI-generated code is generally correct  [ ] and won't create legal issues
[X] A Turing-complete type system is a benefit
[X] Developers don't make mistakes and guessing intent is a good strategy
[X] Nobody really needs:
    [ ] concurrency  [ ] a REPL  [ ] debugger support  [ ] IDE support  [X] I/O
    [X] determinism  [ ] compile-time analysis  [X] joy in their lives
    [X] to interact with code not written in your language
[X] Scaling up to large software projects will be easy
[X] Convincing programmers to adopt a new language will be easy
[X] Convincing programmers to adopt a language-specific IDE will be easy
[X] Programmers love writing lots of boilerplate
[X] Specifying behaviors as "undefined" means that programmers won't rely on them
[X] "Spooky action at a distance" makes programming more fun
[X] The primary objective of a programming language is writing compilers

Unfortunately, your language (has/lacks):
[ ] comprehensible syntax  [ ] significant whitespace  [has] macros  [lacks] memory safety
[lacks] pattern matching/destructuring  [ ] string templates  [ ] assignment expressions
[ ] infix operators  [ ] nested comments  [ ] multi-line strings  [ ] regexes
[ ] pipelining  [ ] variable shadowing  [ ] emoji names  [ ] immutable data structures
[ ] implicit type conversion  [has] explicit casting  [lacks] type inference
[lacks] async  [lacks] exceptions  [lacks] ergonomic error values  [lacks] closures  [lacks] objects
[ ] reflection  [ ] multiple inheritance  [ ] operator overloading  [lacks] coroutines
[has] goto  [ ] comefrom, but unironically  [ ] DSL's  [has] effect system
[ ] algebraic datatypes  [ ] recursive types  [ ] polymorphic types
[ ] covariant array typing  [ ] monads  [ ] dependent types  [ ] tail recursion

The following philosophical objections apply:
[ ] Programmers should not need to understand category theory to write "Hello, World!"
[ ] Programmers should not develop RSI from writing "Hello, World!"
[ ] The most significant program written in your language is its own compiler
[X] The most significant program written in your language isn't even its own compiler
[X] Your language encourages insecure and fragile programs
    [X] and even your examples fail in common edge cases
[X] Your type system is unsound  [X] Your language cannot be unambiguously parsed
   [ ] a proof of same is attached
   [X] invoking this proof crashes the compiler
[ ] The name of your language is
    [ ] impossible to find on Google
    [ ] impossible to pronounce
    [ ] a curse word in _________
[ ] Interpreted languages will never be as fast as C
[X] Backwards compatibility and versioning is more important than you think
[X] Your language assumes the existence of a sufficiently smart compiler
[ ] ____________________________ takes exponential time
[X] ____________________________ is known to be undecidable

Your implementation has the following flaws:
[ ] Hardware does not work that way
[X] Compilers do not work that way
[X] You require the compiler to be present at runtime
[ ] You require the language runtime to be present at compile-time
[ ] Your compiler errors are completely inscrutable
[X] Basic features have been "on the roadmap" for a year
[ ] Your README looks AI-generated
[X] Dangerous behavior is only a warning
[X] Dangerous behavior is not even a warning
[ ] The compiler crashes if you look at it funny
[X] The LLM it uses can be jailbroken
[X] You don't seem to understand basic optimization techniques
[X] You don't seem to understand basic systems programming
[ ] You don't seem to understand pointers
[X] You don't seem to understand functions
[X] You don't seem to like your fellow programmers very much

You seem to be targeting the market for:
[X] systems programming  [ ] scripting  [ ] shells  [ ] web  [X] games
[ ] batch jobs  [ ] app making  [ ] teaching programming
[ ] appeasing ops/security officers  [X] freaking out ops/security officers
[ ] code golfing  [ ] parody languages  [ ] writing type-theory papers
[ ] creating AI  [ ] *mumble* blockchain *mumble*  [ ] other forms of raising VC money
but I'm afraid the market is:
[X] already saturated with frankly better options
[ ] unwilling to adopt solutions from small companies
[X] unwilling to adopt solutions from individual part-time developers
[ ] busy with more important problems
[ ] too smart to fall for your ploy

Additionally, your marketing has the following problems:
[ ] Complete lack of code examples
[X] Unsupported claims of increased productivity
[X] Unsupported claims of greater "ease of use"
[X] Obviously rigged benchmarks where the bulk of work is done:
    [X] in handwritten assembly
    [X] by libraries in other languages, that you call through your FFI
[ ] You're exclusively benchmarking toy functions for:
   [ ] addition  [ ] Fibonacci  [ ] FizzBuzz  [ ] JSON parsing  [ ] serving HTTP
[X] Noone really believes that your language is faster than:
    [ ] assembly  [X] C  [X] Rust  [X] Go  [ ] Javascript  [ ] Python
[X] Rejection of orthodox programming-language theory without justification
[X] Rejection of orthodox systems programming without justification
[X] Rejection of orthodox algorithmic theory without justification
[X] Rejection of basic computer science without justification
[X] Rejection of engineering ethics without justification

My security officer asked me to point out that:
[X] Your builds are:
    [X] not reproducible  [X] unsigned  [ ] triggering our anti-virus
    [X] hosted on a forum  [ ] in a sanctioned country
[ ] It relies on external servers  [ ] and runs code from them  [ ] at runtime
[ ] Your deserialization feature is indistinguishable from a reverse shell
[ ] Your package manager:
    [ ] has trivial security holes
    [ ] lacks decent user authentication
    [ ] hasn't learned the lessons from left-pad et al

Compared to similar efforts, I would like to note that:
[ ] Your complex sample code would be one line in: _______________________
[X] We already have many "better C" languages
[ ] We already have many safe system languages
[ ] We already have many easy-to-learn languages
[ ] We already have many web languages, for frontend, backend, and both-ends.
[ ] We already have many "look at this cool type system!" languages
[ ] You have reinvented Lisp but worse
[ ] You have reinvented Haxe but worse
[X] You have reinvented Crystal but worse
[X] You have reinvented Zig but worse
[ ] You have reinvented Javascript but worse
[ ] You have reinvented Javascript better, but that's still no justification
[ ] You have reinvented IntercalScript but non-ironically

In conclusion, this is what I think of you:
[ ] You have some interesting ideas, but this won't fly.
[X] This is a bad language, and you should feel bad for inventing it.
[X] Programming in this language is an adequate punishment for inventing it.
[ ] I don't want to be in your shoes when the cloud bill comes.