Yay Devrant is back!

Microsoft seems to be struggling with basic human decency such as linking the original when closing an issue someone spent their time writing as duplicate:

https://github.com/microsoft/...

I have 2FA enabled on NPM so it would shut up about it, the recovery codes are in my password manager, right next to my secure randomly generated password.

Password authentication is fucking stupid.

Generic associated types are getting stabilized in Rust! Higher kinded types here we come!

Another day, another critical vulnerability due to an out of bounds write that could never have occurred in Rust

https://github.com/openssl/openssl/...

Windows 10 had one groundbreaking UI innovation, but no one adopted it and even Windows 11 discareded this revolutionary idea:

BUTTONS NEXT TO EACH OTHER AND AT THE EDGE OF A BOX DON"T NEED AN ADDITIONAL MARGIN

Windows 10 was the first and last OS where I never accidentally clicked right next to the X on a window, in a passive area that had no other purpose so it might as well have belonged to that motherfucking button.

I passionately hate this trend, adopted nowadays by every OS, that everything needs to be rounded, separated from the things around it, and "allowed to breathe". They don't breathe. They're not alive. They're fucking UI elements and the space between them is unused, lost space.

The only interaction a button has with its surroundings is that it pushes other content away to make room for itself and responds to the cursor. It doesn't wiggle, it doesn't grow and shrink, and it ESPECIALLY doesn't fucking breathe. Please, just let me click the motherfucking button.

Relatedly, do you know of a good, preferably bluish dark GTK theme that provides window decorations that stretch the full height of the titlebar and are laid out next to each other at the very end of the bar without gaps?

It's nice that more and more languages are introducing async/await syntax, but by the example of Rust in particular I'm starting to wonder why we don't instead introduce this syntax for monads in general?

We could have a keyword (say, `bind`) which unwraps a value from any monad provided that the return value of the function is wrapped in the same monad. The ? operator does something a little similar, and I'll be intrigued whether it can actually be implemented for monads other than Result and Option once GATs are stabilized. In particular in the case of Rust, it would be possible to create a reference counting monad for heap-bound management of objects derived from references.

I really liked the idea with the new Firefox page, but the execution made me angry so I fixed it

- Removed the paddings and margins that took up space from information and actions
- Removed the four sentences that contained the same explanatory text I already understood in the initial popup
- Removed the fucking sidebar ad for Colorways
- I really like the Firefox logo so it can stay

Here's my userchrome repo if you want it, I reserve the right to discard the project and stop updating the repo at any point. It's best used as inspiration:
https://github.com/lbfalvy/...

Oh my god, when will Firefox shut up about its motherfucking colours!? Themes have been a feature since forever, none of this is new. Also, I DO NOT want my fucking userchrome to be colourful, and I DO NOT want to be constantly bugged about this. It's a fucking browser. I want iit have a reasonably high contrast and otherwise blend into the edge of the screen, because for a web browser, the UI is not important and should not stick out.

I respect if someone has different opinions about UI, but it pisses me off to no end that Mozilla doesn't respect mine.

I used to play on an electric guitar which I was trusted to store after the original owner emigrated, now that I left as well I'm out of a hobby.

I have an ever-extending list of small luxuries I plan to buy once I have stable disposable income, the first item is a stratocaster with an amp.

Scrolljacking is an act against accessibility so harmful that it is never realistically outweighed by the possible benefits.

https://www.indesit.co.uk/

font-family expects a comma-separated list. Fonts haven't been displaying on my blog for months because of this issue.

Why could NONE of the browsers I tested this on give me a real syntax error instead of "invalid property value" which could mean literally anything.

Edit: Actually, why can't the CSS plugin for VSCode tell me that I'm making a syntax error in the value of a well-known property?

Rust's DX is incredible. I previously published a couple packages to NPM and every step of the way i had to fight with NPM, Webpack, Rollup, Typescript and the mass of third party plugins for all of these that wired them together. Here it's literally just

cargo publish

I wrote a small crate that does unsafe operations, please help me verify its soundness: https://github.com/lbfalvy/bound
(Also I think you'll like it, I'm solving a fairly abstract problem that's not possible in safe Rust)

It's essentially a struct that ties together a heap reference and a struct that's constructed from it. The main use case is to return lock guards derived from Arc<Mutex> but it's defined in a very abstract way intentionally because I'm using Marc from mappable-rc and async-std's RwLock and I didn't want this to depend on either crate.

It actually has no dependencies apart from STD (I think this one may be unavoidable)

Playing chicken with the halting problem:

Useless language feature #1: specify kind in explicit expression type annotations that you insert to guide the type inference engine.

How did I work on this for 6 months without realizing that the kind of a value's type is always the kind of types because that's literally what the kind of types means?

In type systems without variadic generics, tuples should be defined as a type-level conslist:

Tuple<int, Tuple<string, Tuple<bool, TupleEnd>>>

Consider the possibilities, even just in a regular type system, then consider how much more is possible with dependent types!

To make something impactful. I don't want to be fully credited, though being able to point to it in interviews would be great.

While working, I constantly segment my product into tiny reusable abstract solutions, most of which I eventually publish. I want some of these to grow into popular solutions to the problem I had or some other similar issue. Or, I want one of my major projects to become either a tool or an inspiration in something significant, but frankly the point is that some people appreciate something I created.

Is it just the novice in me that finds the Haskell community's misguided obsession over character count really annoying? Learn You a Haskell For Greater Good states

> Shorter code means less bugs

A lot of people and resources seem to share this opinion, but it's obviously false. Simpler code means less bugs, but look at this function which just means "apply this applicative to each element of a list"

> sequence :: (Applicative f) => [f a] -> f [a]
> sequence = foldr (liftA2 (:)) (pure [])

This isn't "less buggy", it's fucking madness. The same in JS, the king of unreadable languages, would be:

function sequence(seq, val, apply = (f, x) => f(x)) {
seq.map(f => apply(f, val))
}

Seriously, how can you design a strictly typed language that gets beaten by JS in readability?

My preprocessor is just generalized kerning, the macros are variations on the single well-known proof for the Turing-completeness of GK, the type system will probably be a Prolog reskin so simple the translator can be a FSM, the type inference algo is the original HM algorithm which I don't even need to change, the core language is Lambda calculus and no more, and the backend might just be Erlang itself if my research confirms that extending LLVM until it consistently beats Erlang is unrealistic.

I invented nothing, I create nothing. All I do is plug circles into square holes and fill the gaps with play dough.

I could really do with HKT support in Rust right now. I need to somehow convert a
Marc<Task<Output = T>> into a
Task<Output = Marc<T>> where Marc is a Mappable Atomic Reference Counter from the mappable_rc crate. Nothing technically challenging in the whole operation, it's just not supported by the type system without those two types knowing about each other.

Forked from Facebook

I identified the need for a product akin to an ORM that maps an algebraic type system such as that of Rust to a key-value database (my situation dictates lmdb but I'd like to abstract away the store). Can you recommend prior art for me to research?

Slacking off on tests for medium size projects. I have one project that I consider a major achievement as of today, the NPM package @lbfalvy/react-await. It has like two tests and it does a _lot_ more than two things.

Don't get me wrong, I test it thoroughly, but not in an automated way.

I made a little automated Docker reverse proxy called Autocaddy to simplify developing unrelated little trinkets under subdomains of a domain name:
https://github.com/lbfalvy/...
It dispatches subdomains to the (container with the) matching network alias and terminates TLS.

it's a little rough around the edges but to my understanding it shouldn't be an inherent risk (unless you're running things that interfere with name resolution like VPN on the container host, but why would you do that if it's already a container host).

Today I finally had to write a function for which the most descriptive name is objectively kill_all_children

Do you guys remember the fun little joke utility called fuck that corrected typos?

While debugging an absurd 2s shell load time, I noticed today that the command it appends to .bashrc to _set a fucking alias_ takes almost 400ms to execute.

I predict as soon as impl specialization enters stable Rust - if it will extend to member types - CRTP will become omnipresent, because the nature of CRTP is that it's an incredibly unintuitive solution that emerges from simple answers to common questions.

I prefer to build my solutions bottom-up, creating a component right after identifying the need for it but before whatever would be using it, because this gives me the flexibility to think about the problem in the general sense and produce an optimal solution without overspecialization.

VSCode's Rust plugin is a bit overzelous about dead code detection and runs it whenever the codebase is deemed to be correct, highlighting every item that isn't referenced from main, even if it is referenced from something else that's unreferenced.

Whenever I finally defeat the borrow checker and produce a correct solution my entire codebase lights up in yellow like a christmas tree and I'm completely addicted to this.

Three months after I switched to nouveau in anticipation of fixes backported from the open sourced driver to my 470 series card, some hours before a crucial meeting the hack I used to disable the official driver shat the bed. It took about 50 minutes to identify what broke and then 5 to fix it. How and why does Pacman overwrite my dkms blacklists?