Joseph Gentle

This is an amazing writeup, and something I've often wondered about!

For those who want to skip to the code, the article links to these resources:

https://www.ggpo.net/

https://drive.google.com/file/d/1nRa3cRBQmKj0-SEyrT_1VNOkPOJWNhVI/view - a writeup on the GGPO library including code samples of how it works

For an example of what GGPO feels like when implemented in a game from day one, this Reddit thread illuminates what's possible: https://www.reddit.com/r/Games/comments/lolukg/guilty_gear_strive_beta_extended_to_feb23_due_to/go6qxi2/?context=3 - "I was playing matches with a friend in Denmark from the east coast of the US without any issues whatsoever. It's like black magic. If this kind of netcode is what we have to look forward to with GGS, I literally won't play any other fighting game that doesn't have it from here on."

Taking a step back from gaming applications though: I'd love to see a convergence between those researching CRDTs and those who have implemented rollback netcode in the wild. This article from September 2020, by one of the contributors to Google Wave back in the day, is a great overview: https://josephg.com/blog/crdts-are-the-future/

There's a fascinating confluence of talents needed to generally solve the problem of "how do you keep people in a flow-state when collaborating in the presence of network delay" - which is more applicable now than ever. There's psychology, user experience design, user interface design, deep domain knowledge,…

Let me give a little anecdote -- Apparently according to a previous post, there are three tribes of programmers[1] The hackers, the makers and the poets

In my view there are actually other tribes, for example `the fixers` which I personally feel I naturally belong to --

Well I used to work with a fellow from Spain, he was a great coder and all, but he called himself a Punk, a Programming Punk and any time he'd show up it would be in some oversized T-shirt of some esoteric punk band

Not that I didn't like the guy, but I simply didn't relate to his sense of professionalism which I found rather brash and arrogant -- I felt like he would harm my relationships with certain kinds of clients by what amounted to egotism

Well, we were thrust together due to managerial allocations and I was forced to work with him, but I wasn't very glad about it. I kept thinking like "I'm sacrificing time with my kids to be with this Lone Ranger and he's not really giving me the emotional surface area I need to get my job done expediently'

A lot of rookies would internalize this and tell themselves whatever they need but as an adult I found his behaviour simply moronic and that is one albeit small example of why I actually care about the behaviour and attitude of the people around me

edit:

[1] https://josephg.com/blog/3-tribes/

I don't think that quote is complete enough though. If you really believe that programming languages are just tools for building programs (in particular "useful" programs that make money) then yes, Haskell has not much to offer you over PHP or Ruby and other languages in that vein.

On the other hand if you are interested in research, exploring the extent of the design space for programming languages and what you can (or can't) express in them, then Haskell is an excellent language for you. Both for the community of like-minded researchers and for the flexibility of the language/compiler itself.

On a wider scale, I've always liked https://josephg.com/blog/3-tribes/ as an explanation for why this topic comes up again and again and again. The writer of the article is more of a "type 3" programmer. He wants to build a house but does not care much which tools he uses as long as they don't get in the way. It is the end result they are interested in, not the process. Haskell is, by design as a research language, more process oriented than result oriented. And yes, you can still get results with it as IHP and SC and Jane Street have shown. But they seem to be the exceptions that show the norm.

I've been testing Chrome headless extensively for the past few months, and while it's a good step, but it's not stable for high-volume or even diverse set of webpages.

Memory usage is pretty high, lot of heavy webpages result in crashes/hangs, there are many inconsistencies between features available in full version and headless, their debugging protocol has different APIs that work on headless/non-headless in Linux or Windows, and so on.

Of the bugs I've submitted, some have been fixed in the upcoming M59, so other critical ones may take longer due to their backlog. I suppose for now (maybe until M61-62), Chrome full with xvfb or even PhantomJS are better options. When you realize that Chrome is about the same size (by LoC) as the Linux kernel [1], you can't help but wish for a leaner & faster headless browser.

There seems to be some work going on building Firefox pure headless as well. Great overall, as long as all the browsers try to follow the RemoteDebug initiative [2].

[1] https://josephg.com/blog/electron-is-flash-for-the-desktop/

[2] http://remotedebug.org

Well that is fascinating; I think that was probably enough to call this week a success - thanks for the discussion at https://josephg.com/blog/kegans-social-developmental-milestones/ too, it was easy reading and hugely educational.

Although I don't really feel comfortable just agreeing with someone on HN, so I'll also just poke https://josephg.com/blog/why-i-am-no-longer-a-libertarian/ while I'm on the way through to stay in practice. The complaint against libertarianism could be made against any system. Note that through history the developed world generally just leaves poor nations to starve and fumble for example (well, that is a bit generous - we raided and pillaged them). On the spectrum of pure authoritarianism to pure libertarianism, the system that has the best chance of finding a reason for the wealthy to help the poor turned out to be liberty. And within libertarianism there is a lot of room to negotiate over how mineral rights and economic rent are handled.

You can use CRDT algorithms with Braid that heal from network partitions transparently, and guarantee strong eventual consistency. Here's an example CRDT algorithm for collaborative text that can handle arbitrary network partitions, and guarantee full eventual consistency, and prune all unnecessary history:

https://braid.org/antimatter

This algorithm is the first to do so, and happened to be developed in the Braid group.

As for scaling, check out JosephG's https://josephg.com/blog/crdts-go-brrr/ CRDT, which scales great, and is thoroughly tested. The Braid protocol is also architected with a new type of OT/CRDT architecture called a Time Machine that lets you do advanced things like apply backpressure through a network to decrease the frequency of updates, which we presented in https://braid.org/meeting-81, and are releasing in the https://github.com/braid-org/braid-text library that you can try right now.