List of things I don’t care about

  • Trolling
  • Firmly held beliefs
  • Names
  • Sunk costs
  • Unobserved events
  • Definitions

Advertisements

UX story #1

It was Saturday morning, and Joe Programmer hopped out of his bed and
got onto his computer. It booted up instantly, as usual, greeting him
with a smiley face (as configured) and the latest interesting tidbits.
"What?" Joe exclaimed. "Bill made a trillion dollars off his latest
program? I need to get to work!"

Joe took a sheet from his "list of programs to be reimplemented in
Mathnerd314's programming language", and went to work.

"Hmm", he said, "this uses one of those Java/C# hybrids. I really hate
that crap. Good thing it's guaranteed bug-free. I don't get paid to fix
bugs."

Whistling, he went to work, mostly just typing back in the code, until
he came to a place with a base class and a few derived classes. "This
one's a puzzler," he said. "The derived classes don't override any of
the getters of the original class, but there's an overriden method that
doesn't call its parent! This won't work at all for Mathnerd314's
language, where both the base class method *and* the derived method are
called at once."

He IRC'd Mathnerd314, and explained the problem. "Oh, your universe is
impossible," said Mathnerd314.

Joe, and his problem with Mathnerd314's language, promptly ceased to exist.

The End

Slogans

"the ultimate programming language"
"the superset of your language"
"reverse-engineering compilers so you don't have to"
"replacing syntax with semantics since <date>"
"solving the halting problem, every day before breakfast"
"porting the world to run on thin air"
"more abstract than abstraction itself"

Wiki design

The Structure

  • Dict: (Dictionary / Default namespace)

    • code / pseudocode for various important algorithms and data structures

    • working definition of each term

    • snippets of various PL documentation (grammars, semantics, …)

    • authoritative names for the various PL’s

    • relatively difficult to edit – protected to some (small) group

    • new terms (pages) should be easy to make

    • copying of portions wikipedia and lesswrong might be good

    • nothing should ever be deleted here unless “OMG THE SERVER’S RUNNING OUT OF SPACE!!!”

    • large #’s of redirects likely

    • disambiguations should be resolved in DictionaryChange (terms have only 1 meaning)

    • should be a relatively small area, mostly for people who want to know what they’re talking about

    • creme da la creme of the site

  • DictionaryChange (Talk: ?)

    • RFCT’s (request for changes to terms)

    • clarification on whatever some random git posts as a new term

    • garbage-collected once the RFCT has been discussed

  • Meta:

    • overview of the site

    • links to related sites

    • IRC channel policies

    • … other meta stuff …

  • Dect: (Deconstruction)

    • detailed picking apart of PLs

    • analysis of which features work and don’t work

    • contain research, summaries/links to research

    • stated opinions of some authorities / random gits

    • performance data / charts

    • cognitive behavioral therapy

    • /really intense/ discussion of the lambda calculus and its relatives

    • trolling for n00bs

    • … other interesting stuff …

    • stuff deleted if the author agrees (possibly via protracted silence)

    • goal is to find stuff worthy of a term / page in Dict:

  • Perhaps some other namespace(s) for IRC logs, debates, flamewars, images, etc. so we don’t have to use Dect: all the time

  • User pages limited somehow and garbage-collected based on content

End goal: random user posts some code snippet in Dect:, we say use [[Dict:X]] [[Dict:Y]] and [[Dict:Z]] in [[Dict:AwesomePL]] to make it maintainable. (Maybe make Dict: the main namespace, so it’s just [[X]] [[Y]] and [[Z]], and have autolinking enabled – wiki software to shorten it to [x] might be better)

Programming is Easy (Usually)

I read the Daily WTF sometimes, and I have to say: the only things they can complain about is “quirks” of the language they’re using: exceptions make control flow hard to follow, rand() isn’t referentially transparent, lack of syntax sugar, etc. etc.

These are bugs; they happen to be located in the programming language design. But you can still fix them. Stop complaining, start programming. Seriously.

The problem is that languages are considered to be “hard”; this probably comes from examples in the past.

  • C/C++ (namely GCC) was specifically designed to be messy and hard-to-modify, so that proprietary software can’t interface with it.
  • Javascript (in general, any committee language) has too much red tape to modify it (e.g. “let” isn’t used because it’s not cross-browser)
  • Perl/Python/Ruby are constructed around “philosophies” rather than fixing problems in languages (i.e. they reject language patches)
  • “Small” languages are designed by academics, and are guilty by contamination (Lisp, Io, etc.)

So it’s wrong; fixing bugs is easy. You just have to solve all these other “human” problems to get it accepted, which is supposed to be hard for programmers. Think “geek in the basement”; is he going to spend time advocating for his patches when he could just keep on hacking? Thus one ends up with a fragmented ecosystem of good programming; lots of people, working on their own, who nobody pays any attention to except to reject. And they don’t say that it’s easy, so it’s hard.

Does the conspiracy to keep programming difficult sound extreme yet? Subscribe for more!

Link dump

This is pretty much everything I’m going to dump into the language core:

Sets are values

As well as being functions, set are values. You can apply functions to them, pass them around, etc.
Wait, what is {1,2} + 2, you ask?
Simple: it is just {1+2,2+2}={3,4}.

Similarly, {...,-3,-2,-1,0,1,2,3,...} * {2,3} = {...,-9,-8,-6,-4,-3,-2,0,2,3,4,6,8,9,...}.
It’s just that set monad or ambiguous choice that you thought might be cool.

But sets are types, so this means you can do type-level arithmetic; (2 * Integer) * 3 = (6 * Integer)
Of course, this probably makes the type system undecidable… but I certainly don’t care!