meltyness

tokio default behavior within a task is to ignore panics, such as an Err/None unwrap, and only crash that task, so it's impact limited so that's nice, maybe that's where the snowblindness came from.

it'd be kinda hard to amend the clippy lints to ignore coroutine unwraps but still pipe up on system ones. i guess.

edit: i think they'd have to be "solely-task-color-flavored" so definitely probably not trivial to infer

> especially knowing you are actually never going to work on such problems as part of an actual job

Actually, unwittingly, problem solving being a common organizational behavior, and most algorithms being a blueprint for optimal problem solving; maybe get curious and shed the incline that they are merely academic?

Anyways, I did this, myself recently. I picked up CLRS and read it, omitting or skimming the proofy sections, opting to focus on design and intuition, which is troublesome when they begin to overlap. I hope to revisit it. It's a nice space to be in, a blissful stroll through pedagogy, little history lessons, easy stuff.

As I progressed through the readings I worked a healthy number of problems. Lots of struggle and pain working exercises, opting to avoid hints or shortcuts and spend hours and hours to internalize. This part stings. No one likes to bathe in the lather of their own ignorance, but it can be done.

"it came to me as a microsleep misinterpretation of a radio news broadcast" feels like the most tech thing, to me. this is always where the best ideas seem to come from, a misinterpretation that gets fixed up into an enhancement.

It's funny to me that the patch threads attempting to fix a concern with the CPU from the OS both immediately derail into "oh no, you broke something!!1"

the CPU is assumed to work, despite Linux being designed with portability, theres not really a programming interface to cleanly disable arbitrary features, I guess we just screw with it until it seems to work OK and no one is yelling.

Granted, Linux isnt a product, and a patch in a thread is unlikely to impact anyone

Proof by counterexample, just find the inevitable security flaw.

Optimistically because the component was considered self-contained, and done?

If you build things with wires, diodes, multiplexers, breakers, fuses and keyed connectors there's less maintenance needed than if you try and build a system entirely out of transistors and manually applied insulators.

I haven't looked at the package itself, but was it built on top of the C libraries with like, bindgen?

e: a glance suggests thats not the case, but perhaps they were ported naively by simply cloning the structure without looking at what it was implementing? that's definitely the path of least resistance for this type of thing. On top of that the spec itself is apparently in POSIX, some parts of which are, well, spotty; compared to RFCs

Well, it probably depends on which software's concern will be implementing a policy to prevent users from having permission to fill critical directories and prevent the system from operating normally, which is discussed in the article. Which is also a coordination problem because the most common user of disk is software itself, I think.

FHS seems to specifically imbue the user with the responsibility and consequences of filling up the disk.

Linux for me is all about customization and control, particularly of hardware, which you'd usually do for optimization (performance, workflow, latency, stability), which is fun if you care about optimization and efficiency, but for "good enough/I'm used to it/I'm a satisfied paying customer" I suppose there's no reason to investigate or risk. The market has poured loads of capital into satisfying PC multimedia use-case.

I'd suspect there's probably versions of all those that have been made to function basically through WINE.

If your curious, it's very easy to use it as a hypervisor, and pull out what you can, though IOMMU/SR-IOV might be tricky.

Alternatively, checking if Blender/GIMP service your use cases wouldn't even require switching...

AutoHotKey has been solved a lot of different ways, for sure.

But yeah, granular detailed control over your hardware is still the primary use-case for Linux, so if you view bad defaults, annoying install procedures, occasional show stopping bugs a hindrance rather than an opportunity, maybe it's not a strong candidate.

tts would be an interesting case-study. it hasn't really been in the lime-light, so could serve as a leading indicator for what will happen when attention to text generation inevitably wanes

I use Read Aloud across a few browser platforms cause sometimes I don't care to read an article I have some passing interest in.

The landscape is a mess:

it's not really bandwidth efficient to transmit on one count, local frameworks like Piper perform well in alot of cases, there's paid APIs from the big players, at least one player has incorporated api-powered neural tts and packaged it into their browser presumably ad-supported or something, yet another has incorporated into their OS, already (though it defaults to speak and spell for god knows why). I'm not willing to pay $0.20 per page though, after experimenting, especially when the free/private solution is good enough.

I adore this machinery, there's a lot of money riding on the idea that interest in AI/ML will result in the value being in owning bunch of big central metal like cloud era has produced, but I'm not so sure.

Yeah, a fuse or a breaker is a pretty common thing.

Probably a more apt analogy would be a keyed adapter.

I mean, you don't really have to speculate about what this is for, it's for an authority providing for lawful search, it seems pretty well-scoped, and similar to any old search warrant, which is not a new thing, really https://classic.austlii.edu.au/au/legis/nsw/consol_act/deccd...

Basically, they're not really setting up for a blanket ban on personal security features, that interpretation is obviously catastrophizing. Not that there aren't hamfisted laws somewhere like this, but NSWs implementation seems OK I guess

This is uncanny and worryingly specific, and I'm not a lawyer, but if you're not already under suspicion of being a criminal, then installing graphene doesn't match this definition I think

I find Rust pretty cohesive and consistent in its semantics. Accomplishing different tasks involves less sugar than other languages like this article seems to focus on.

Generally all of the interfaces conform to the patterns in the mem module. If you want to understand the structure of everything else unambiguously it would be best to start there: https://doc.rust-lang.org/std/mem/

When they establish personality archetypes and roles bonds form readily. That's like, the purpose of roles in an organization.

Well I guess a GLP-1 pacemaker would address this. A lifetime of doses weighs at much as a nickel?

Two lines clearly deviate from AAB.

Can't upload discord attachments from mobile.

By my memory, a cron runs a script that checks my cert file's last modified daily. When it is a certain number of days since (flavored Bash statements) the file last modified I'll certbot and install whatever comes back.

It's very under-engineered, maybe a trifold pamphlet on light A11 printed with a laser jet running out of ink.

I've probably spent more time talking about how much it sucks than I have bothered considering a proper solution, at this point.

My server got renewal halted. I rolled my own wrapper for certbot. Idk it's just a blog, I'm not that attached. It hit some rock a few months ago, I just retried and manually installed it, and it seems to have perked back up and continued receiving certs. Probably would have been more frustrating if it were a huge fleet but, it wasn't even worth my time to check logs and figure out what precisely happened (cert distributed with a modified that didn't match the ASN.1 expiry? transient issuance failure? issues the same cert? ...who knows.)

Brought to you by lightspeed briefs

Lean is a lovely language ecosystem, as Tao clearly demonstrates though, LLMs can struggle with it. The language and the tooling is designed heavily around not merely text code, but continuous feedback from a specialized shell, though Tao attributes the issue to another condition, that there are two acutely similar versions of the language.

Yeah, the problem LLMs will have with Rust is the adherence to the type system, and the type system's capability to perform type inference. It essentially demands coherent processing memory, similar to the issues LLMs have performing arithmetic while working with limited total features.

https://leetcode.com/problems/zigzag-grid-traversal-with-ski...

Here's an example of an ostensibly simple problem that I've solved (pretty much adversarially) with a type like: StepBy< Cloned< FlatMap< Chunks<Vec<i32>>, FnMut<&[i32]> -> Chain<Iter<i32>, Rev<Iter<i32>> > > > >

So this (pretty much) maximally dips into the type system to solve the problem, and as a result any comprehension the LLM must develop mechanistically about the type system is redundant.

It's a pretty wicked problem the degree to which the type system is used to solve problems, and the degree to which imperative code solves problems that, except for hopes and wishes, which portions map from purpose to execution will likely remain incomprehensible.

Yeah this is late-stage 'growth.' Hamstring your other products to reconcentrate activity, 'rebalance' usage to Shorts content by making the original offering, long-form content less usable, lower quality, less interesting; and so shall it remain until some congress finally forces these players cut a dividend instead of this moronic buybacks situation, hysterical that <well-liked female northeast senator and presidential primary candidate whose policy positions had been featured here> abruptly stopped talking about this for no apparent reason.

It's kind of conceptually like a Shepard's tone, though, which is maybe interesting.

The only response I want to read about this starts with, "Historically, the lurch and jerk of technical progress, paranoia manufactured by ubiquitous media, government financial overreach, and heavy-handed speculative projections shattered the ability of many organizations to establish meaningful turnover and generational handoff ..."

For perspective, I'm a novice with algorithm design, I've been grinding leetcode for the past 6 months or so, almost exclusively in Rust. I was bewildered by the same concern since I had initially set out to, not only focus on Rust, but to primarily maximize use of the Iterator construct, since I was not intricately familiar with it. A few months in I discovered that there was an appropriate Iterator construct which accomplishes the same thing.

  // Comments for the non-Rust native reader, regarding this Function declaration:
  // successors is a function that accepts an `Option` container for some Value of type T, called `first`
  // and a Closure called `succ`, constrained below:
  pub fn successors<T, F>(first: Option<T>, succ: F) -> Successors<T, F> ⓘ
  where
  // `succ` must receive the iterated state, and return the next iterated state
    F: FnMut(&T) -> Option<T>,

  // Each time the `next()` function is called on the returned Iterator (a Successors-flavored iterator),
  // the state of `first` is yielded, and then
  // `succ` is called to progress
  // until a `None` type is reported by `succ`

I'm not sure where the concept came from, but it's not dissimilar to the author's implementation, but instead of the ControlFlow enum, it relies simply on the Option enum. I know though, that it was initially built in the Itertools crate as unfold and then upstreamed some time later.

Essentially you use `first` to contain a Queue, Stack, or Level for the different traversals, and define traversal or activities from there.

It's fairly ergonomic in practice, ergonomic enough for Leetcode.

Here's a BFS: https://leetcode.com/problems/course-schedule-iv/solutions/6...

[0] https://doc.rust-lang.org/std/iter/fn.successors.html

[1] https://docs.rs/itertools/latest/itertools/fn.unfold.html

Also economists, during every bubble ever:

I wouldn't be so dismissive of the importance when people succumb to the realization that it's like VHS/Betamax, but instead of Bruce Willis in Die Hard, at stake is literally half of your friends and acquaintances.

  Write 20 sentences that end with "p" in the final word before the period or other punctuation.

Succeeded on ChatGPT, pretty close on gemma3:4b -- the exceptions usually ending with a "puh" sound...

Pipes and filters are considered an architectural pattern, whereas Builder is a GoF OOP pattern, so yes.