enum

Give this notebook a shot:

https://github.com/arjunguha/BigCode-demos/blob/main/bigcode...

A GPU will help, but I found it passable on a CPU as well.

Stopify is a JS-to-JS compiler. It performs a lot better than a JS-in-JS interpreter could.

All the selectable languages compile to JavaScript. Stopify takes that JavaScript output and makes programs stoppable, steppable, etc. Therefore, each demo is a composition of two compilers: (1) a third-party X-to-JS compiler and (2) Stopify, which compiles JS to stoppable JS.

Fixed and added a little FAQ. :)

It depends on the source language. We have done extensive benchmarking. For example, on Python the median slowdown is 1.4x. PyJS doesn't use all of JavaScript's features and we can exploit that to improve performance. Our worst slowdown is when the source language is JavaScript itself because we can't make simplifying assumptions. (Median slowdown is 20x.)

These are slowdowns on a cheap ChromeBook. We also have results from the four major browsers on a desktop machine.

We'll put more technical details on the website very soon. Since you asked for an abstract, let me reply via DM on Twitter. (I'm @arjunguha)

Hi @amasad,

In collaboration with @jpolitz, we've been working on way to debug programs written in arbitrary source languages in the browser that you may find interesting. You can find a technology demo here:

http://www.stopify.org

Stopify uses existing compilers that produce JavaScript (e.g., ScalaJS, BuckleScript, etc.) We've tested with ten languages, five of which are on the website. There are three key pieces to Stopify: (1) first-class continuations for JavaScript (warts included), (2) browser-specific optimizations, and (3) language-specific optimizations (i.e., many compilers emit a sane subset of JavaScript that Stopify can exploit to improve performance). We've conducted a pretty extensive performance evaluation that we can also share. E.g., we've found that PyJs + Stopify can be as fast as Skulpt with suspensions.

This abstract suggests that the bound may be lower:

http://jointmathematicsmeetings.org/amsmtgs/2160_abstracts/1...

From http://jointmathematicsmeetings.org/meetings/national/jmm201...

Cool stuff. I think it's similar to custodians in Racket (the artist formerly known as PLT Scheme):

http://docs.racket-lang.org/reference/eval-model.html#(part....

> In Haskell, when I read an API, I know no effects lurk behind the pure type signatures.

I wonder how often unsafePerformIO : IO 'a -> 'a is employed

For example:

http://www.cs.ucla.edu/~kohler/class/10f-aos/

On current releases of PLT Scheme, you can use:

#lang plai

to write the programs in the book, instead of using PLaneT.

Yep, reactive programming. You can do this in JavaScript too: http://www.flapjax-lang.org/

"Practical Foundations of Programming Languages", available online:

http://www.cs.cmu.edu/~rwh/plbook/book.pdf

I believe it's feature size: http://en.wikipedia.org/wiki/Photolithography

UW has a terrific CS program. You will learn a lot.

Based on Fig. 1 and the text describing it, the study seems to conclude that imperative programming is unlike anything students have seen before.

"all had enough school mathematics to make the equality sign familiar."

Sure, but = in imperative code is nothing like = in math. It's hardly surprising that it is confusing.

grad school is a 5+ year commitment. Launching a startup probably takes less time. Also, grad. school is not about entrepreneurship. Perhaps there are transferable skills, but research has different goals.

DrScheme

Is Python really pulling a syntactic trick?

I think < is simply left associative: True < 4 is True.

Similarly, I think > is right associative. (50 > 30) > 10 does not hold, but 50 > (30 > 10) holds.

You don't have to learn Emacs. Also, Common Lisp isn't the only option. Try Scheme, this one: www.drscheme.org.

Misses laziness, which is arguably the most confusing part.

I think :set wildmenu is great, especially for relative newbies such as myself:

  command! CD cd %:p:h " change to current buffer's directory
  set incsearch " Incremental search
  set hlsearch " Highlight search
  set guifont=Bitstream\ Vera\ Sans\ Mono\ 12
  set nowritebackup " no stupid backup files
  set noswapfile    " no stupid recovery files
  set wildmenu " it's wild
  set visualbell
  set fileformat=unix

It's great what you can do with first-class functions. But, without tail calls, simple uses of the Y combinator will run out of stack space.

Michael Spivak's Calculus text:

http://www.amazon.com/gp/product/0914098918

"I thought laziness was the New Python 3.0 Way, but apparently the New Python Way is susceptible to hairy non-local bugs."

You're using "laziness" in a language with mutation. What do you expect?

If you're willing to understand the program behind the proof, I think it's more acceptable than a handwritten proof.

My experience with motion-control running shoes quite different from what the article reports. My knees stopped hurting once I switched to them.

How about something akin to X-expressions as often found in Lisp/Scheme. For example,

http://docs.plt-scheme.org/continue/index.html#(part._.Rende...

Lambda is fine. The loops are mutating the variable i, so all the lambda share the same i. Apparently, list comprehensions also use mutation--I suppose that's fine.