Joseph Gentle

I think it's that the few enthusiastic fans make such hyperbolic statements, they create drama and stand out among the majority of reasonable users of the language. They attract attention of the people who are curious about the language, and give the impression that the community is hyping it up too much. The other day I saw a developer who works on the Rust language saying, please tone it down because it's making us look like fanatics. It's healthy to acknowledge that the language is not perfect, it has room to improve, even some fundamental flaws. Oh, I recognize your user name, recently read a great article you wrote - here it is. This was really informative and interesting. Rewriting Rust - https://josephg.com/blog/rewriting-rust/

This reminds me of the "three tribes of programming: mathematical poetry, machine hackery, and business value". I think each SWE gets similar but different feelings of satisfaction. I knew a coworker who cared about the result, and little about the code he wrote. This was foreign to me when I saw it, as I was and still am definitely in the love for "math poetry" camp when it's possible. https://josephg.com/blog/3-tribes/

https://josephg.com/blog/electron-is-flash-for-the-desktop/ Please use native toolkits. At least Gtk or Qt :) Flash is just “We don’t like to pay developers. We prefer you to pay more for memory. And your processor. And by the why, we don’t care about your security.” Ironically memory prices are skyrocketing right now. Even the best known Electron application (Signal) is eating memory like it is free. Similiar native applications integrate much better and use a fraction of memory (e.g. Fractal). PS: If autonomous locally usage doesn’t make sense a mere web-app is good way. At least it is then a single tab in the web-browser and most platforms are covered (if you don’t target Chrome exclusively…). In this case possible step? At least not 500 MB wasted.

If you're just getting started with CRDTs I'd also recommend Seph's "5000x faster CRDTs" post[1] and also his "I was wrong. CRDTs are the future" post[2] for some nice captures of the practical challenges and opportunities in the space. [1] https://josephg.com/blog/crdts-go-brrr/ [2] https://josephg.com/blog/crdts-are-the-future/

I'd love that! For my CRDT work, I stare at a lot of graphs to figure out bugs and optimize. For example, here's the causal graph of changes made to git's Makefile: https://josephg.com/git-makefile.dt.svg Having a nicer way to render these graphs (and especially show them in the browser) would be delightful!

I would start by taking a look at this article; it helped me understand what it is that I personally get out of programming: https://josephg.com/blog/3-tribes/ But I would also say, I don't think there's anything wrong with not enjoying it any more. Few people can do something for decades and still take joy in it. It's great if you can rekindle the fire, but it's also okay if your interests drift elsewhere.

https://josephg.com/blog/reverse-engineering-apple-dictionaries/ seems like there's someone who outright reverse engineered the format as well. Normally I would recommend going for something via Applescript but it seems like Dictionary.app doesn't expose anything via Applescript (though it totally should)

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.

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… - "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,…

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.

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'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

This was my impression as well. If you ignore the paper and just look at the source code - and carefully study Seph Gentle's Yjs-like RGA implementation [1] - I believe you find that it is equivalent to an RGA-style tree, but with a different rule for sorting insertions having the same left origin. That rule is hard to describe but can eventually be proved commutative; I'm hoping to include this in a paper someday. [1] https://josephg.com/blog/crdts-are-the-future/

Let's balance the discussion a bit. https://josephg.com/blog/crdts-are-the-future/

The ‘three tribes of programming’ [1] strike again! This thread is full of claims that ‘programming is really engineering’ (in accordance with the article), ‘programming is really building’, or ‘programming is really philosophy/mathematics’. They're all true! It's not that one of them is the True Nature of software and anyone doing the others is doing it wrong or at a lower level. These are three different things that it is completely reasonable to want to do with software, and each of them can be done to an amateur or expert level. But only one of them is amenable to scientific analysis. (The other two are amenable to market testing and formal proof, respectively.) [1]: https://josephg.com/blog/3-tribes/

Reminds me of the three tribes of software programmers. https://josephg.com/blog/3-tribes/amp/ Mort == maker Elvis ==? hacker Einstein == poet

CRDTs are not inherently “crazy slow”. Researchers just don’t succumb to the appeal of premature optimization. See: https://josephg.com/blog/crdts-go-brrr/ (And even these optimizations are nascent. It can still get so much better.) The section you quoted describes an effect of homomorphic encryption alone. There is the problem that both CRDTs and encryption add some overhead, and the overhead is additive when use together. But I can’t tell if that is the point you are trying to make.

This split does exist, and I often refer others to https://josephg.com/blog/3-tribes/ There's a 3rd type of programmer, besides the first two you mentioned.

> Algorithmically, this is an interesting problem but it should be quite solvable. Just, for some reason, nobody has worked on this yet. So, thanks for writing this post and bringing more attention to this problem! I'm skeptical that an algorithmic solution will be possible, but I can see this being handled in a UX layer built on top. For example, a client could detect that there's been a conflict based on the editing traces, and show a conflict resolution dialog that makes a new edit based on the resolution. The tricky part is marking a conflict as resolved. I suspect it could be as simple as adding a field to the crdt, but maybe then it counts as an algorithmic solution? [1] https://josephg.com/blog/crdts-go-brrr/

Waved used OT not CRDTs: https://josephg.com/blog/crdts-are-the-future/

I don't have any experience with this, but the use of flat arrays (rather than unbalanced trees) in Yjs sped things up considerably according to this long and interesting blog post below. https://josephg.com/blog/crdts-go-brrr/ "We can use a flat array to store everything, rather than an unbalanced tree. This makes everything smaller and faster for the computer to process."

It's already bad enough that people, by default, are not aware of the frame of reference in which they see the world, let alone communicate with. As just a very simple example, unless I am explicitly clear about speaking from a Living Systems world view and a regenerative paradigm, when I talk about permaculture design here in this forum, I end up talking past the vast majority of people here on HN. But even staying with the same shared technological world views and paradigms -- the people across the Three Tribes of Programmers (https://josephg.com/blog/3-tribes/) will get into flamewars because the frame differs in distinct ways. Because a schema makes distinctions on information in a particular way, it will always encode a frame in which to view and understand that information.

So exciting! Strangely enough, a couple of hours before this release, we just managed to wrap our heads around Yjs after playing with it on and off for a few weeks! For anyone not up to date with the world of CRDTs, Seph Gentle's two blog posts have become legendary: * https://josephg.com/blog/crdts-are-the-future/ * https://josephg.com/blog/crdts-go-brrr/ these are also worth checking out: * https://github.com/y-crdt/y-crdt (rust implementation started by the creator of Yjs, Kevin Jahns) * https://github.com/y-crdt/ypy (python bindings for the rust implementation) * https://github.com/josephg/diamond-types (Seph Gentle's rust implementation of YATA, the algorith behind Yjs)

So am I, and yet we hold different opinions about which languages to choose for different purposes. This article might interest you: https://josephg.com/blog/3-tribes/ (you seem to be tribe 1, I'm probably tribe 3)

https://josephg.com/blog/3-tribes/ This what you're looking for?

Your comment reminded me of this article[1] that has probably been posted plenty of times on HN. You've described both the "hacker" and the "mathematician" tribes. [1] https://josephg.com/blog/3-tribes/

Grandparent wrote a good article on CRDT performance https://josephg.com/blog/crdts-go-brrr/

Thank you for posting this code on Github! There has been some reverse-engineering done on the language dictionaries bundled with Mac OS, and it's nice to know that the same model is being used on the Apple Watch! I look forward to seeing your dictionary app. https://josephg.com/blog/reverse-engineering-apple-dictionaries/ There's also a command-line tool that can query the dictionary: https://github.com/takumakei/osx-dictionary Something I haven't yet reverse-engineered is Apple's word segmentation. I can get the word breaks in Chinese by pressing option + right arrow + space, repeatedly. But I have no idea how the backend for that works.

You probably don't want to use Automerge. See https://josephg.com/blog/crdts-go-brrr/ for a nice CRDT optimization story.