limmeau

From the publication dates, this could be what Thomas Maier-Komor got his PhD for; however, since he now appears to have a full-time job at BMW, I wouldn't count on this being developed further.

There's still Cil if you speak Ocaml: http://kerneis.github.io/cil/doc/html/cil/

Have you tried Revised Syntax?

http://caml.inria.fr/pub/docs/manual-camlp4/manual007.html

The flight booking metaphor makes it very inviting to play around. Thanks for sharing.

(Now if I could get Firefox for Android to download a .mp3 link to local SD card...)

To concentrate, I use computer game soundtracks (e.g. from Humble Bundle; particularly the one with Eufloria and Waking Mars), and to drown out voices of coworkers whose volume dial got lost in the laundry, text-heavy music in a language I don't understand (alternating between Czech hip-hop and Finnish hummpa).

Have you tried Boodler, a soundscape generator?

http://boodler.org/

Thanks. I see it wraps NBD, too.

FUSE is somewhere on the top of my "cool tools I wish I had a use for some day", together with Go, so thanks for posting this!

BTW does anyone know if there is something similar to FUSE, but for block-devices? I've written a rudimentary NBD server to read my old OS X sparsebundles on Linux, but NBD seems a bit over-general for that purpose.

I wish they had renamed it to Issue9 when they still had the chance.

Bringing the fun of goatserolling into the world of command-line applications.

I'm not claiming any prior use of "Full stack developer"(TM) (haven't researched that), just that HN discussions often have a web-technology bias, where "designer" implicitly means "web designer", "low-level" means "in a VM inside a browser running on an OS running on a processor", etc.

I don't claim that "Full stack developer" has been used before.

Just like in the context of HN, "designer" seems to mean "web designer".

Grouping comes to mind, e.g.

        int x, y;
        int width, height;
        int area;
        int numPoints;

Racket (and maybe other Schemes) lets you interchange [] and () freely. Helps a bit. e.g.

         (cond
           [(positive? -5) (error "doesn't get here")]
           [(zero? -5) (error "doesn't get here, either")]
           [(positive? 5) 'here])

I thought that too. Was curious about the people who fled the Eternal September the Web has become, returning to the good old Gopher without popup ads and CSS drop-shadows.

What do you swap into the pointer? A new instance?

The Bitcoin community could agree on one block to be the "last" block and compute all balances reached so far. Then start a new block chain with a special first block which initializes the balances.

This requires a protocol change and lots of coordination, but may be preferable to a situation where mere possession of a copy of the block chain qualifies you for jail.

Similar in Germany, although it was introduced only recently. We got 14 months in total, which we split 12 months + 2months. It's also possible to stretch the parental leave into a longer time of subsidized part-time. One of my bosses is doing that right now.

However, the system is designed for salaried employees. If you're self-employed, your parental leave benefits are based on whatever bills your customers chose to pay in the 12 months before birth (but hearsay).

Doesn't Mercurial also maintain version info in one file below .hg per file in the tree?

This would be even more fun if Java supported user-defined infix operators with adjustable precedence, like Haskell.

Or even mix-fix operators like Maude. Maude lets you define operators with variable arity and arbitrary stuff before, between and after, like

       let _ = _ in _ 
       _::_(_)
       _,_ |- _
       You _, but I _

Always considered this a cool feature.

Have you got an example of a more sane and easier to understand notation for type inference rules? I find the horizontal-bar notation quite readable.

The Mint transaction, which becomes part of the block chain, establishes consent that the given bitcoin address owns one BTC less and that simultaneously the given Zerocoin becomes valid.

Minting takes place within the block chain, unlike Dollar exchanges on MtGox, which are not directly visible as such in the block chain.

It would be inconvenient if the validity of a blockchain became undecidable, or even just NP-hard.

When you Mint a zerocoin, you spend a BTC. When you redeem a zerocoin, you receive a BTC. The collective of miners verifies that you don't get rich doing so.

Would that look at the screen layout to remove a span that is positioned too far to the left? Or just disable JS control over copy-paste, which doesn't solve this problem?

Why would one use PMODE with Watcom when Watcom comes with DOS/4GW?

What do you recommend as a first book to read?

(edit: never mind, sibling thread has it covered: https://news.ycombinator.com/item?id=5485695 )

I always hated the forward-backward buttons. In Eclipse and VS, I kept hitting them when reaching for Shift or Cursor, and ended up in a different file.

Not having to run a shop.

For a while, I thought that luvit is completely undocumented. But then, I found out that one just goes to nodejs.org ...

So far, I mostly like it. Recently, I used it to build a PoC for an in-house testing tool for embedded devices and decided to slap a web interface onto it for fun (just like Twisted provokes you to add an NNTP and an SSH interface just for fun).

What I'm a bit unhappy with is the decision to be incompatible with the rest of the Lua world. From what I read in the mailing list, it's not just "sorry, that rock uses blocking file IO" but rather "Lua is Lua, and luvit is luvit".