Threads for mayli

  1. 1

    I wonder if there is a lighter kv database with multi-index support. With pre-generated aggravation such as count, group by and sum.

      1. 12

        Read the rest of this story with a free account.

        no thanks

        1. 6

          I’m using scribe.rip as an alternative frontend to medium. Just replace it in the URL. (Fully agreeing that one shouldn’t have to do this)

      1. 1

        Wondering the tool making the gui, or it’s pure image editing?

        1. 6

          It’s probably just an image. Looks like macOS 9 (maybe 8). Seems like too much effort to atually fire that up to mock a GUI.

        1. 1

          “any kernel version” That’s probably not true.

          1. 3

            If you take a maximally-literal interpretation, sure, it’s not going to work on HURD or FreeBSD or Linux 2.4, but I think it would be fair to interpret it as meaning it will work with any kernel for which that could reasonably be expected (i.e. a recent-ish Linux with CONFIG_IO_URING=y).

          1. 5

            Personally, the most interesting aspect about this is the different ways you could represent the same information: schemaless (tuple, dict) vs schemaful (data class, named tuple), limited (NumPy arrays) vs effectively unlimited (others). The size of each object wouldn’t come into consideration except for extremely niche programs, such as those where the max size of each datum is known in advance (where NumPy arrays make sense).

            Also, how do each of these data types scale in memory if you have a million of them, each with a million fields?

            1. 1

              Store them in a more compact form such as pickle, and unpickle them ondemenad with a cache.

            1. 17

              Nice article, but the visualizations are kinda miserable to actually understand. What’s wrong with just graphs?

              1. 11

                I was thinking I’d prefer seeing names, not just icons.

                1. 2

                  I think the criticism was that it’s not visually obvious in your graphics that 8GB RAM is twice as much as 4GB. The main use of visualization is to visually represent things (quantities in your case), but your visualization fails at that because it requires us to read all of its test. I hope I didn’t misrepresent what icefox meant.

                  P.S. Charts (plots?) is a better term than graphs.

                  1. 1

                    I was adding general feedback, not strictly replying only to what icebox brought up. Should I have made a separate comment?

                  2. 1

                    Same here, bar graph with annotation should be more meaningful and useful than a random icon for reader to decrypt.

                1. 1

                  How about some cheap x86 boards? You can get wyse 3040 (4C 2G) for ~25$ and wyse 5070 for ~80$ (doesn’t have any good deal yet) on ebay. The wyse 3040 is more like RPI with limited interfaces, and similar CPU performance, however, it’s x86 and widely available.

                  1. 2

                    Being a fan of fly.io and litestream, nice to know those good engineers are working together. Also, the one-writer multi-reader model works well for most applications, without pre-rendering the entire site to static html.

                    1. 1

                      I’d like to see the comparison between 32bit native program vs the 64bit vs the pointer compression. This reminds the real mode of x86, when memory is addressed by segments (20bits).

                      1. 4

                        Is any server really going to send you data fast enough to justify a huge pipe like that? I have a measly 200mbps connection (1% of that!) and I rarely see my computer receiving anything close to its capacity. Maybe just when I download a new version of Xcode from Apple.

                        (Obligatory grandpa boast about how my first modem was 110bps — on a Teletype at my middle school — and I’ve experienced pretty much every generation of modem since, from 300 to 1200 to 2400 to… Of all those, the real game changer was going to an always-on DSL connection in the late 90s.)

                        1. 4

                          It’s easy to fill a Gigabit line these days in my experience. With a faster uplink, now all devices at my home can fill at least a Gigabit line, at the same time :)

                          1. 1

                            Filling 1Gbps is trivial, but pumping 25Gbps data would be rather challenging, if you fully utilize the 25Gbps duplex with the NAT. 25Gbps on each direction means 100Gbps throughout for the router. That’s a huge load on the router, for both software and hardware. For benchmarks, you could recent hourly billed hertzer vps, they have 10Gbps connection with a fairly cheap price. I wondering how’s the peering status is this ISP, the 25Gbps doesn’t really mean anything unless you have huge pipes connected to other ASN. Even with dual 100Gbps, the network can only serve 8 customer at full speed, which is :(

                            1. 3

                              init7 peers with hetzner directly, other customers report getting 5+ Gbit/s for their backups to hetzner servers :)

                              The hetzner server I rent only has a 1 Gbit/s port. Maybe I’ll rent an hourly-billed one just for the fun of doing speed tests at some point.

                              1. 1

                                In the mean time, I found this product interesting when searching for ccr2004, at msrp of 199$.

                                https://mikrotik.com/product/ccr2004_1g_2xs_pcie

                                The 2C/3C low-end “cloud” servers has full 10G connection, and it’s available across multiple regions.

                                1. 2

                                  What discourages me massively about this device is clunky integration like this:

                                  This form-factor does come with certain limitations that you should keep in mind. The CCR NIC card needs some time to boot up compared to ASIC-based setups. If the host system is up before the CCR card, it will not appear among the available devices. You should add a PCIe device initialization delay after power-up in the BIOS. Or you will need to re-initialize the PCIe devices from the HOST system.

                                  Also active cooling, which means the noise level is likely above the threshold for my living room :)

                          2. 2

                            DigitalOcean directly peers with my ISP and I can frequently saturate my 1 Gbit FTTH. I use NNCP to batch Youtube downloads I might be interested in and grab them on demand from DO at 1 Gbit, which I have to say is awesome, cause I can download long 4/8K videos in seconds.

                            1. 1

                              It’s pretty easy to saturate that symmetrically once you have multiple people & devices in the mix, eg) stream a 4K HDR10 movie in the living room while a couple of laptops are sending dozens of gigs to backblaze and the kid is downloading a new game from steam.

                              1. 3

                                Not really 4k streaming isn’t that scary, the highest bitrate I’ve ever seen is the spider man form sony at 80Mbps, bb backup over wifi maybe use 1Gbps, and steam download is also capped at 1Gbps. So, it only uses 3Gbps, far from saturated.

                                1. 2

                                  Yeah sorry, I meant it’s not hard to saturate GP’s 200Mbps connection. The appeal of 25Gbps is that you’re not going to saturate it no matter what everyone in the house is doing, for at least the next few years.

                            1. 3

                              The issue is “Sonic only keeps the N most recently pushed results for a given word”, so it only limits to certain use cases, if you don’t need to retrieve all matches.

                              1. 2

                                Yeah I think this is definitely a case of software with a specific purpose, this one being search that fits on a single smallish box.

                                1. 1

                                  Yeah, for smallish box I might just use the fst in sqlite.

                              1. 23

                                Instead, please put the unit in the function name.

                                (sleep-seconds 300)

                                1. 5

                                  Too simple. People need to complicate and add yet another bit of complexity such as purpose created types, nammed parameters and whatnot that ultimately needs to be looked up in the documentation.

                                  Funny that the obvious solution isn’t even mentioned because people don’t even consider a design flaw from their all mighty favorite languages.

                                  1. 2

                                    I hate types

                                    1. 5

                                      And yet types exist whether they are declared or not, even in Lisp-y languages! Types are a characteristic of the universe we inhabit. I wouldn’t take my car to a hair salon to have the oil changed, and I know not to do this without actually trying it because the types don’t work out.

                                      1. 3

                                        Right. I’m working on a new essay on this but in short, I tried to design a dynamically typed lisp with maximal applicability of procedures—as in, “reverse” should be able to reverse a string, a vector, or a list, as opposed to having “string-reverse” or “vector-reverse” defined separately. I found that in order to implement that, I needed an isa-hierarchy of types (or, rather, derive an isa-graph from a tag cluster, kinda duck typing style). For example, strings, vectors, and lists are all “sequences”. So, in that sense, types are great.

                                        In order to not have to deal with types (as much) on the app level, I really do need to do them carefully (at the primitives level). So types aren’t useless. I still hate them though and languages that make it a point to do everything through types. Dependent types are the worst.

                                        I don’t wanna type annotate and I don’t wanna limit procedures to only compile on certain types. I don’t want the compiler to prevent you from taking your car to the hair salon.

                                        1. 3

                                          APL achieves something very similar to what you are trying to do. Here’s a talk making the point (I think) that APL is so expressive, types would just get in the way.

                                          Does APL Need a Type System? by Aaron W Hsu https://www.youtube.com/watch?v=z8MVKianh54

                                          NB: I’m in general very type-friendly (as is the speaker it seems), but that just makes this perspective all the more interesting to me.

                                          1. 1

                                            I love APL ♥

                                          2. 3

                                            I don’t want the compiler to prevent you from taking your car to the hair salon.

                                            But why wouldn’t you want that? The hair salon will do nothing useful with the car, and might even mess it up!

                                            What if I call reverse on an integer? I’d love to find out that my mental model is wrong right after I type it (or, at worst, when I run the compiler) rather than when I run the code and get some inscrutable error in another part of my program because reverse silently did nothing with the value (or, even worse, treated the int as a bit string).

                                            The fact that some languages have string-reverse and vector-reverse is more a function of the language and less a function of the types. You can easily define a generic reverse function in many languages and still get static types (and, if the language supports it, type inference so you don’t need to write out the types). There are also languages that support things like extension methods so that you can add interfaces to existing types.

                                            1. 1

                                              Sometimes I feel like this is, figuratively, an ergonomics issue. Some programmers feel more comfy with the kind of checks and balances you’re talking about and others (like me) hate them. I’m kinda glad that there are both kinds of languages.

                                              We are veering in to off-topic because the thread is about sleep time units.

                                              Let’s say I annotate 10 types. 2 of them find bugs, and then there are three or four bugs that weren’t related to types. Then I have done meaningless work 8 times, and put myself in a workflow or state of mind that make those three or four bugs way harder to find, all for the sake of finding two bugs (the kind of bugs that are often obvious on first run anyway). Instead, if I don’t have types, I check everything at the REPL and make sure it gives sane outputs from inputs.

                                              Like, say I wanna make the procedure

                                              (define (frobnicate foo)
                                                (+ foo (* 6 7)))
                                              

                                              If I meant to type (* 6 7) but accidentally type (* 6 9), type annotation wouldn’tve caught that. Only testing can.

                                              But why wouldn’t you want that? The hair salon will do nothing useful with the car, and might even mess it up!

                                              Maybe they can drive around in the car and give haircuts all over town.

                                              A lot of my best decisions as a programmer have been me realizing that the same procedure is much more general than I first thought (and then giving it a new, more general name). I like to type as I think, refactor and mold into the perfect parameter signature. (“Oh! I don’t need to pass in the list here, if I only pass the last pair, this function could share code with foo!”)

                                              What if I call reverse on an integer?

                                              My language converts it to decimal and reverses the digits. Useful for calculating probabilities for Unknown Armies.

                                              I’d love to find out that my mental model is wrong right after I type it (or, at worst, when I run the compiler) rather than when I run the code and get some inscrutable error in another part of my program because reverse silently did nothing with the value (or, even worse, treated the int as a bit string).

                                              So this is why humanity haven’t found the perfect language yet. Some people like different things. I’m not here to stop the type fest that’s been going on. Cool things might be invented from that camp down the line, it’s good that people are trying different things. If type inference could be made better so we don’t have to annotate…

                                              1. 1

                                                Let’s say I annotate 10 types. 2 of them find bugs, and then there are three or four bugs that weren’t related to types. Then I have done meaningless work 8 times, and put myself in a workflow or state of mind that make those three or four bugs way harder to find, all for the sake of finding two bugs (the kind of bugs that are often obvious on first run anyway).

                                                Can you expand on this more? How do types make it harder to find non-type related bugs? In my experience, by completely eliminating an entire class of bugs (that aren’t always obvious catch-on-the-first run bugs, especially if you have a really nice type system!) it gets easier, not harder, to identify logic errors.

                                                1. 3

                                                  As an analogy, overly relying on spell checkers can make some people miss things that are still legit spellings but are the wrong words in that particular sentence, like effect/affect.

                                                  But, it’s worse than that since (and I’m complaining about type annotation, not type inference) you need to enter the type info anyway. It’s “bugfinding through redundancy”. Sort of the same philosophy as “write a test for every line of code” but more rigid and limited. Of course reduntantly writing out what you want the function to accept and return is going to catch some bugs.

                                                  If you like this sort of type checking, you’re not alone. A lot of people love them, and ultimately there’s no need to argue. Time will tell if that style of programming does lead to overall fewer bugs, or at least does so for programmers of a certain taste, and if so, that’s fine by me. I’m not gonna take your ML away.

                                                  But as my “42 is odd” example shows, I’m not too happy with the whole “statically typed programs are Provably Correct” hype leading into the same hopeless dead end as Russell and Whitehead did a hundred years earlier.

                                                  Coming from C and Pascal, when I first discovered languages that didn’t have type annotations in the nineties (like awk, perl, and scheme) I felt as if I had found the holy grail of programming. No longer would I have to write out boring and obvious boilerplate. It was a breath of fresh air. Other people obviously feel differently and that’s fine.

                                                  For me, it seems that a lot (not all, but some) of the things a good type annotation system helps you with are things you don’t even need to do with dynamically typed languages. It also feels like with a type annotated language, there’s a catch-22 problem leading you to have to basically write the function before you write it (maybe with pseudocode or flowcharts) just so you can know what type signatures to use.

                                                  I felt that wow, a cons pair of car and cdr can express data in so many ways, I can just immediately write the actual logic of my code. Whereas when I worked as a Java dev (don’t worry, I’ve looked at modern type languages too, like Haskell) we had to slog through writing types (classes and instances), UML diagrams, wall full of post-its, architecture, ConnectionKeepingManagerFrobnicator.new() etc. With Scheme it was just, all that red tape just fell away. No need for pseudocode since I could just send whatever I was thinking into the REPL.

                                                  The type community loves the expression “to reason about the code”. Well, to me it’s a heck of a lot easier to reason about the code when it’s a fifth the size. (Sexps help too since it’s easier for me to grok a code tree than a linear sequence of unparsed tokens of code data.)

                                                  Obviously, type fans have had similar epiphanies but in the other direction, falling in love with static just like I fell in love with dynamic. And that’s cool. Let the deserts bloom. Humanity can’t be betting all of its eggs on my approach. I see the type craze as an experiment. One that might even be right. So please, go ahead.

                                                  I’m just really, really grateful that it’s not me who have to slog through it. I can sit under the cork tree sniffing dynamically typed flowers.

                                                  1. 2

                                                    Uh, wait, why did I get baited into writing all that when I see now that I already answered it in what you snipped out:

                                                    Instead, if I don’t have types, I check everything at the REPL and make sure it gives sane outputs from inputs.

                                                    Like, say I wanna make the procedure

                                                    (define (frobnicate foo) (+ foo (* 6 7)))

                                                    If I meant to type (* 6 7) but accidentally type (* 6 9), type annotation wouldn’tve caught that. Only testing can.

                                                    1. 1

                                                      hm, that doesn’t answer my question at all but it your longer post did, so thanks.

                                                      I think the point about “boilerplate” is pretty tired and not even true any more with how good type inference is nowadays. Yes, Java involved/involves a lot of typing. No, it’s no longer the state of they art.

                                                      It’s true that in the case where you use the wrong term that has the same type as the correct term, the typechecker will not catch this. Not having types is also not going to catch this. I’m going to see the error at the same exact time with both approaches. Having a REPL is orthogonal to having types, so I also often check my Haskell functions at the REPL.

                                                      I see the type craze as an experiment.

                                                      Calling an entire field of active research a craze is a little upsetting.

                                                      1. 1

                                                        I am complaining about annotated type systems specifically, which I clarified nine times. Inference type systems are fine.

                                                        Not having types is also not going to catch this.

                                                        The idea is that checking at the REPL will find it.

                                                        I’m going to see the error at the same exact time with both approaches. Having a REPL is orthogonal to having types, so I also often check my Haskell functions at the REPL.

                                                        Me too. Which made me feel like the whole type thing was a little unnecessary since I needed to do just as much checking anyway.

                                                        (As noted elsewhere in this thread, I’ve changed my tune on types a little bit since I realized I do need an isa-taxonomy for primitives. I.o.w. to get rid of types, I’m gonna have to define types.)

                                                        Calling an entire field of active research a craze is a little upsetting.

                                                        It’s more the whole dependent type / provably correct thing that’s a li’l bit of a craze, not the entire field of type research as a whole. As I wrote in my essay, types have a lot of benefits including serious performance gains, and that’s awesome. It’s the whole “it fixes bugs!” that gets a li’l cargo culted and overblown sometimes. Not by you, who do understand the limits of type systems, but by hangers-on and newly converted acolytes of typing.

                                                2. 1

                                                  Lots of points from your arguments can be achieved by using generic types, and everything would work safely, giving the programmer quick feedback if the types work for the particular combination. No need to guess and check in the runtime.

                                                  My language converts it to decimal and reverses the digits. Useful for calculating probabilities for Unknown Armies.

                                                  So what would be the output of 2.reverse() * 2?

                                                  1. 2

                                                    Four.

                                                    1. 1

                                                      I’m wondering if that would also be the case with "2".reverse() * 2. Because if the output would be 4, then I’d wonder what would be the output of "*".reverse() * 2 would be. I hope it wouldn’t be **.

                                                      No matter what the answers are, I’ve already dedicated a lot of time to decode how some basic operations work. With types, I would have this information immediately, often without needing to dig through the docs.

                                                      1. 1

                                                        4 and ** respectively.

                                                        1. 2

                                                          All kidding aside, the idea isn’t to overload and convert but to have a consistent interface (for example, reversing, or walking, or concatenating strings and lists similarly) and code reuse. I’m not insisting on shoehorning sequence operations to work on non-sequence primitives. Which is why I already said I needed an isa taxonomy of primitive types.

                                        2. 1

                                          So sleep(seconds: 1) needs to be looked up in documentation whereas sleep-seconds(1) does not?

                                          1. 2

                                            If you language only supports the second, then use the second which is perfectly clear. You would by no means be ina. Situation where lack of language features limit code clarity.

                                            Notice that while parameters have names in most languages, in many of them you can’t include the name on your code but rather need to pass them in order.

                                        3. 2

                                          this way makes the most sense to me, at least for sleep

                                          1. 1

                                            It used to be a common sense that sleep uses seconds, until other languages not following that.

                                            1. 5

                                              That’s not how common sense works!

                                          1. 2

                                            the kernel has moved its minimum GCC requirement to version 5.1

                                            Yeah, thanks for moving to a 5.x gcc and failing compilation on CentOS 7’s default gcc which is 8 years old, while still

                                            look to moving to the C99 standard — it is still over 20 years old

                                            I am a little bit confused where you can always have the latest and greatest linux kernel from upstream (lesser than 1 week old and being confident about it), but hesitant to trust a compiler or C standard that’s been there for 20 years. While asking developers to trust a compiler that’s 7 years old (gcc 5.1).

                                            1. 1

                                              Is anyone still updating centos7? It’s legacy now surely

                                              1. 2

                                                Centos7 still gets package updates via upstream, unlike 8.

                                                1. 1

                                                  But there’s precious few of those. Only cve severity important or higher are applied by default, with other updates at Redhat’s discretion. Disclaimer: I work for red hat, but may still be misrepresenting their policy.

                                            1. 2

                                              the “(in Bash)” part is realy hackery.

                                              1. 1

                                                So I guess they don’t bother to have a spending limit that prevent those kind of usage based billing? Or, maybe it’s time to switch to hosting that doesn’t bill by the traffic usage. I’ve been using about 20~90TB per month, on a $5 instance.

                                                1. 4

                                                  I wish there were lighter alternatives to the full-blown Mastodon server when you want to self-host a (small?) federated news channel… 🤔

                                                  It’s good to see Gitea on the fediverse still, and the announce that they received a grant to work on the project makes it better. Well done.

                                                  1. 9

                                                    There’s Pleroma, which seems much lighter and more intended for smaller deployments.

                                                    1. 3

                                                      Even for pleroma you need a postgresql, I am expecting a rust with sqlite as db with api that’s compatible with pleroma.

                                                      1. 1

                                                        I have just given up on trying to make it run again. Pleroma is an endless source of pain. It’s bloated as hell.

                                                        An actual option would be more like https://humungus.tedunangst.com/r/honk

                                                      2. 14

                                                        There’s also the more whimsical honk: https://honk.tedunangst.com/

                                                        It’s written in Go, rather minimalist and lightweight.

                                                        Frankly one barrier holding me back from trying it is they’re using Mercurial for version control, and I barely understand git so I’m not eager to half-learn some other system. I’ll probably get around to it eventually.

                                                        EDIT: Given it has libsqlite3 as a dependency, I’m assuming it uses SQLite for its database.

                                                        1. 7

                                                          @tedu literally just publishes tarballs; you don’t need to care about the SCM whatsoever.

                                                          1. 3

                                                            Fair point, I was assuming I would want to hack on it at some point, but it should be perfectly usable without modifying the source yourself.

                                                          2. 6

                                                            Mercurial is 100x more user friendly than git, don’t be afraid! For a long time I dreamt of an alternative timeline, where Mercurial won the lottery of history and DVCS is just a thing silently humming in the background, while so obviously intuitive people don’t really need to think about it in their day-to-day. But eventually I accepted the reality and grew to respect and appreciate the fickle tool that’s now standard instead, having learnt the contorted gestures required to hold it such that I don’t gain and more deep scars, and to keep my attention level always high enough and movement speed slow enough so as to usually avoid even the passive-aggressive light bruises and smacks it considers “expression of affection”.

                                                            1. 7

                                                              Off topic: when it comes to VCS dreams, I don’t want Mercurial to come back, I want Pijul to win.

                                                              1. 1

                                                                What are the perks with it that you prefer over other solutions?

                                                                1. 3

                                                                  It makes collaboration and LTS branch maintenance considerably easier because any two patches that could be made independently can be applied independently in any order. Darcs had that many years ago, but never gained popularity due to its low performance. Pijul developers found a way to make that fast.

                                                                  1. 1

                                                                    Ohh, wow, it has the darcs thing?? I had no idea!

                                                                    1. 1

                                                                      Is this like hg graft?

                                                                2. 1

                                                                  I’d like to see the end user usability study that concluded Mercurial was the nice round figure of exactly “100× more user friendly that Git” as a result.

                                                                  1. 1

                                                                    Ouch, sorry; I sincerely only meant this as a subjective opinion and a rhetoric device; obvious as it may sound to you, it honestly didn’t even occur to me that it could be taken as a solid number; only now that you wrote I see this possibility, so I now realize it would be better if I at least prefixed it with an “IMO” or an “I find it…”; sorry again; ehh, I find again and again that this whole language thing is such a fickle beast and lossy protocol when trying to express things in my head, never ceasing to surprise me.

                                                                3. 1

                                                                  The nice thing about Mercurial is that there’s nothing to learn when you’re first getting started because it has a reasonable CLI UI. Don’t hesitate to try it.

                                                                4. 6

                                                                  I wish there were lighter alternatives to the full-blown Mastodon server when you want to self-host a (small?) federated news channel

                                                                  Same. I currently run Pleroma but compared to most other things I run it’s huge. I’ve been keeping a close eye on the https://github.com/superseriousbusiness/gotosocial project. It’s still in the early stage but they made an initial release last year and it looks promising.

                                                                  1. 1

                                                                    That’s a very interesting perspective, thanks.

                                                                    Lately I find myself wishing somebody would combine the “how to get off Google” genre of blog post with a “why language X is awesome” genre to create a “how to self-host/federate a whole lot of software using language X and minimal libraries”. There’s significant operational and security value in minimizing package dependencies. If you happen to be using lots of Golang services on your server that would be a very interesting case study.

                                                                1. 3

                                                                  nc / netcat / ncat, there are so many not that compatible implementations, it’s one of the confusing tools I’ve ever used

                                                                  1. 5

                                                                    Is there any one using this OS?

                                                                    1. 5

                                                                      As a daily driver - probably nobody. But it’s an interesting project, and if you are a GPL purist this might be very interesting in the long run.

                                                                      Also, rump(a) means butt in Swedish which makes this (and other rump kernels) interesting due to reasons. ^_^

                                                                      1. 5

                                                                        Also, rump(a) means butt in Swedish

                                                                        It is also the primary meaning of the word in English

                                                                        1. 1

                                                                          TIL, thanks! :D

                                                                      2. 2

                                                                        Not directly but it’s like the Haskell of operating systems. Or maybe Self would make a better analogy. Without Hurd and other microkernel petri dish projects we likely wouldn’t have FUSE or pulseaudio on Linux.

                                                                        1. 1

                                                                          Ahh, nice to know the FUSE is related to Hurd. Does FUSE exist on Hurd as well? How’s the performance?

                                                                          1. 1

                                                                            Rather, all Hurd filesystems are in userspace, and they are called translators. Have a look at Small Examples on Using Translators.

                                                                      1. 2

                                                                        I don’t think that’s a problem. Just like Imagine if Doctors never use internet.

                                                                        1. 4

                                                                          That’s what the article is about.

                                                                        1. 2

                                                                          ZSTD support unfortunately still seems to be slightly buggy

                                                                          Does this “buggy” mean eatmydata? One of the major reason people use ZFS is raidz1/raidz2, supporting R0/1 only isn’t very friendly for consumers, and I bet enterprise won’t take it either due to lack of age.