Comments URL: https://news.ycombinator.com/item?id=47409097

Points: 3

# Comments: 0

I've often wondered about this, so I'm curious to learn more. I agree in principle we should be more clever to ensure we have better memory use. However, half the implementations in the list you've linked use a growth factor of 2, so I'm confused about your point.

If it's not the best, what is? Do you know why these implementations opt for 2 if it's not the best choice?

While methods like linear or polynomial regression can be used predict continuous variables like number of patient deaths over time, survival analysis gives us more context and allows us to make inferences about the survival of individuals and populations as a whole, in addition to forecasting illness.

It does this in a few ways, but firstly by giving us a more rich language to discuss survival data. This is where concepts like "censoring", etc. come into play. It should be noted that censoring here does not refer to the colloquial use of the word, but rather the statistical definition [1].

Survival analysis in practice includes training KM-curves, Cox-PH models, etc. by fitting them to the underlying survival data based on this censored data. It's very possible that new and more robust methods have come out since I last touched the subject around 2015. Modern NNs may blow these models out of the water in terms of pure predictive power, but from a population-modeling perspective survival analysis would likely still be very useful.

[1] https://en.wikipedia.org/wiki/Censoring_(statistics)

> the metrics that guided us during the [zstd experiment] revealed a surprising behavior

This feels so backwards. I'm glad that they addressed this low-hanging fruit, but I wonder why they didn't do this metrics analysis from the start, instead of during the zstd experiment.

I also wonder why they didn't just send deltas from the get-go. If PASSIVE_UPDATE_V1 was initially implemented "as a means to scale Discord servers to hundreds of thousands of users", why was this obvious optimization missed?

Why would one sell permanent ownership of a networked product? I've been seeing the rise of "lifetime" subscription levels (pay once) for SaaS products, but I'm curious as to what the actual long-term economics of it are.

If your cost of operations is not a one-time cost per user, I don't see how you can avoid a subscription model.

When users subscribe they should be purchasing a license that renews periodically. Local-first apps should validate the license (based on its expiry) by connecting to the internet to ensure users are subscribed. If they're not subscribed or they don't have internet access, they cannot use pay-walled features. You should offer a free, fair, and robust export tool for those not subscribed, though unfortunately not many companies do this.

What am I missing here? The drawback is of course when customers don't have internet access but are still valid subscribers, so they lose access to pay-walled features. One option would be to only offer annual licenses (infrequent license checking), another would be to offer a complementary 7 day license extension for the short-term until the user reconnects to the internet (grace period).

Stop giving away your value proposition for free. Get paid fairly.

Where is your ground truth? How collaborative is a given resource? How are merge conflicts (or any overlapping interactions) handled? Depending on your answers, CRDTs might be the wrong tool.

Please don't forget about straightforward replicated state machines. They can be very easy to reason about and scale, although require bespoke implementations. A centralized server can validate and enforce business logic, solve merge conflicts, etc. Figma uses a centralized server because their ground truth may not be local.[1]

If you try a decentralized state machine approach the implementation is undoubtedly going to be more complex and difficult to maintain. However, depending on your data and interaction patterns, they still might be the better choice over CRDTs.

It could be argued that even for this example, two local-first clients editing the same file should not be automatically merged with a CRDT. One could make the case that the slower client should rename their file (fork it), merge any conflicts, or overwrite the file altogether. A centralized server could enforce these rules and further propagate state changes after resolution.

[1] https://www.figma.com/blog/how-figmas-multiplayer-technology...

I'm only half-joking :)

I very much relate to the dropdown example, and I've found that complicated UX patterns can be extremely awkward to implement and maintain in LV.

One example from my experience that was prickly to implement in LV was graying out a chat message you sent if it didn't get acked or persisted by the channel/server for any reason.

Can't wait to try this out in my next project!

After witnessing the architecture of both ancient and (relatively) modern Eastern/Southeastern structures, I found the Sagrada Familia lacking. It came across somewhat soulless with its bleached cavernous interior and uninspired stained glass artwork.

That came across harsher than I truly feel, but I think it's garnered some undeserved hype especially after 100 years of construction. I wonder what structures inspired Gaudi that may be lost to time, and what feelings he wanted to evoke in me that I didn't experience during my visit.

It derives from David McCullough's quote, "Writing is thinking. To write well is to think clearly. That's why it's so hard."

In order to arrange the right words in the right sequence to convey the right message, you're required to organize your thinking, and also consider how it might be consumed.

To bring it back home, I suppose the same could be said of writing code.

---

As an aside, McCullough wrote my favorite biography, John Adams.

Why couldn't they have an option to keep the old animation? In 2022, it should be that simple, but of course...

It's not that I loved the old animation, but rather that I can't stand the current one. It's like I'm rotating a deck of cards, taking one off the top of the pile and putting it underneath. Not very pleasant to me, and also not an animation style I've seen used in any other book apps to my knowledge. I wonder why that is?

What are the alternatives here? Write the assembly in a separate file and provide a FFI?

Of course, the (potential) drawback is in using Elixir for both front-end and back-end which may be a tough sell to a client or employer.

-----

[1]: https://blog.appsignal.com/2021/09/28/real-time-form-validat...

[2]: https://hexdocs.pm/ecto/Ecto.Schema.html#module-redacting-fi...

[3]: https://elixircasts.io/ecto-virtual-attributes

It's potentially easier to understand an individual's biases on a per-article basis than something like the NYT, especially if you follow them and their perspectives over time.

I'm happy for you.

I've found that editors tend to do one thing or the other very well: they're either really good editors for rich text and multimedia or really good editors for code.

What tools balance the best of both worlds?

Comments URL: https://news.ycombinator.com/item?id=29908720

Points: 19

# Comments: 7