
Programming Language Checklist - kibwen
http://colinm.org/language_checklist.html
======
zeteo
>[ ] The name of your language makes it impossible to find on Google

Unless you work for Google, in which case your language's name (maybe shared
with a common verb or a popular board game) will quickly become the top search
result!

~~~
djur
For me, in an incognito window (so Google is less likely to tweak search
results for my preferences), the Wikipedia page for the game Go is the first
result, and five out of the top 10 are also about the game. The other results
are Disney's "go.com" domain, golang.org, and the movie Go on IMDB.

Doesn't really suggest unfair weighting to me.

~~~
GuiA
This is what I see in an incognito window:
[http://i.imgur.com/BI4zvXB.png](http://i.imgur.com/BI4zvXB.png)

~~~
alecdbrooks
Given that incognito doesn't obscure your IP address (not to mention the
myriad other ways your identity could be leaked to Google), I wonder if
incognito's enough to get a "clean" page of Google results. On this search, I
get different results from you but ones similar to djur:
[http://imgur.com/7KTqZFV](http://imgur.com/7KTqZFV) (on Firefox in private
mode: [http://imgur.com/Jn400wX](http://imgur.com/Jn400wX)). For reference, I
probably would only visit a page on Go if it were linked to on a blog; I don't
use it or (normally) search for it.

------
zellyn
It's surprising to me that people view this as primarily negative. I think
it's (a) funny, and (b) actually serves - as does the best humor - to make
people think about things more deeply: by enumerating all the knee-jerk
reactions in one place, discussion can focus on more interesting aspects.

~~~
mhurron
People want to be offended, it makes them feel superior.

It is clearly a joke, anyone taking it seriously shouldn't really have any
attention paid to them.

------
jmduke
This is such a bummer of a file that incorrectly assumes that the only valid
goal of a new language is to achieve widespread adoption.

I know its en vogue to turn up our noses at "X at Y lines of Javascript", but
programming is actually a pretty fun and neat thing to do, and its okay to
create something even if its not particularly groundbreaking or commercially
viable.

 _This is a bad language, and you should feel bad for inventing it._

I can't help but imagine the person who penned this sentence also routinely
tells children that their macaroni artwork could use more symmetry.

~~~
edvinbesic
I cannot agree more, especially reading the history of T by P. Graham, a
language I have never heard of before or written a line in, but whose history
I find extremely interesting from a developers perspective.

The whole "X at Y lines" argument is the same as saying "I created an OS in
language X in two lines of code" by writing:

    
    
      Import OS.*;
      OS.Run();

~~~
Aldo_MX
Checkmate, one line.

    
    
      Import OS.*; OS.Run();

~~~
chavesn
Compile error: only the full sequence ";\n" ends a statement.

~~~
Aldo_MX

      for(;
      ;
      )
      {
          print "I don't like your compiler.";
      }

------
tptacek
This is like lowbrow-dismissal bingo. Someone (cough) should turn this into
actual bingo cards.

------
jredwards
> You have reinvented PHP better, but that's still no justification

Preach.

------
ret
"You have reinvented Brainfuck but non-ironically" \- brilliant. :)

~~~
gwern
Ah, so _that_ is what this checklist yields for Urbit!

------
russell
With a little cleanup, this could have been the original government
procurement checklist for Ada.

------
ori_b
As the developer of Myrddin
([http://eigenstate.org/myrddin.html](http://eigenstate.org/myrddin.html)), I
felt the need to fill it in for my pet language:

    
    
        You appear to be advocating a new:
        [ ] functional  [ ] imperative  [ ] object-oriented  [x] procedural
        [ ] stack-based [x] "multi-paradigm"  [ ] lazy  [x] eager  
        [x] statically-typed  [ ] dynamically-typed [ ] pure  [x] impure
        [ ] non-hygienic  [ ] visual  [ ] 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
        [ ] Garbage collection is free
        [ ] Computers have infinite memory
        [x] Nobody really needs:
            [x] concurrency  [x] a REPL  [x] debugger support  [x] IDE support  [ ] I/O
            [x] to interact with code not written in your language
        [ ] The entire world speaks 7-bit ASCII
        [x] Scaling up to large software projects will be easy
        [x] 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): [Lacks => L, Has => H]
        [L] comprehensible syntax  [L] semicolons  
        [L] significant whitespace  [L] macros
        [L] implicit type conversion  [H] explicit casting 
        [H] type inference [H] goto  [ ] exceptions  [x] closures
        [L] tail recursion  [L] coroutines [L(planned)] reflection 
        [L] subtyping  [L] multiple inheritance
        [L(planned)] operator overloading [H] algebraic datatypes  
        [H] recursive types  [L] polymorphic types [L] covariant array typing 
        [L] monads  [L] dependent types [H] infix operators 
        [H] nested comments [L] multi-line strings  [library] regexes 
        [H] call-by-value  [L] call-by-name [L] call-by-reference 
        [L] 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
        [ ] No language spec
        [X] Incomplete language spec
        [ ] "The implementation is the spec"
        [ ] The implementation is closed-source
                [ ] covered by patents
                [ ] not owned by you
        [X] Your type system is unsound 
        [ ] Your language cannot be unambiguously parsed
        [ ] a proof of same is attached
        [ ] invoking this proof crashes the compiler
        [ ] The name of your language makes it impossible to find on Google
        [ ] Interpreted languages will never be as fast as C
        [X] 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
        [X] Your compiler errors are completely inscrutable
        [ ] Dangerous behavior is only a warning
        [X] The compiler crashes if you look at it funny
        [ ] The VM crashes if you look at it funny
        [X] You don't seem to understand basic optimization techniques
        [ ] 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 (Benchmarks? What are those)
        [ ] 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  [ ] Ruby  [ ] Prolog
        [x] 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: _______________________
        [x] We already have an unsafe imperative language
        [ ] We already have a safe imperative OO language
        [ ] 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
        [x] 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:
        [x] 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.
    

Side note, this isn't something serious. It's a tongue in cheek parody of this
old usenet spam-fighting idea checklist meme:
[http://craphound.com/spamsolutions.txt](http://craphound.com/spamsolutions.txt)

------
joshguthrie
Can it output me a list of programming languages based on what I check?

------
evincarofautumn
As the author of Kitten
([http://github.com/evincarofautumn/kitten](http://github.com/evincarofautumn/kitten)):

You appear to be advocating a new functional, imperative, procedural, stack-
based, eager, statically typed, pure programming language. Your language will
not work. Here is why it will not work. Unfortunately, your language has
comprehensible syntax, significant whitespace, type inference, closures, tail
recursion, algebraic datatypes, polymorphic types, nested comments, multi-line
strings, and call-by-value. (It lacks almost everything else.) The most
significant program written in your language isn’t even its own compiler.
There is no language spec; the implementation is the spec. Compiled languages
will never be “extensible”. Your compiler errors are completely inscrutable.
No one really believes that your language is faster than assembly, C, or
FORTRAN. We already have a safe statically typed eager functional language.
You have reinvented Forth but non-ironically. In conclusion, you have some
interesting ideas, but this won’t fly.

And the runtime isn’t even done yet. :P

------
timmclean
This checklist discourages people from writing their own programming
languages. Why not rewrite the checklist as positive, constructive advice
around common pitfalls, instead of complaints like "You don't seem to
understand X"? There are new programming languages waiting to be invented --
providing a template for knee-jerk negative reactions does not seem like a
productive endeavour.

~~~
dragonwriter
> This checklist discourages people from writing their own programming
> languages.

Rather, this checklists mocks common discussion-board dismissals that
discourage people from writing their own programming languages.

------
lignuist
Perfect.

To me it looks like a few new languages are introduced every week and I just
cannot understand why. I can understand that a programmer who reaches a
certain level wants to build his own language, but do they really think that
the world is waiting for yet another programming language? It is just not
getting easier with a new language.

This article is a must read for everyone who considers writing a new language.
If all the arguments do not apply for your language, then the world is
probably really waiting for your new language. :)

~~~
derekp7
I believe that it is good for any programmer to at some point in their
development create a simple language and write an interpreter for it. First,
you learn parsing, then you learn what actually makes a language tick. Then
you learn what goes into the design process, when you realize you've designed
yourself into a corner. Then you start reading up on language design, stumble
across sites like Lambda-the-Ultimate.org, and find out that there is a lot
more than imperative / OO programming. Then you start getting into the Lisp
literature, and reach a zen-like state. Then you snap back to reality, and
become a slightly better programmer, who is a bit more humble.

~~~
alcari
Repeat several times to become a much better programmer, but possibly lose the
humbleness.

~~~
rfnslyr
Final step: Co-exist as one with John Carmack and all other ascended souls.

------
fat0wl
> You appear to believe that:

> [ ] Syntax is what makes programming difficult

Lol I went from RoR to Java (IBM Websphere stuff) & all my Python dev friends
started trying to explain to me how its a career killer because Java's syntax
is archaic.

Turns out the company I'm at is using very advanced builder tools and then
just integrate a bit with linked Java objects. Pretty neat! And has given me
time to shift study toward Play framework / Node / Dart / Clojure.

------
shenoybr
I believe programmers should rather focus their attention to understanding the
internals of existing languages, this will do wonders to the way they program.

------
rayiner
Re: "[ ] The most significant program written in your language isn't even its
own compiler"

There's a great quote by someone which Googling can't find, that goes along
the lines of: "a language whose own compiler isn't written in itself is
beneath contempt."

------
imslavko
As a non-expert in programming languages I find this list a good starting
point for learning: reading about each bullet point in Wikipedia might already
be useful. And arguing on HN is not the single application of this knowledge.

------
seanmcdirmid
As a researcher working on experimental PLs [1]...why not

[1] [http://research.microsoft.com/en-
us/people/smcdirm/liveprogr...](http://research.microsoft.com/en-
us/people/smcdirm/liveprogramming.aspx)

    
    
      You appear to be advocating a new:
      [ ] functional  [X] imperative  [X] object-oriented  [X] procedural [ ] stack-based
      [ ] "multi-paradigm"  [ ] lazy  [ ] eager  [X] statically-typed  [ ] dynamically-typed
      [ ] pure  [X] impure  [ ] non-hygienic  [ ] visual  [ ] beginner-friendly
    
      You appear to believe that:
      [X] Garbage collection is free                [X] Computers have infinite memory
      [ ] Nobody really needs:
         [ ] concurrency  [X] a REPL  [ ] debugger support  [ ] IDE support  [ ] I/O
         [ ] to interact with code not written in your language
      [X] Convincing programmers to adopt a new language will be easy
      [X] Convincing programmers to adopt a language-specific IDE will be easy
      [X] "Spooky action at a distance" makes programming more fun
    
      Unfortunately, your language (H -> has/ L -> lacks) :
      [H] comprehensible syntax  [L] semicolons  [H] significant whitespace  [L] macros
      [L] implicit type conversion  [L] explicit casting  [H] type inference
      [L] goto  [L] exceptions  [L] closures  [L] tail recursion  [L] coroutines
      [L] reflection  [H] subtyping  [H] multiple inheritance  [L] operator overloading
      [L] algebraic datatypes  [L] recursive types  [H] polymorphic types
      [H] covariant array typing  [L] monads  [L] dependent types
      [H] infix operators  [L] nested comments  [L] multi-line strings  [L] regexes
      [H] call-by-value  [L] call-by-name  [L] call-by-reference  [L] call-cc
    
      The following philosophical objections apply:
      [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"
         [X] The implementation is closed-source  [X] covered by patents  [X] not owned by you
      [?] Your type system is unsound  
      [X] ____________________________ takes exponential time
      [X] ____________________________ is known to be undecidable
    
      Your implementation has the following flaws:
      [X] CPUs do not work that way
      [X] RAM does not work that way
      [X] VMs do not work that way
      [X] Compilers do not work that way
      [X] Compilers cannot work that way
      [X] You require the compiler to be present at runtime
      [X] You require the language runtime to be present at compile-time
      [X] Dangerous behavior is only a warning
      [X] You don't seem to understand basic optimization techniques
      [X] You don't seem to understand basic systems programming
    
      Additionally, your marketing has the following problems:
      [X] Unsupported claims of increased productivity
      [X] Unsupported claims of greater "ease of use"
      [ ] Noone really believes that your language is faster than:
         [X] assembly  [X] C  [X] FORTRAN  [X] Java  [X] Ruby  [ ] Prolog
      [X] Rejection of orthodox programming-language theory without justification
      [X] Rejection of orthodox systems programming without justification
      [ ] Rejection of orthodox algorithmic theory without justification
      [X] Rejection of basic computer science without justification
    
      Taking the wider ecosystem into account, I would like to note that:
      [X] We already have an unsafe imperative language
      [X] We already have a safe imperative OO language
    
      In conclusion, this is what I think of you:
      [ ] You have some interesting ideas, but this won't fly.
      [ ] This is a bad language, and you should feel bad for inventing it.
      [ ] Programming in this language is an adequate punishment for inventing it.

------
KerrickStaley
I only upvoted this because McMillen wrote it.

------
ahomescu1
Hilariously, C checks a lot of these boxes.

------
jdpage
I once built a stupid language for fun. Think a bastard child of FORTH and
brainfuck, but in two dimensions. To give an idea of how stupid it was, I will
fill this in.

    
    
        You appear to be advocating a new:
        [ ] functional  [X] imperative  [ ] object-oriented  [X] procedural [X] stack-based
        [ ] "multi-paradigm"  [ ] lazy  [X] eager  [ ] statically-typed  [X] dynamically-typed
        [ ] pure  [ ] impure  [ ] non-hygienic  [X] visual  [ ] beginner-friendly
        [X] non-programmer-friendly  [X] 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
        [ ] Garbage collection is free                [ ] Computers have infinite memory
        [ ] Nobody really needs:
            [X] concurrency  [X] a REPL  [X] debugger support  [X] IDE support  [ ] 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
        [X] "Spooky action at a distance" makes programming more fun
    
        Unfortunately, your language (has/lacks):
        [-] comprehensible syntax  [-] semicolons  [+] significant whitespace  [-] macros
        [+] implicit type conversion  [-] explicit casting  [-] type inference
        [+] goto  [-] exceptions  [-] closures  [-] tail recursion  [-] coroutines
        [-] reflection  [-] subtyping  [-] multiple inheritance  [-] operator overloading
        [-] algebraic datatypes  [-] recursive types  [-] polymorphic types
        [-] covariant array typing  [-] monads  [-] dependent types
        [-] infix operators  [+] nested comments  [+] multi-line strings  [-] regexes
        [-] call-by-value  [-] 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
        [ ] No language spec
        [ ] "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()
        [X] You require the compiler to be present at runtime
        [ ] You require the language runtime to be present at compile-time
        [X] Your compiler errors are completely inscrutable
        [X] Dangerous behavior is only a warning
        [X] 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
        [ ] 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:
        [ ] Unsupported claims of increased productivity
        [ ] 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  [X] Prolog
        [X] Rejection of orthodox programming-language theory without justification
        [ ] 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: almost anything, actually
        [ ] We already have an unsafe imperative language
        [ ] We already have a safe imperative OO language
        [ ] 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.
        [X] Programming in this language is an adequate punishment for inventing it.
    

In fact, it was so magnificently stupid that when I described it on a forum I
frequent, one of the administrator considered banning me because I obviously
deserved it if I would invent something that deranged.

~~~
trafficlight
Now you have to tell us what it is.

~~~
S4M
Totally agree. GP, please post a link. We won't make fun of you.

~~~
jdpage
On thy own heads be it. Here is the code, as written when I was 16. You'll
need Tcl 8.5 to run it (8.3 is probably fine, but you'll have to change the
line at the beginning), because all the cool kids implement interpreted
languages in other interpreted languages. (Actually, wasn't Arc implemented
that way originally?)

[https://www.dropbox.com/s/zqahavw2yoeca5p/stringsh.zip](https://www.dropbox.com/s/zqahavw2yoeca5p/stringsh.zip)

~~~
trafficlight
That's pretty awesome.

------
munificent
I'm working on a little object-oriented scripting language:

    
    
        You appear to be advocating a new:
        [X] functional  [X] imperative  [X] object-oriented  [ ] procedural [ ] stack-based
        [ ] "multi-paradigm"  [ ] lazy  [X] eager  [ ] statically-typed  [X] dynamically-typed
        [ ] pure  [X] impure  [ ] non-hygienic  [ ] visual  [ ] 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
        [ ] Nobody really needs:
            [ ] concurrency  [ ] a REPL  [X] debugger support  [X] IDE support  [ ] I/O
            [ ] to interact with code not written in your language
        [ ] The entire world speaks 7-bit ASCII
        [X] 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):
        [+] comprehensible syntax  [-] semicolons  [-] significant whitespace  [-] macros
        [-] implicit type conversion  [+] explicit casting  [-] type inference
        [-] goto  [-] exceptions  [+] closures  [ ] tail recursion  [+] coroutines
        [+] reflection  [+] subtyping  [-] multiple inheritance  [+] operator overloading
        [ ] algebraic datatypes  [ ] recursive types  [ ] polymorphic types
        [ ] covariant array typing  [ ] monads  [ ] dependent types
        [+] infix operators  [+] nested comments  [ ] multi-line strings  [ ] regexes
        [ ] call-by-value  [ ] 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
        [ ] The name of your language makes it impossible to find on Google
        [X] Interpreted languages will never be as fast as C
        [X] 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()
        [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
        [ ] Dangerous behavior is only a warning
        [ ] The compiler crashes if you look at it funny
        [ ] The VM crashes if you look at it funny
        [X] You don't seem to understand basic optimization techniques
        [ ] 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:
        [ ] Unsupported claims of increased productivity
        [ ] 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
        [ ] Noone really believes that your language is faster than:
            [X] assembly  [X] C  [X] FORTRAN  [X] Java  [ ] Ruby  [ ] Prolog
        [ ] Rejection of orthodox programming-language theory without justification
        [ ] 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:
        [ ] Your complex sample code would be one line in: _______________________
        [ ] We already have an unsafe imperative language
        [X] We already have a safe imperative OO language
        [ ] 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.

------
picomancer
Here is the checklist for my programming language, foil -- demo available
(requires Java plugin) at [http://picomancer.com/blog/foil-compiler-tech-
preview/](http://picomancer.com/blog/foil-compiler-tech-preview/)

    
    
        You appear to be advocating a new:
        [ ] functional  [x] imperative  [x] object-oriented  [ ] procedural [ ] stack-based
        [ ] "multi-paradigm"  [ ] lazy  [ ] eager  [x] statically-typed  [x] dynamically-typed
        [ ] 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:
        [x] Syntax is what makes programming difficult
        [ ] Garbage collection is free                [ ] Computers have infinite memory
        [ ] Nobody really needs:
            [ ] concurrency  [ ] a REPL  [ ] debugger support  [ ] IDE support  [ ] I/O
            [ ] to interact with code not written in your language
        [x] The entire world speaks 7-bit ASCII
        [ ] Scaling up to large software projects will be easy
        [x] 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
        [x] 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):
        [Y] comprehensible syntax  [N] semicolons  [Y] significant whitespace  [N] macros
        [N] implicit type conversion  [N] explicit casting  [Y] type inference
        [Y] goto  [Y] exceptions  [Y] closures  [N] tail recursion  [Y] coroutines
        [N] reflection  [Y] subtyping  [ ] multiple inheritance  [Y] operator overloading
        [ ] algebraic datatypes  [ ] recursive types  [ ] polymorphic types
        [ ] covariant array typing  [ ] monads  [ ] dependent types
        [ ] infix operators  [ ] nested comments  [Y] multi-line strings  [ ] regexes
        [Y] call-by-value  [ ] call-by-name  [Y] 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
        [ ] The name of your language makes it impossible to find on Google
        [ ] 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
        [x] Your compiler errors are completely inscrutable
        [x] Dangerous behavior is only a warning
        [ ] The compiler crashes if you look at it funny
        [ ] The VM crashes if you look at it funny
        [ ] You don't seem to understand basic optimization techniques
        [ ] 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:
        [ ] Unsupported claims of increased productivity
        [ ] 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
        [ ] Noone really believes that your language is faster than:
            [ ] assembly  [ ] C  [ ] FORTRAN  [ ] Java  [ ] Ruby  [ ] Prolog
        [ ] Rejection of orthodox programming-language theory without justification
        [ ] 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:
        [ ] Your complex sample code would be one line in: _______________________
        [ ] We already have an unsafe imperative language
        [ ] We already have a safe imperative OO language
        [ ] 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.
        [ ] This is a bad language, and you should feel bad for inventing it.
        [ ] Programming in this language is an adequate punishment for inventing it.

------
dbpokorny
[x] Code can be shared without compromising security

This is made possible with...

* compile-time memory protection

* automatic memory management

* compile-time data access restrictions (mark struct members as read-only)

* divide programs into small, mutually-distrusting components

* add features by adding components, not by changing existing components

The last two points are things the programmer has to do, but keep in mind that
programming languages today don't even give you the opportunity to design this
way. The last paradigm that did was C / Unix, and that was back when it was
reasonable to send program state over a pipe.

Java tried to do this in the 90s, but a quick web search for "Java security"
will turn up the historical record. In my opinion, VMs are inherently
insecure, so I think the flaw in Java's approach was the decision to make Java
run on a VM. VMs are inherently monolithic, and thus violate the "network of
mutually-distrusting components" point above.

For more semi-coherent rambling on this topic, see my latest blog post...
[http://dbpokorny.blogspot.com/2013/11/prisoner-of-
paradigm.h...](http://dbpokorny.blogspot.com/2013/11/prisoner-of-
paradigm.html)

------
lhgaghl
...and brendan eich checked all the boxes

