psuter

Also in that vein is Island & Trains [1], though the release date may be further out.

[1] https://store.steampowered.com/app/1957760/Islands__Trains/

Great investigation and excellent production value!

Brings back good memories too, as 10 years ago my first contribution to lichess was to improve the PGN notation for disambiguation. [1]

[1] https://github.com/lichess-org/scalachess/blame/master/core/...

Härkingen is well-known for being at the crossroads of important highways, FWIW. It is definitely a very relevant location for logistics.

Facebook reportedly was using Bittorrent to distribute their own application across their servers. I remember outreach presentations where they mentioned this over 10 years ago, and this article seems to have some corroborating details: https://arstechnica.com/information-technology/2012/04/exclu...

“huis clos”? It’s commonly used in French at least. https://en.wiktionary.org/wiki/huis_clos

I described some of the process in a previous HN thread: https://news.ycombinator.com/item?id=19567549

There is also a presentation we had prepared for an informal talk: https://github.com/chesseye/chesseye/blob/master/presentatio...

Hope this helps! I always enjoy talking about these things, so feel free to reach out if you want to discuss it more.

Congrats! We tried something similar a few years ago (also at the TC Disrupt Hackathon [1]), but had to take a lot of shortcuts to get to something working. I'm impressed you had the time to train a proper model (we went with old school CV hacks).

Looking forward to seeing what BoardBoss could become. These days I've been wanting a CV app to track backgammon games. Those dice can be pretty tiny though :)

[1] https://devpost.com/software/chesseye

There you go: https://psuter.net/images/z-index-fig-1-alt-preview.png

That's correct. If you're curious about the architecture: the vision part detects a chessboard, then corrects the perspective and restricts the image to just the square of the board, then looks at each square and has some simple thresholds to decide if it's occupied by a piece, and of what color. From there, the camera is treated as a black box sensor that continuously streams two 64-bit masks, for where it thinks it sees white and black pieces. There is a second program (controller) that turns that stream into a stream of chess positions (and a Unix pipe in between). The sensor is faulty of course and the controller has logic for ignoring bits from the mask where there cannot possibly be pieces etc.

We built a barely working version of that during a hackathon a while back: https://github.com/chesseye/chesseye (README has a link to a video).

It takes a lot of shortcuts, works with just the right lightning, etc., but worked great as a proof-of-concept :)

We got away with not identifying the pieces by just detecting the color, assuming the game started from the initial position, and assuming only legal moves (the whole game is unambiguous using these assumptions).

It's all old-school computer vision with hand-written features, and I'm pretty confident there is tons of low-hanging fruit, but who has the time.

A friend+former colleague of mine is the lead author of ReactiveML, a synchronous extension to OCaml: http://rml.lri.fr/

We worked on a hackathon together where we built a physical chessboard interface (https://github.com/chesseye/chesseye). He built the controller, which handles among other things the output from the video recognizer and messages the chess engine, in ReactiveML. I didn't know much about the language beyond first principles then, but was impressed by how easy it made it to compose parallel processes.

We tried to convey some of those conclusions in a later presentation, even though looking at it 2 years later I realize it's probably hard to get the insights without the verbal delivery: https://github.com/chesseye/chesseye/blob/master/presentatio...

(I understand there was a ReactiveML tutorial at ICFP last Saturday: https://icfp18.sigplan.org/program/program-icfp-2018, not sure if this post is related.)

It was definitely a little confusing, as there seems to be many ways of exiting. From the QBasic docs in the IDE:

END: Ends a program, procedure, block, or user-defined data type. [...] If no argument is supplied, END ends the program and closes all files.

STOP: Halts a program.

SYSTEM: Closes all open files and returns control to the operating system.

You may be thinking of:

SHELL: Suspends execution of a Basic program to run a DOS command or batch file.

It is my understanding that QB64 [1] compiles through C++, although I haven't tried it myself. They in theory support a superset of QBasic, and you could compile the C++ generated files using emscripten (again, in theory).

[1] https://en.wikipedia.org/wiki/QB64

Thank you!

On a "warm" invocation, almost all the time goes into DOSBox + QBasic.

Not precise measurements but: on my MacBook Pro, running the QBasic interpreter from within DOSBox consistently takes about 1.5 seconds & running DOSBox + QBasic from the shell in "headless" mode takes about 2.4 seconds.

OpenWhisk also gives me the logs of the invocations, which include debug lines produced by DOSBox, and from the timestamps in those I can tell that invocations do typically spend >2s running DOSBox.

Thanks, this is great!

I think you mean 'guinea pig' :)

Do you foresee an enlargement in the total number of speakers? Why?

In total number of speakers, it's possible, and I think it's been the case historically (just by general population growth). In relative numbers (fraction of the population), it's been shrinking and I don't see this changing. Main reasons are that:

  a) as mentioned in the BBC article, people move, and it's very difficult to keep the language after one or two generations if you don't live in that region,
  b) even if you were to move to a Romansh-speaking area (as a Swiss national or as an immigrant), the incentive to learn is low because almost everyone also speaks (Swiss-)German.

national language

It has a slightly different status than the other 3 languages, Wikipedia explains it well [1]. I don't know if you could get citizenship that way but you'd definitely be on the news.

[1] https://en.wikipedia.org/wiki/Romansh_language#Official_stat...

MX3 is a platform curated by the national radio stations in all four languages. The playlist by Radio Rumantsch would be a good start: https://mx3.ch/p/2ev (not all the songs are in romansch in there, though).

I speak Romansch (although poorly, by now), AMA. (Or even better, out yourself as a fellow speaker!)

I'm not sure it was ever the goal that everyone would _speak_ Rumantsch Grischun, as it is called, but the hope was that at least it would be used in writing (e.g. in school books) [1]. The resistance there is arguably more surprising.

[1] This is not too different from the situation with High German being used in education even though everyone speaks in dialects.

Nice tool! Not too obvious from the landing page that there is a terminal version. Also, some units come with implicit assumptions:

    ≫ 1 month -> days
      1 month -> d
       = 30.4167 d
    ≫ 1 year -> days
      1 year -> d
       = 365 d

zenodo.org lets you archive code and data, generates DOIs, has a GitHub integration, and is maintained by a reputable team. I recommend it wholeheartedly.

Paper describing the processes of recovering historical versions, attribution, and creation of the repo: https://www.dmst.aueb.gr/dds/pubs/jrnl/2016-EMPSE-unix-histo...

If you only look at the GitHub repository, look at the branch listing.

(I'm not the author, just an admirer of the work.)

One thing JIT compilers are good at is specializing methods for common (runtime) types; e.g. you have a method operating on Iterable but it turns out most of the time you get a List as input; you can generate code that bypasses the method lookups for .size etc. The question of whether this pays off is usually only answerable at runtime.

Do you mean https://github.com/apple/swift ?

FWIW, OpenWhisk, while available on IBM Bluemix, is also open source and can be run wherever you so desire: https://github.com/openwhisk/openwhisk

To a large extent it would seem the Solar Impulse team agrees with you:

What we are working on now [...] is to build an airplane which has no pilot. [...] an unmanned version which could fly six months, maybe one year

[1] http://videos.usatoday.net/Brightcove2/29906170001/2016/01/2... 0:47 onwards

I went from O1 to EB1 and had to resubmit all evidence (and then some). There is definitely an opportunity for reuse, so assuming you didn't throw it all away, it should be easier to assemble your case than if you were starting anew. (I'm not a lawyer. Sample size N=1.)

From [1]:

08/24/1993: Ken signs employment agreement with Apogee Software Productions. A special provision on the contract says that Apogee cannot interfere with Ken's education.

Inferring from the first entry in the timeline, he must have been 17 or 18 then.

[1] http://advsys.net/ken/build.htm

For those interested in the topic, we ran a related set of experiments recently [1], and cross-referenced npm packages with (a subset of) Javascript GitHub projects to see how packages and versions are used in practice.

[1] http://www.apiful.io/intro/2016/06/01/npm-analysis.html