Anaminus

One time, this annoyed me so much that I made a website.

https://anaminus.github.io/langding/

om would fall under "Yes, must scroll".

I was going to ask, is there a standard for this sort of thing? Then I realized that it's just references in the form of text. Hypertext, if you will. We should make a markup language for it.

The lock file is 12 times larger than the entire source.

  git clone -q https://github.com/paaatrick/playball.git
  cd playball
  echo $(du -bs package-lock.json | cut -f1) / $(du -bs src | cut -f1) | bc -l

This sort of thing is why packages should always be namespaced. Just "base64" without any additional qualifiers makes it seem more official and definitive than it actually is.

This is a thing in Lua as well, with do-end blocks:

    local foo
    do
        local bar = 42
        -- Same as `foo = function() ... end`, so this sets the local foo variable.
        function foo()
            return bar
        end
    end

Because Lua has no significant whitespace, it can be made to look like some kind of specific syntax:

    local foo do
        local bar = 42
        function foo()
            return bar
        end
    end

Though I think this is too clever, so I like to insert a semi-colon to make it clear what is happening:

    local foo; do
        local bar = 42
        function foo()
            return bar
        end
    end

1. Use a passphrase generator to produce two or three words

2. Smash pieces of the words together until you get something that looks good.

e.g. blurred grumble ambiguity:

- Blurlamb

- Redblig

- Leguity

Don't worry about the meaning. The meaning emerges from the identity you give it.

Extra credit: Look it up to make sure it isn't a dirty word in some foreign language. Happens more often than you think.

This one amuses me. You skip the long-windedness of the front page to look at the pictures. Your eyes are caught by two example user interfaces: contact forms. The one on the left looks great. The one on the right looks awful. Yet it's the one on the left that has the big red X next to it. So you backtrack to read why they're wrong. The reason is because borders "feel" busy and cluttered. Nothing empirical. No data to back it up. Just "feelings".

This led me to believe the whole website/book is going to be like this, so I haven't read any further. I'm sure it's great.

I've been calling it Pepsi Logo Kool-Aid.

I once read that either FreeBSD or OpenBSD was the "bad one". I forget which it was, but given that BSD is the Linux of Linux, I don't really think about it.

I figured this would happen. I've also committed the even greater sin of testing in only one environment (my own). I guess we don't quite live in the future yet.

Vision: Game Boy Advance-sized website.

Problem: Very tiny.

Solution: Scale to viewport in integer increments.

Result: https://anaminus.github.io/

This disables zoom. In fact, it actively fights the zoom level to always fit the viewport. Have I committed a great sin?

I WILL use todo for everything! But instead of committing them inline, I will dump them into a TODO file that is ignored by the VCS. If this file starts getting too big, then I'll move some of the long-standing todos out to an issue tracker.

> Why not just go straight to the issue tracker?

An issue tracker adds a lot of overhead. It's sitting on a different system, so you have to have a separate window open. It's public, so you have to spend time producing a comprehensible issue. Every action is a commitment. Internet access is essential.

Meanwhile, TODO is just a file, so it can sit right next to your code. Its private, so you can just stream thoughts right into it and move on. Adding an item is as simple as typing out some lines, and removing that item is as simple as deleting some lines. Need to search? Just grep it. It's fast, and it doesn't leave a mess in your code.

If I can't clean the copyright grease off of my work, can I just waive the ability to enforce it?

  <LICENSE>+GOAWAY
  
  This license must never be enforced.

I'm sure some verbose laywerspeak is required to make it ironclad, if it even works at all.

What I can say is that, when the payout program started, all payout requests did go through a manual process (the minimum rate was the same then, by the way). Later on, there is evidence of account "snapshots", which is used to track income made before and after Roblox bumped the exchange rate up [1], which is described with some detail [2]. So it's not unlikely that there are other kinds of counters keeping track of income sources. Even so, there is still evidence for some sort of manual processing, at least up to last December [3].

[1]: https://devforum.roblox.com/t/the-robux-exchange-rate-and-mo... [2]: https://devforum.roblox.com/t/the-robux-exchange-rate-and-mo... [3]: https://devforum.roblox.com/t/holiday-schedule-for-the-devex...

Worth noting that, since the currency can also come from a handful of other sources (e.g. trading cosmetics), each cash-out is manually reviewed to ensure that the currency only comes from approved sources (sale of assets, games, products). Because of this, reducing the minimum payout does not scale, and at some point becomes infeasible. The article and video, of course, both fail to mention this.

Maybe throwing more manpower at the problem will let them reduce the minimum rate. Or they could work on altering their infrastructure to support a more automated system, possibly eliminating the minimum rate entirely.

Sometimes people don't actually want help, they just want to complain. Other people misinterpret this as a question or a debate, so their explanatory responses are received negatively. You'll find that this also applies to C++, Rust, every programming language, and anything in general.

Program that interfaces AutoHotKey and youtube-dl so that I can easily play or download things with shortcuts. Haven't played a youtube video from the actual website in years (don't tell anyone).

Program that lets me keep track of the last time I did something (brush teeth, exercise, vacuum the floors, etc), which motivates me to do these things more regularly.

Program to convert between various units of bits, mostly so that I could do a calculation regarding download speeds.

Program to run programs without a shell, so that I could run certain commands on startup (it was faster to implement than to find an existing solution) [1].

Library to dump various useful information out of a Pokemon ROM, so that I could play the game more efficiently [2].

Playing card library, so that I could simulate certain solitaire games and figure out the chances of winning [3].

Program to quickly parse and generate markdown files from source code comments, existing solutions being too complex or not working quite the way I wanted [4]. This one ended up being a real winner, because it let me stop worrying about presentation and get back to writing code/documentation.

There's this sort of multi-tool I've been working on for game development on Roblox (very niche) [5]. A high-level overview is that it uses scripting to streamline certain workflows that would otherwise be tedious, such as parsing proprietary file formats, interacting with web APIs, or assembling a project into a final product. It's a winner because it lets me make even more tools for myself.

[1]: https://github.com/Anaminus/nosh

[2]: https://github.com/Anaminus/pkm

[3]: https://github.com/Anaminus/cards

[4]: https://github.com/Anaminus/qdoc

[5]: https://github.com/Anaminus/rbxmk

JSON5 pretty much addresses all the problems with JSON as a config format. I'd love for it to just replace JSON entirely.

https://json5.org/

"Opinionated" means decisions that have already been made for you.

This sort of thing has never worked for me. It's like the snooze button on an alarm clock; instead of hitting this relatively large button, even my half-asleep brain will precisely locate the off switch every single time.

I've found greater success in just observing my impulses. While I'm working, I might get a desire to type the "hn" keyword into my URL bar (guess where it goes). But because I've noticed this before it happened, I can choose to not do it. If I find myself "idling" on such distractions without realizing, then that means it's time to do something else. Get back to work. Take a break and relax. Get off the screen entirely. Anything else, just don't idle. This seems to get easier with practice.

For me at least, the reluctance comes from the new proposal process not having yet proved itself for large backwards-incompatible features. I want to be assured that a Go with generics is a Go with a really well-integrated feature, and not some grafted mutant appendage whose only real purpose is to appease the greater community.

It's great that they're trying out the process on smaller, more simple proposals. My hope is that this system will either produce really good features, or reveal that there are simply no satisfying solutions.