user2994cb

And the same volume has his proof of the consistency of arithmetic:

http://www.digizeitschriften.de/download/PPN266833020_0039/P...

The paper referenced also defines Gentzen's sequent calculus, an even nicer formulation of logic:

http://www.digizeitschriften.de/download/PPN266833020_0039/P...

An FSA matcher will be O(M) - one state transition per input character.

As does Javascript of course. On the other hand, IEEE754 guarantees correct rounding, so floating point operations on integral values will come out alright (additions and multiplications will be exact within a large range, and inexact divisions will be rounded correctly, so you shouldn't be any worse than using integer operations).

To put the original in more context, David A. Moon is a major figure in the Lisp world: https://en.wikipedia.org/wiki/David_A._Moon

You can construct the complex numbers quite nicely with Geometric Algebra: https://www.youtube.com/watch?v=PNlgMPzj-7Q

It's true that the original non-recursive definition of Y doesn't typecheck in Haskell:

  Prelude> \f->(\x->f(x x))(\x->f(x x))

  <interactive>:5:14:
    Occurs check: cannot construct the infinite type: r0 ~ r0 -> t
    ...

Interesting stuff. Maybe there is a connection with the use of quaternion pairs to represent rotations in 4-space (as in the Coxeter paper).

> Location: Los Angeles, Prague

It's still a bit early if he's in LA, particularly as it's Sunday.

I forgot to add (1945) to the title, apologies.

Useful discussion on Stack Overflow: https://stackoverflow.com/questions/16198700/using-the-extra...

Upshot: you can probably get away with it if you are careful to canonicalize pointers before using them.

I came across this series of YouTube videos by Aubrey Clayton on Bayesian Inference (based on Ed Jaynes' book, 'Probability Theory: The Logic of Science') that I thought explained the fundamental ideas extraordinarly well but judging by the viewing figures, are not widely known.

There is a neat way of doing this style of indexing using barycentric coordinates: https://www.shadertoy.com/view/MlVfzG

Building a tagged architecture on top of a stock 64-bit system would be much easier than with 32 bits - current systems use 48 bits for addresses, which leaves plenty of bits left over for the tag (you could even represent all non-floating point values as 64-bit NaNs and avoid the problems with FP mentioned in the article).

An interesting (later) paper about generating the Stern-Brocot tree and the Calkin-Wilf tree simultaneously from a sequence of 2x2 matrices: http://www.cs.nott.ac.uk/~psarb2/MPC/RecountingRationalsTwic...

There is a neat derivation of this from the fact that reflection in a plane with unit normal Q can be represented as P -> QPQ with P and Q considered as pure quaternions (ie. no scalar part).

Previous discussion: https://news.ycombinator.com/item?id=11560122 and Paul Hankin has some more thoughts on the subject: https://blog.paulhankin.net/fibonacci2/

Something like this happened in 1944: crew bailed out from Dornier 217 over London, plane carried on north, landing by itself in the Milton Road allotments in Cambridge: https://www.asisbiz.com/il2/Do-217/Do-217-KG2.2-(U5+DK)/page...

Dan Boneh's Cryptography Part I on Coursera. Will we ever get Part II? Enrolling for Sept 2018 according to Coursera.

Just out of interest (I worked on a table-driven parser for SML a couple of decades ago) - what bits of ML syntax is giving you trouble? I remember one bit that (theoretically) needed unbounded lookahead, and user-defined infix operators were fun.

Code to print both the Stern-Brocot tree and the Calkin-Wilf tree, using the algorithm in that paper:

  def fractions():
      a,b,c,d = 1,0,0,1
      while True:
        yield a,b,c,d
        if a == 1 and b == 0 and d == 1:
          a,b,c,d = 1,c+1,0,1
        else:
          j = (c+d-1)//(a+b)
          k = 2*j+1
          a,b,c,d = k*a-c,k*b-d,a,b

  g = fractions()
  for i in range(100):
      a,b,c,d = g.next()
      print "%d/%d %d/%d"%(c+d,a+b,a+c,b+d)

The audiobook by Jim Norton (aka Bishop Brennan) is a good way in to FW: https://www.youtube.com/watch?v=JAc901X7gK0

Another visualization, using JS to solve the Langrangian: https://matthewarcus.github.io/lagrange/

Actually, having Some(x) be just a pointer to x seems to work fine without an explicit tag, as dragonwriter says below.

Dunno, but I'd have thought that you can make None look like a null pointer, but Some(p) needs to be tagged in some way.

Aren't null pointers just a variation on the Maybe Monad?

2014 interview with Delany about this here: http://shetterly.blogspot.co.uk/2014/07/a-conversation-with-...

Generating necklaces and bracelets is fun too, see eg. http://www.sciencedirect.com/science/article/pii/S0304397512...

Looking at it a bit more - the double recursion in the radiance function for refraction would make things a bit awkward in WebGL.

Looks like it would make a nice glsl/WebGL fragment shader (might be even shorter as the vector operations are predefined). Can't see one listed on the page, but then it's mostly from a few years back.