https://github.com/LemmyNet/lemmy/pull/4024

Broken input sanitization probably.

Issue will thankfully no longer exist in the next lemmy release.

lemmy deleted everything between the “less than” character and “>”.

Lemmy also escaped the ampersands in their comment’s link 😉

Isn’t broken sanitization great!

Next Day Edit: Sorry. Forgot to use my Canadian Aboriginal syllabics again. Because apparently it’s too hard to admit HTML-sanitizing source markdown was wrong!

One thing that irks me in these articles is gauging the opinion of the “Rust community” through Reddit/HN/Lemmy😉/blogs… etc. I don’t think I’d be way off the mark when I say that these platforms mostly collectively reflect the thoughts of junior Rustaceans, or non-Rustaceans experimenting with Rust, with the latter being the loudest, especially if they are struggling with it!

And I disagree with the argument that poor standard library support is the major issue, although I myself had that thought before. It’s definitely current lack of language features that do introduce some annoyances. I do agree however that implicit coloring is not the answer (or an answer I want to ever see).

Take this simple code I was writing today. Ideally, I would have liked to write it in functional style:

    async fn some_fn(＆self) -> OptionᐸMyResᐸVecᐸu8ᐳᐳᐳ {
        (bool_cond).then(|| async {
            // ...
            // res_op1().await?;
            // res_op2().await?;
            // ...
            Ok(bytes)
        })
    }

But this of course doesn’t work because of the opaque type of the async block. Is that a serious hurdle? Obviously, it’s not:

    async fn some_fn(＆self) -> OptionᐸMyResᐸVecᐸu8ᐳᐳᐳ {
        if !bool_cond {
            return None;
        }

        let res = || async {
            // ...
            // res_op1()?;
            // res_op2()?;
            // ...
            Ok(bytes)
        };

        Some(res().await)
    }

And done. A productive Rustacean is hardly wasting time on this.

Okay, bool::then() is not the best example. I’m just show-casing that it’s current language limitations, not stdlib ones, that are behind the odd async annoyance encountered. And the solution, I would argue, does not have to come in the form of implicit coloring.

Practically speaking, you don’t have to.

Your executor of choice should be doing tokio compat for you, one way or another, so you don’t have to worry about it (e.g. async-global-executor with the tokio feature).

async-std is dead.

I would bad mouth Axum and Actix just because of the overhype. But then, the latter is powering this very platform, and the former is used in the federation crate examples 😉

So let me just say that I tried poem and it got the job done for me. Rusty API. Decent documentation. And everything is in one crate. No books, extension crates, and towers of abstractions needed.

I try to avoid tokio stuff in general for the same reason, although a compatible executor is unfortunately often required.

From your list, I use bat, exa and rg.

delta (sometimes packaged as git-delta) deserves a mention. I use it with this git configuration:

[core]
  # --inspect-raw-lines=false fixes issue where some added lines appear in bold blue without green background
  # default minus-style is 'normal auto'
  pager = "delta --inspect-raw-lines=false --minus-style='syntax #400000' --plus-style='syntax #004000' --minus-emph-style='normal #a00000' --plus-emph-style='normal #00a000' --line-buffer-size=48 --max-line-distance=0.8"

[interactive]
  diffFilter = "delta --inspect-raw-lines=false --color-only --minus-style='syntax #400000' --plus-style='syntax #004000' --minus-emph-style='normal #a00000' --plus-emph-style='normal #00a000' --line-buffer-size=48 --max-line-distance=0.8"

[delta]
  navigate = true  # use n and N to move between diff sections
  light = false    # set to true if you're in a terminal w/ a light background color (e.g. the default macOS terminal)

[merge]
  conflictstyle = diff3

Still on 0.17.4 btw.

if you’ve been following us for a while you know we’re passionate about #Rust! 🦀

who’s “us”?
following where?
is there a reason to particularly care about ᐸwhoever you areᐳ’s passion for Rust?

^ only meant half-seriously to point to the silliness of microblogging to a discussion community.

Note: the ᐸᐳ characters are Canadian Aboriginal syllabics because Lemmy devs haven’t fixed broken input sanitization yet.

https://github.com/LemmyNet/lemmy/issues/3827

Because the audiophile is broke, and will have to listen to some music on a lowly device, but the craving for some placebo is still there.

EDIT: btw, the bitrate is missing a k in your command 😉

Not audiophilic enough.

ffmpeg -i in.flac -ar 48000 \
            -af aresample=resampler=soxr:precision=28:cheby=1:dither_method=shibata \
            -c:a libopus -b:a 224k out.opus

There is no need to talk about an imaginary version of IPFS. GNUnet already exists. You can add that to the list of actually superior technologies that long predates IPFS.

As I mentioned, IPFS is nothing but very basic tech that got overhyped to junior/uninformed developers, and crypto scam victims.

Besides being overhyped basic tech where way more useful and practical solutions existed for decades (Freenet existed since year 2000 btw, and Tahoe-LAFS since 2007), there is nothing private about IPFS. This is a dangerous message to purport.

IPFS is as practically useful as NFTs. No wonder the two crowds connected well!

iroh is an attempt to create a useful and practical IPFS. But none of the bigger practical features is implemented yet. And the design itself doesn’t appear to be finalized. I’m willing to give iroh a chance, although the close proximity to the IPFS crowd doesn’t fill one with confidence.

There is also a serious bug regarding contexts and replies BE | UI.

Not rushing to update is proving to be very wise

From a technical point of view, I’d rather Lemmy didn’t federate except with itself, and maybe possibly also with similar networks, but only as long as that doesn’t hold Lemmy back from doing its own thing.

Getting ActivityPub federation to work reliably between Lemmy instances alone is already proving challenging for developers.

From a personal point of view, I have zero interest in what I consider a shit paradigm of social communication. The “micro” lie in micro-blogging, as you quickly conceded, is long gone. The interface is horrible for effective exchange of well-thought ideas. The social networks formed are hypernormalized echo chambers of unhinged ranting faux intellectuals and champagne activists, usually led by a cult of personality or two who are tasked with making sure the one-upping posturing game continues forever.

When you are about to "micro"blog, presumably you will be writing something coherent enough that it relates to a certain subject of interest to a section of the public. It is also presumably meant to be viewable by the public since you’re not sharing it in a private group chat.

If that’s the case, there should be a community in Lemmy where those interested in that subject congregate. That community would either be low-traffic, then you can make your "micro"blog a post there breathing more live into it. Or it would be a high-traffic one, in that case a lounge/chat/MegaThread post should exist where you can chat with people interested in that subject, in an interface that actually facilitates good discussion.

Sort by “best” is coming to Lemmy, in case you didn’t know.

Imagine if media in Lemmy was all hosted in a distributed network filesystem like Iroh, where instances only function as inserters and exit nodes for that media.

This way, smaller instances can have a smaller cache corresponding to the media that was actually needed by it (recently). And independent peers can help by participating in the distributed file-system network without running instances themselves.

Would you have escaped them a priori?

Do you consider markdown-it’s typographic replacements common knowledge, and thus intuitively escapable?

Should lemmy apps be pushed to use markdown-it, in your opinion?

their live demo

I meant the markdown-it live demo.

I wrote a separate post about this.