Conlectus

What happens when the ASCII character for space is embedded within a multibyte UTF-8 codepoint?

This is irresponsible reporting. The authors themselves have clarified that this is an _association_ study, whereas the above article claims that isolation is _causal_ to increased dementia risk.

From the authors:

> We agree with Dr. Kawada that no casual conclusion should be made in the present study, as it is an association study. We avoided using terms that imply causal inferences in the paper.

Yep, I'm aware ("ahead of its replacement"), but in the mean time it really helps to have something that just solves the "take these two modules and merge their functions" problem.

Given my experience, I would not recommend using Wasmer over an alternative like Wasmtime for several reasons.

1. Lack of support for `externref`, AKA opaque references to host data. Sure, the Wasmer 2.0 blog post _claims_ they added support for it, but that amounts to allowing you to read the type signature in an existing module, but not actually use the feature yourself. With some digging, my educated guess is they wanted this to be their headlining 2.0 feature but weren't able to get it working, so they just pretended in their blog post and left the incomplete version behind a development flag.

2. An awkward context API for host calls. All host data associated with an instance must be `Send` + `Sync`. In practice I've found this leads to wrapping your entire context object in a `Arc<RefCell<T>>`, even if your data could otherwise live on the stack. Wasmtime does not have this limitation, so it's not a hard technical requirement.

3. It took me about 2 weeks of development to run into a use-after-free bug bubbling up into Rust.

4. The performance, at least for my use case, was not meaningfully better than Wasmtime. This may not be true if you're doing a lot of intense number crunching.

5. Lack of support for instance resource allocation pools. Wasmtime allows you to pre-allocate / reuse the resources associated with an instance, whereas you would have to roll this on your own with Wasmer.

6. Lack of support for the module linking proposal. This proposal may be incomplete, but it is still helpful ahead of its replacement.

This is on top of, as others have mentioned, their questionable business practices[1][2].

All of this may improve, but as things currently exist, Wasmtime should give you everything you would want from Wasmer in a more stable, more complete and more ergonomic package.

[1]: https://mnt.io/2021/10/04/i-leave-wasmer/

[2]: https://wasmer.io/posts/wasmer-and-trademarks

Adding on: Though there is no consensus, I believe that is now the less-popular theory for the origin of spiciness. It seems instead to be a form of pesticide and fungicide.

Evidence for this is that pepper varieties tend to be spicier in wetter environments, where the biological resources spent on producing capsaicin to fight fungus are more valuable than preserving them in case of drought.

Source: https://sitn.hms.harvard.edu/flash/2012/issue131b/

The term is "Höschen fur ficken"

> Höschen means panties, and ficken means, well…

Hint: Dutch is a close cousin to English. Try just pronouncing it.

This is a bit out out of date. Interpolation colorspace can be specified as of CSS Color Module Level 4. See https://drafts.csswg.org/css-color-4/#interpolation-space

I don't believe it is yet implemented in browsers, but I know Chrome at least is working on it.

I believe because some organizations require "wet" signatures on documents, and ask to be emailed scans of those signatures.

This would assumedly let you use an image of your signature rather than printing and signing.

I believe they meant that it was the gambling that was being laundered (disguised) not the money.

The above commenter likely is familiar with the expression, but they are being an obnoxious pedant about your use of the word "literally", which usually means "without metaphor" or exaggeration.

Gotcha, that makes sense. I look forward to digging into the code myself :).

Looks nice! The inline REPL functionality reminds me a lot of the (defunct) Light Table[1].

[1]: https://www.youtube.com/watch?v=H58-n7uldoU

Wouldn't this be true of any form of replication, including whatever Postgres uses? Or is the proof of correctness for Raft weaker than some other class of consensus?

Edit: from rqlite's FAQ

> Raft is a Consistency-Partition (CP) protocol. This means that if a rqlite cluster is partitioned, only the side of the cluster that contains a majority of the nodes will be available.

Disconcertingly, this sounds like they assume that only one side of a partition can contain a majority of nodes. This isn't true if the partition is partial, eg A<-->B, B<-->C, A<-/->C.

I found this to be a compelling counterargument to Blow's alarmism about forgotten knowledge in tech https://www.datagubbe.se/endofciv/

A related point: numerically there are far more low level developers now than there were in past he idealizes. No such knowledge is being forgotten, it is used and innovated upon regularly. It may be in less frequent use, but is still there if needed.

You may be interested to know that Wikipedia has a page dedicated to such redesigns[1]. Perhaps there are some to draw inspiration from. Regardless, maybe it would be worth contributing to the list.

[1]: https://en.wikipedia.org/wiki/Wikipedia:Unsolicited_redesign...

A problem with this is that when a website breaks in one browser, but works in another, I imagine most people's reaction would be to blame the browser. This leads to a kind of race-to-the-bottom for browser compatibility. See for example the history of User-Agent strings.

Not to be rude, but: caring about people other than yourself. This reads to me like asking a doctor why they advocate healthy living seeing how that would lower their demand.

Perceptual hashes are not exact hashes, otherwise they would be useless for this task; you would just mirror the image or change 1 pixel.

They are instead fuzzy classifiers, and thus have non-zero error rates.

Worth noting that the spec was abandoned in part because enabling it actually makes you more likely to be tracked. It's another datapoint that can be used to fingerprint your device.

I suppose I must have misinterpreted this line

> As such, any sort of failure either with ZomboDB itself, between Postgres and Elasticsearch (network layer), or within Elasticsearch will cause the operating Postgres transaction to ABORT. [1]

In my defense, there is a fairly important distinction between "any error that ES is capable of reporting back" and "any sort of failure within Elasticsearch".

That said, I and trust that you're more familiar with consistency levels than me, so I'll bow out here.

[1] https://www.zombodb.com/documentation/things-to-know/

Though I have only a recreational interest in datastores, I would be pretty wary of a service that claims to strap a Consistant-Unavailable database (Postgres) to an Inconsistent-Available database (ElasticSearch) in a useful way.

Doing so would require ElasticSearch to reach consensus on every read/write, which would remove most of the point of a distributed cluster. Despite this, ZomboDB's documentation says "complex aggregate queries can be answered in parallel across your ElasticSearch cluster".

They also claim that transactions will abort if ElasticSearch runs into network trouble, but the ElasticSearch documentation notes that writes during network partitions don't wait for confirmation of success[1], so I'm not sure how they would be able to detect that.

In short: I'll wait for the Jepsen analysis.

[1] https://www.elastic.co/blog/tracking-in-sync-shard-copies#:~...

Twitter also sucks for meaningful interaction, in my opinion.

Yes, you're right. I misremembered the problem and thought a greedy algorithm would work in that case.

It still seems to me that bowl-stacking is solved by sorting alone, though, which is of course much simpler.

Is the algorithm different from a simple sorted order in this case? The difficulty with TSP is that you have to return to the start, which wouldn't seek to be the case with stacled bowls, unless you're stacking them in a ring somehow.

Warble - Twitter

This surprises me. The shim should only introduce the latency of a single disk read, right?

Have you seen a difference yourself, and if so, could it have been from the overhead of loading gems instead?

I don't follow how an "async backend" would help over threads in this case. If you mean using actors everywhere and moving that into client code, you effectively have a new framework.

Likewise, async IO has high throughout but often trades that off for increased latency jitter, since requests can block each other because of the limited thread pool. This is less a problem with threads because of preemption (though they of course compete for shared resources like database time).

Excellent to see, the ESC ambiguity problem is one that has especially bugged me.

I hope there's a plan to standardize this with the relevant organizations! I worry that's the only way to see widespread adoption.

Commenting in no way on any such effects, droughts and famines have been a fairly regular feature of Russian history.

https://en.wikipedia.org/wiki/Droughts_and_famines_in_Russia...

Yes, it is. The popularly cited studies these days suggest an upper limit of one second to ensure a user maintains flow.