Anyone can become a designer, some just face a longer journey than others.
Like people who set a monospace font and then specify section margins that aren't an integer number of characters.

So today I learned how tree shaking works and I was just about to publish patches to my NPM modules when the registry gave up.

I just wrote 80+ lines of tests for a 30 line module and I was really mad at myself for wasting my time like that, until I remembered that while writing those tests I did actually catch several really tricky bugs and it didn't even take that long.

I wanna go back to the age where a C program was considered secure and isolated based on its system interface rathe than its speed. I want a future where safety does not imply inefficiency. I hate spectre and I hate that an abstraction as simple and robust as assembly is so leaky that just by exposing it you've pretty much forfeited all your secrets.
And I especially hate that we chose to solve this by locking down everything rather than inventing an abstraction that's a similarly good compile target but better represents CPUs and therefore does not leak.

I was passed someone else's homework which included describing what certain Bash commands do. I've a fair bit of experience and I can't imagine why this one would be useful, can you think of any use for it?

(find -type d) | grep public | tr './p' ' '

I finally figured out how to get myself to take regular breaks

To the bright engineer who considered it a good idea to open Zoom's toast popups in their own windows without tagging them appropriately as frameless short-lived managed popups:

Ride a hedgehog to work, you lazy fuck.

Viruses are quine programs written for cells.

A word of advice:
If you integrate email verification very tightly in the registration flow, it will be a world of pain to implement changing the email address.
It's alright, I didn't want to do anything this afternoon anyway.

What's the minimal feature set that can make a language as ornamented as JS into a comfortable REPL?
Should I write a full parser or should I try to patch my way around with regex?
It will have to interface a lot with JS so it has to be able to manage JS datastructures in some fashion, which means that I can't just make a whole new command line with its own programs.

My current plan:
Some delimiter (probably a semicolon) will take the output of a command and inject it in the next in case you decide halfway through a line to do some more processing, It also awaits promises and does some other nice stuff to make controlling such pipelines easy. I have an elaborate system in mind to decide where a value must be injected to make the line valid so in most cases you don't even have to indicate it. JS has beautifully simple syntax rules so I have a lot of technical balance to burn before I start building technical debt.

I have some ideas for automatic parentheses and commas in function calls. I realize while using a command line you do not want to tap shift often. My main idea here is that two names or values in js are always joined by an operator so the first missing operator is a call and following missing operators are commas until the end of line. This has lots of nasty edge cases though, like that no argument expression can begin with a unary operator or a bracket of any shape. You can always prepend a comma but it's cognitive load.

Anyway, do you have any suggestion or warning besides "js bad" which I know but it's the most popular sandboxable language and has a massive existing set of libraries which I kinda need.

Can we take a moment to recognize how absolutely retarded JS' event system is?
Events aren't objects. No, they're managed by an object, and identified by a string.
To subscribe to an event, you call object.addEventListener(name, callback). Because for some reason we can't just have an event object. Events MUST have an owner.
But to unsubscribe you don't call the function addEventListener returned, you don't use the token it returned either. No, you pass the same function to removeEventListener.
Because we don't use serializable tokens like in PP, and we don't return functions like in FP, no, we use functions as tokens, realising idiomatic DFP.

Redux is weird, and I don't like it because it violates the most basic principles of responsibility. The concept of expressing state changes as reducers is nice because it can be duplicated, saved and restored and compared for equality. So is creating isolated accessors and selectors. However, I really don't think a reducer should be aware of its own position in the hierarchy. When specifying an action you aren't addressing a reducer, you're addressing the tree. That the tree doesn't manage this addressing and expects reducers to identify themselves is a bit strange, especially considering that the whole point of having a tree is that reducers shouldn't be affected by their position in that tree because they're pure. Same goes for selectors, they should belong to the tree, not to any particular sub-reducer. Separating the slices is reasonable structure, but if you specify parts of the addressing in the slice and parts of it in the root you might as well just use separate reducers for each of your slices. It's functionally equivalent.

The primary concept of reactive programming is great. The idea that things just naturally re-run when anything they rely on is changed is amazing. Really, I think it's the next step in programming language development and within a decade or two at least one of the top 5 programming languages will be built entirely on this principle.
BUT
Expecting every dependency to be used unconditionally is stupid. Code that checks everything it might need all the time even if a decision can be made from much less information is simply bad, inefficient code. If you want to build a list of dependencies automatically, you have to parse the source.
And I really hate that there are TONS of languages that either make the AST readable at runtime or ship with a very powerful preprocessor that could be used to analyse expressions and build dependency lists, but by its sheer popularity the language we're trying to knead into something it was never and still isn't meant to be is JavaScript.

So, I turned on my old phone to transfer all my p̶o̶r̶n̶ photos, and it crashed from the notifications.

And I understand that it's an underpowered device and notifications aren't expected to come by the hundreds, but how terribly misdesigned must a pubsub system like Push be for the client to crash?

A word of advice to any new Arch user: don't use lxdm for your display manager. It's utter shit. The package hijacks the symlink of any other DM when you install it, and it refocuses the DM on a 5 second loop while it's running, making it a pain in the ass to use a VT. LightDM was broken temporarily so I had to install it, but frankly, I don't ever want to touch thiis piece of software again.

I'd like to learn about functional programming. What books, courses, tutorials or articles would you suggest? I have a good understanding of abstract algebra and I felt the need to learn it because my Typescript is a mess and I visibly don't know what I'm doing.

Fun fact!

Xiaomi has a restriction where you're only allowed a bootloader unlock key one week after you've requested it. No, not a week after you've bought the phone. Not a week after you created an account and generated so much usage data that it would be stupid to doubt you're a genuine user.
No, you have to wait one week after installing their fucking desktop app and getting past some arbitrary point in the process.

Seriously, how much shit can this company pull with a straight face? At this point they're just sabotaging me, it's not even for any reason.

I decided to use Docker Compose on a tiny project that essentially consists of an API and a Caddy server that serves static files and proxies to the API, all of this running on an EC2 t1-nano. I made this admittedly odd choice because I wanted to learn Compose and simultaneously forego figuring out why the node-gyp bindings for sqlite3 refuse to build on EC2 even though it builds just fine on my machine.

I am storing secrets in .env which is committed into the private GH repo. Just now I came across a rant that described the same security practice and it sounded pretty bad from an outside perspective so I decided to research alternatives.

Apparently professional methods for storing secrets generally have higher system requirements than a t1-nano. I'm not looking for a complex service orchestration system, I'm not trying to run an enterprise on this poor little cloud-based raspberry pi. I just want to move my secrets out of the Git repo,

Any tips?

I wish all you frontend devs who use the keydown event to hack tab-order a very painful and very quick death.
Especially those who fail to ensure that TAB; Shift+TAB is always identity.

[!dev]
Today I learned that although the frequency unit Hertz is named after a person, the German name for heart - the most human example of a periodic system - is also Herz, pronounced the same.

Checking for root is maintaining a false façade of security. By the definition of root it can always be bypassed and we should be designing workflows to discourage logging in from an untrusted device unless you have 2fa.

Xiaomi's bootloader unlock procedure is So. Fucking. Tedious. I have no words... oh wait, I do. HIDING THE PERMISSION BEHIND A HUNDRED DEVICE-SIDE SWITCHES WON'T MAKE IT ANY SAFER, IT WILL ONLY MAKE MODDERS ANGRY. Why do you need a third switch besides OEM unlock and USB debugging anyway? If I toggled OEM unlock it's obvious what I'm trying to do and every other option should change to comply with that intent. Don't roll your own Android if you know fuckall about UX.

After using Linux every day for 3 years today I learned that listing directories requires the execute permission.

In a misdirected attempt to solve my problems I also learned the basic concepts of SELinux before realising that SELinux is disabled on the host and not present on the guest.

How is it that in the age of 98%+ reliable contraception incest is more stigmatized than a relationship between an authority figure and their subordinate? sex=children hasn't been the case for decades now.

It's probably no news that I love Typescript's versatile and powerful generics. Today I found what is probably the most brilliant use of these tools to solve a real problem. This package exports one generic type which takes one generic argument, reads it like a JSON schema and returns the Typescript type for it:

https://github.com/YuJianrong/...

How the fuck does TypeScript still not have service worker support? Seriously, it's just a typings file. People have written that typings file. They would just have to include it in the lib collection shipped with the compiler. Yeah, it would have DOM calls intermixed with the SW api, but frankly, having the typings for a set of calls you can't use is infinitely better than missing them for a set of calls you can.
The relevant issue is 5 years old btw.

"Failing upwards" is not a thing, you're just denying the damage you caused and therefore lying by implication.

I just released my first NPM package that is actually functional and used in a private project (https://npmjs.com/package/@lbfalvy/...) and I have to say, the quality of debug tooling for Node is abysmal. I spent 4 hours just on Webpack's "Field browser doesn't contain a valid alias configuration" error which simply means "package not found", and then getting Rollup to output a working compiled javascript _and_ a d.ts was its own day-long ordeal.

Tools are made for various audiences. Git is the de-facto standard for version management, so it can be complicated because people will still learn it (they more or less have to). Editors aren't as standard and they are to be used from the minute you start learning, so they have to at least be usable without a course or a handbook. I prefer the first type of tool because to use something really good I don't mind reading a book. Programming languages can fall in either category; Python was meant to be used by laics and is therefore very simple, sacrificing a lot for the sake of simplicity. Rust isn't meant to be used by anyone who isn't trained, and it comes with a great book that explains all the most important gotchas. Haskell doesn't have an official book AFAIK, but it has the best wiki I've ever seen in a programming language.

Thread-based asynchronity is the best because you can run operations in parallel that weren't designed to run in parallel.
Thread-based asynchronity is the worst because you can run operations in parallel that weren't designed to run in parallel.