36a17d092b
* update readme * Literal -> Lit, LitE -> Lit * commentary * infer * hindley milner inference :D * comments and better type errors * type IsString + test unification error * infer nonrec let binds infer nonrec let binds * small * LitE -> Lit * LitE -> Lit * TyInt -> TyCon "Int#" * parse type sigs; program type sigs * parse types * parse programs (with types :D) * parse programs (with type sigs :D) * Name = Text Name = Text * RlpcError * i'm on an airplane rn, my eyelids grow heavy, and i forgot my medication. should this be my final commit (of the week): gootbye * kinda sorta typechecking * back and medicated! * errorful (it's not good) * type-checked quasiquoters * fix hm tests * Compiler.JustRun * lex \ instead of \\ * grammar reference * 4:00 AM psychopath code * oh boy am i going to hate this code in 12 hours * application and lits appl * something * goofy * Show1 instances * fixation fufilled - back to work! * works * labels * infix decl * expr fixups * where * cool * aaaaa * decls fix * finally in a decent state * replace uses of many+satisfy with takeWhileP * layout layouts oh my layouts * i did not realise my fs is case insensitive * tysigs * add version bounds * grammar reference * 4:00 AM psychopath code * oh boy am i going to hate this code in 12 hours * application and lits appl * something * goofy * Show1 instances * fixation fufilled - back to work! * works * labels * infix decl * expr fixups * where * cool * aaaaa * decls fix * finally in a decent state * replace uses of many+satisfy with takeWhileP * layout layouts oh my layouts * i did not realise my fs is case insensitive * tysigs * its fine * threaded lexer * decent starting point * man this sucks * aagh * okay layouts kinda * kitten i'll be honest mommy's about to kill herself * see previous commit and scale back the part where i'm joking * version bounds * we're so back * fixy * cool * FIX REAL * oh my god * works * now we're fucking GETTING SOMEWHERE * i really need to learn git proper * infix exprs * remove debug flags * renamerlp * rename rlp * compiles (kill me) man * RlpcError -> IsRlpcError * when the "Test suite rlp-test: PASS" hits i'm like atlas and the world is writing two lines of code * errorful parser * errorful parser small * msgenvelope * errors! * allow uppercase sc names in preperation for Rlp2Core * letrec * infer letrec expressions * minor docs * checklist * minor docs * stable enough for a demo hey? * small fixups * new tag syntax; preparing for Core patterns new tag syntax; preparing for data names * temporary pragma system * resolve named data in case exprs * named constr tests * nearing release :3 * minor changes putting this on hold; implementing TTG first * some * oh my god guys!!! `Located` is a lax semimonoidal endofunctor on the category Hask!!!  * it's also a comonad. lol. * idk * show * abandon ship * at long last more no more undefineds * i should've made a lisp man this sucks * let layout * ttg boilerplate * fixup! ttg boilerplate * fixup! ttg boilerplate * organisation and cleaning organisation and tidying * error messages * driver progress * formatting * *R functions * -ddump-ast * debug tags * -ddump-eval * core driver * XRec fix * rlp2core base * ccoool * something * rlp TH * sc * expandableAlt * expandableAlt * fix layout_let * parse case exprs * case unrolling * rose * her light cuts deep time and time again ('her' of course referring to the field of computer science) * tidying * NameSupply effect * tidy * fix incomplete byTag * desugar * WIP associate postproc corecursive * sigh i'm gonna have to nuke the ast again in a month * remove old files * remove old files * fix top-level layout * define datatags * diagram * diagram * Update README.md * ppr debug flags ddump-parsed * ppr typesigs * ppr datatags * remove unnecessary comment * tidying * .hs -> .cr update examples * fix evil parser bug (it was a fucking typo) * fix evil lexer bug (it was actually quite subtle unlike prev.) * examples * examples * letrec + typechecking core * Update README.md * Rlp2Core: simple let binds * Rlp2Core: pattern let binds * small core fixes * update examples * formatting * typed coreExpr quoter * typechecking things * lt * decent state! * constants for bool tags * print# gm primitive * bind VarP after pats * fix: tag nested data names * gte gm prim * more nightmare GM fixes * QuickSort example works i'm gonig to cry * remove debug code * remove debug tracers * ready? * update readme * remove bad, incorrct, outdated docs --------- Co-authored-by: crumbtoo <crumb@disroot.org>
106 lines
5.4 KiB
Plaintext
106 lines
5.4 KiB
Plaintext
Programming Language Checklist
|
|
by Colin McMillen, Jason Reed, and Elly Fong-Jones, 2011-10-10.
|
|
|
|
You appear to be advocating a new:
|
|
[x] functional [ ] imperative [ ] object-oriented [ ] procedural [ ] stack-based
|
|
[ ] "multi-paradigm" [x] lazy [ ] eager [x] statically-typed [ ] dynamically-typed
|
|
[x] pure [ ] impure [ ] non-hygienic [ ] visual [x] beginner-friendly
|
|
[ ] non-programmer-friendly [ ] completely incomprehensible
|
|
programming language. Your language will not work. Here is why it will not work.
|
|
|
|
You appear to believe that:
|
|
[ ] Syntax is what makes programming difficult
|
|
[x] Garbage collection is free [x] Computers have infinite memory
|
|
[x] Nobody really needs:
|
|
[x] concurrency [x] a REPL [x] debugger support [x] IDE support [x] I/O
|
|
[x] to interact with code not written in your language
|
|
[ ] The entire world speaks 7-bit ASCII
|
|
[ ] Scaling up to large software projects will be easy
|
|
[ ] Convincing programmers to adopt a new language will be easy
|
|
[ ] Convincing programmers to adopt a language-specific IDE will be easy
|
|
[ ] Programmers love writing lots of boilerplate
|
|
[ ] Specifying behaviors as "undefined" means that programmers won't rely on them
|
|
[ ] "Spooky action at a distance" makes programming more fun
|
|
|
|
Unfortunately, your language (has/lacks):
|
|
[x] comprehensible syntax [ ] semicolons [x] significant whitespace [ ] macros
|
|
[ ] implicit type conversion [ ] explicit casting [x] type inference
|
|
[ ] goto [ ] exceptions [x] closures [x] tail recursion [ ] coroutines
|
|
[ ] reflection [ ] subtyping [ ] multiple inheritance [x] operator overloading
|
|
[x] algebraic datatypes [x] recursive types [x] polymorphic types
|
|
[ ] covariant array typing [x] monads [ ] dependent types
|
|
[x] infix operators [x] nested comments [ ] multi-line strings [ ] regexes
|
|
[ ] call-by-value [x] call-by-name [ ] call-by-reference [ ] call-cc
|
|
|
|
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] No language spec
|
|
[x] "The implementation is the spec"
|
|
[ ] The implementation is closed-source [ ] covered by patents [ ] not owned by you
|
|
[ ] Your type system is unsound [ ] Your language cannot be unambiguously parsed
|
|
[ ] a proof of same is attached
|
|
[ ] invoking this proof crashes the compiler
|
|
[x] The name of your language makes it impossible to find on Google
|
|
[x] Interpreted languages will never be as fast as C
|
|
[ ] Compiled languages will never be "extensible"
|
|
[ ] Writing a compiler that understands English is AI-complete
|
|
[ ] Your language relies on an optimization which has never been shown possible
|
|
[ ] There are less than 100 programmers on Earth smart enough to use your language
|
|
[ ] ____________________________ takes exponential time
|
|
[ ] ____________________________ is known to be undecidable
|
|
|
|
Your implementation has the following flaws:
|
|
[ ] CPUs do not work that way
|
|
[ ] RAM does not work that way
|
|
[ ] VMs do not work that way
|
|
[ ] Compilers do not work that way
|
|
[ ] Compilers cannot work that way
|
|
[ ] Shift-reduce conflicts in parsing seem to be resolved using rand()
|
|
[ ] 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
|
|
[ ] Dangerous behavior is only a warning
|
|
[ ] The compiler crashes if you look at it funny
|
|
[x] The VM crashes if you look at it funny
|
|
[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
|
|
[ ] You don't seem to understand functions
|
|
|
|
Additionally, your marketing has the following problems:
|
|
[x] Unsupported claims of increased productivity
|
|
[x] Unsupported claims of greater "ease of use"
|
|
[ ] Obviously rigged benchmarks
|
|
[ ] Graphics, simulation, or crypto benchmarks where your code just calls
|
|
handwritten assembly through your FFI
|
|
[ ] String-processing benchmarks where you just call PCRE
|
|
[ ] Matrix-math benchmarks where you just call BLAS
|
|
[x] Noone really believes that your language is faster than:
|
|
[x] assembly [x] C [x] FORTRAN [x] Java [x] Ruby [ ] Prolog
|
|
[ ] Rejection of orthodox programming-language theory without justification
|
|
[x] Rejection of orthodox systems programming without justification
|
|
[ ] Rejection of orthodox algorithmic theory without justification
|
|
[ ] Rejection of basic computer science without justification
|
|
|
|
Taking the wider ecosystem into account, I would like to note that:
|
|
[x] Your complex sample code would be one line in: examples/
|
|
[ ] We already have an unsafe imperative language
|
|
[ ] We already have a safe imperative OO language
|
|
[x] We already have a safe statically-typed eager functional language
|
|
[ ] You have reinvented Lisp but worse
|
|
[ ] You have reinvented Javascript but worse
|
|
[ ] You have reinvented Java but worse
|
|
[ ] You have reinvented C++ but worse
|
|
[ ] You have reinvented PHP but worse
|
|
[ ] You have reinvented PHP better, but that's still no justification
|
|
[ ] You have reinvented Brainfuck 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.
|
|
[ ] Programming in this language is an adequate punishment for inventing it.
|
|
|