Ask HN: What's your innovative idea to change the world?

  You appear to be advocating a new:
  [ ] functional  [ ] imperative  [x] object-oriented  [x] procedural
  [ ] stack-based [ ] "multi-paradigm"  [ ] lazy  [x] eager
  [ ] statically-typed  [ ] dynamically-typed [ ] pure  [x] impure
  [ ] non-hygienic  [ ] visual  [x] beginner-friendly [x] "modular"
  [x] 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
  [x] Adding more "ideas" to a language makes it better
  [x] People choose between garbage collection/
      manual memory management/reference counting and other,
      very hard to implement and use approaches for fun
  [ ] Garbage collection is free   [x] Computers have infinite memory
  [ ] Nobody really needs:
    [x] concurrency  [ ] a REPL  [ ] debugger support  [ ] IDE support
    [ ] I/O  [ ] 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
  [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
  [x] "Spooky action at a distance" makes programming more fun
  [X] Programmers will pay money to use your language
  [X] Programmers aren't annoyed already from all the new free
      languages appearing twice a day

  Unfortunately, your language (has/lacks):
  [x] comprehensible syntax  [ ] semicolons [x] significant whitespace
  [ ] macros [ ] implicit type conversion  [ ] explicit casting
  [ ] type inference [ ] goto  [ ] exceptions  [ ] closures
  [ ] tail recursion  [ ] coroutines [ ] reflection  [x] subtyping
  [ ] multiple inheritance  [ ] operator overloading
  [ ] algebraic datatypes  [ ] recursive types  [ ] polymorphic types
  [ ] covariant array typing  [ ] monads  [x] 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
  [ ] The most significant program written in your language isn't 
      even its own compiler
  [x] 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
  [ ] Interpreted languages will never be as fast as C
  [ ] Compiled languages will never be "extensible"
  [x] Writing a compiler that understands English is AI-complete
  [x] 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
  [ ] The liveness property is known to be undecidable

  Your implementation has the following flaws:
  [x] The "market" for programming languages doesn't work this way
      (there is no market)
  [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
  [ ] 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
  [ ] 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:
  [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:
      [ ] assembly  [x] C  [ ] FORTRAN  [ ] Java  [ ] Ruby  [ ] Prolog
  [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

  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
  [x] The "I can do everything better than thousands of people with
      decades of experience"-one-man-projects usually go nowhere.

  In conclusion, this is what I think of you:
  [x] You have some interesting ideas, but this won't fly.
  [x] This is 95% wishful thinking.
  [x] Building a language is a great way to gain deeper technical understanding,
      but believing it's possible to earn money with it is ridiculous.
  [ ] This is a bad language, and you should feel bad for inventing it.
  [ ] Programming in this language is an adequate punishment for inventing it.

Two questions:

1) How is "modular" programming not possible in other languages? In something like Scala, I'd always imagined any paradigm is possible. I'd be extremely interested in a short piece of example code.

2) Why a new language instead of contributing to, say, Go, Rust, Scala, or one of the other "new" languages? It generally takes 5+ years for a language to become mainstream (sometimes much longer), so if you're looking at a release date of 3 years from now, you're talking about nearly a decade.

"Modular programming" is already a term in wide use for a widely used programming style/practice [1], so if you have defined a new paradigm, you should probably call it something else.

[1] see, e.g., http://c2.com/cgi/wiki?ModularProgramming and http://en.wikipedia.org/wiki/Modular_programming

Never going to happen, for a truly innovative idea, because the risks are too high.

The world needs a benevolent Bell Labs type of institution, with commercial intelligence, that channels profits back into its growth (like Amazon). It should employ tens of thousands of scientists - engaged in 'blue sky' research - and aim to solve problems that are currently considered 'too big'. The usual stuff, like climate change, clean energy production, and political reform (backed by hard political science).