Neil Fraser

I remember reading this here a while back - wonder what happened:
https://neil.fraser.name/news/2015/04/13/

But like others in this post I would recommend CS unplugged.

And depending on how long he is in there for he might want to look at:

How to Design Programs - This is a good book, and although it's in Scheme, it teaches how to create appropriate levels of abstraction, which seems to be something many programmers struggle with.

Concepts, Techniques & Models of Computer Programs - Discusses the different paradigms and how they are inter-related.

Also something a bit more vocational like The Pragmatic Programmer or Clean Code / Clean Coder probably wouldn't hurt either.

If he can read all of those he will be very well prepared to do some actual programming when he gets out.

SICP not a bad shout either, although I've not got past the first chapter.

While OTs (there are several variants) are a promising approach for distributed authoring, I think the complexity of implementing them is still prohibitive. Surely there is a better way...

I have been reading papers on this looking for a "clean" way to solve this (in the context of packet loss, latency, etc).

One good approach I was able to understand is Neil Fraser's Differential Sync http://neil.fraser.name/writing/sync/eng047-fraser.pdf

There are other approaches out there. One example which uses character based changes and is worth checking out is here:
PAPER wikisym.org/ws2010/tiki-download_wiki_attachment.php?attId=15
CODE https://github.com/gritzko/ctre

I feel like it is time someone solved this collab. editing thing once and for all and shared the code with everyone. (Firepad? https://github.com/firebase/firepad/)

That reminds me of the JavaScript interpreter written in JavaScript (which is used for Scratch, I think) - that supports stepping through multiple instances of the interpreter to achieve a kind of interleaved concurrency.

https://neil.fraser.name/software/JS-Interpreter/docs.html#threading

> JavaScript is single-threaded, but the JS-Interpreter allows one to run multiple threads at the same time. Creating two or more completely independent threads that run separately from each other is trivial: just create two or more instances of the Interpreter, each with its own code, and alternate calling each interpreter's step function. They may communicate indirectly with each other through any external APIs that are provided.

> A more complex case is where two or more threads should share the same global scope..

> text editing as the de-facto solution is so weird to me since that problem is both niche and extremely complex.

My first foray into collaborative editing was for my text editor. Indeed, things get super linearly harder as you add basic functionality of editors such as deleting and replacing, especially when those space multiple lines.

Instead, I reached for Fraser’s differential syncing. https://neil.fraser.name/writing/sync/. There’s a lot of ambiguity and nuances in various versions of the prose and white paper that I could never really flesh out.

I think anyone attempting to relay a collaborative editing algorithm needs to do is start with the simplest scenarios: append only / monotonically increasing data.

This blog post from Google engineer Neil Fraser made the rounds 4 years ago: https://neil.fraser.name/news/2013/03/16/

He traveled to Vietnam and observed a high quality Computer Science education in primary / secondary school. Talking about grade 11 scholars, he wrote:

After returning to the US, I asked a senior engineer how he'd rank this question on a Google interview. Without knowing the source of the question, he judged that this would be in the top third. The class had 45 minutes to design a solution and implement it in Pascal. Most of them finished, a few just needed another five minutes. There is no question that half of the students in that grade 11 class could pass the Google interview process.

You are completely assuming that everyone who wants to program is intending to do so professionally, or that they won't be able to grow from a basic intro of "here is how to present your thoughts programmatically" and then cover the deeper subjects later, as they need to.

This is especially relevant as we start teaching programming at younger and younger ages. I hope it's obvious that when kids start programming in 4th grade, it's much more intuitive to start them on Logo than lambda calculus...

See, for example:
https://neil.fraser.name/news/2013/03/16/

Also, if you look at the amount of money that "Flappy Bird" made, perhaps making brain-dead iPhone apps isn't such a bad deal...