makecheck

I forget sometimes how good it really is at blocking. I had blocked certain things long ago and when I eventually see the original accidentally somewhere else I am shocked by the annoyances.

One of the things I think protestware doesn’t understand is that the “users” of something are not clear-cut, and that should be especially obvious for things like chains of dependencies in modules/libraries. In other words, some (if not many or even most) people have no idea that something else they use (or even need) is depending on your stupid module.

For example, how would I know if my mouse driver software happens to use a certain Node module, and one of its auto-updates just starts breaking things? Yes, it would be a stupid technical decision on the part of the mouse driver company (and that company would ultimately be responsible for the fallout) but how does that help the person actually affected, in the meantime? And did the protestware developer really not think that someone “downstream” like this could be affected by such decisions? Not everyone is sitting at a terminal seeing a message printed out.

Of course there are other reasons too, e.g. you completely destroy your credibility as a project (or even potential employee in the industry) by pulling stunts like this, and how could that be worth it in the long run?

An important one often overlooked (due to our tendency to focus on just the “diff”): what else should be changing or could be affected?

Very easy to forget to change code that isn’t highlighted in the review.

I feel like the industry is really struggling with shipping “boring utilitarian things”. Rather than let software remain boring and just-plain-useful, it is forced to slowly transform into a nightmare of ads, pop-ups and other crap that is clearly NOT required for core functionality and ultimately the whole thing becomes awful to use.

Even when the intrusion is small, it is ridiculous because it is not required for the software to work (e.g. in the iPhone SETTINGS app, nothing about tweaking settings ever requires the user to view a stupid ad, and yet there they are, crappifying the UI).

And as I get older I am telling myself “this isn’t what I signed up for”: I want useful software that is free of garbage, especially when money is exchanged, and most certainly when a LOT of money is exchanged.

So tell these bean-counters to get the hell out, and let us make computers “only” useful instead of ad-spewing machines.

Definitely every one of these is sluggish at best on a very modern machine but they are also full of UI annoyances. God I am so tired of little spinners for things that would have displayed instantaneously on ten-year-old hardware with previous UI designs.

I’m also really tired of things that pretend to be single apps but every other thing you click on will jerk you into an entirely DIFFERENT app. Oh, a sidebar: logically, clicking any item on the side should always update the right-hand side, right? Nope: some of the items you click on might update the right-hand side (after displaying a stupid spinner of course); others will hurl you into the App Store app and slide in some un-Mac-like UI to display 3 pieces of information (usually with truncation that can’t be fixed in a view that can’t be resized); still others might just open a web page (one that only works in Safari of course, because to hell with your browser preferences).

Why is any of this crap necessary? It’s perfectly clear that Apple just doesn’t care at all anymore about making nice, smooth, usable experiences. More than that, they don’t seem to even know how their own desktop platform has traditionally behaved. But even if they did want to change how things behave, why are so many things behaving differently? It is a complete mess and they should be embarrassed. No leadership AT ALL on the UI front.

One method I’ve found: realizing that something I don’t like may simply be ripped out in its entirety at some point, and therefore I may be wasting time obsessing over its minor details right now. (And deleting hundreds of lines of an awful module later is a much better feeling than any amount of optimization beforehand.)

Also, I found that I tend to perfect only the things that I work on alone. As soon as anyone else is involved, you have to start worrying about things like not making difficult merges, and most perfections fall into the category of “PITA merge”. That grand 50,000-line code-reformatting that someone did will not really help, it will just come up again and again across 4 branches that they didn’t know existed, as each person trips over the same things. And I guarantee there is at least one tiny bug in that reformat somewhere. So don’t do it; keep things as close to what they were before as possible, pretty or not, for as long as it lives, unless you can be absolutely sure that there won’t be other branches out there.

I think this could help a lot with companies that clearly abandon some of their apps and let code slowly accumulate hundreds of tiny bugs.

Maybe projects that aren’t sexy and won’t get anyone promoted would still be fun to work on part-time.

If the big platforms let people with experience go tackle a few issues in their spare time without chaining them to a desk, maybe they could finally fix all these dumb bugs they’re accumulating.

I adopted this years ago for writing app “help” content, for roughly the same reasons Markdown was invented (e.g. it was annoying to have to mark up almost every word in text that was largely plain content, and the ability to drop in HTML as needed was super convenient). Although .md files “won”, I still use .textile today.

Having to be right “every time” is why it’s insane we still rely on things like SSNs and phone numbers that are difficult to replace but highly valuable and damaging if leaked.

We need to be exchanging personal data only in forms that become worthless and unidentifying in a short period of time, requiring secure refreshes to maintain.

I’m reminded of those Apple commercials where a person is wandering around town and is followed by increasingly large groups of people (e.g. the cashiers of all the places they were just shopping), creepily looking over their shoulders at everything.

This was never “OK” for people to be doing before the Internet/Facebook so why should it be “OK” now? Stalking is now stalking “with computers” so that makes it a novel concept?

P.S. That’s why you never give your phone number to ANY company, it’s too easy for them to connect a bunch of dots. And if a service one day decides to ask “for security”, interpret it as “for farming your data” and stop using them.

Apple likes to highlight all the ways their actions benefit developers, while ignoring all the ways their actions harm developers.

Well if you get to add money to your bottom line for all the great stuff you do, you should also have to subtract money for all the crappy things you do.

Off the top of my head:

- Developers should get a “cut” whenever Apple makes arbitrary changes that completely break 3rd-party apps. If the app’s code doesn’t change but Apple does change something, their behavior is literally creating problems for developers with no cost to Apple. Let’s charge them!

- Developers should get a “cut” whenever Apple is literally the reason for delay when trying to deliver things like critical fixes to customers. Let’s charge them!

- Developers should get a “cut” whenever their reputation is completely trashed by users because Apple refuses to acknowledge their own mistakes. In other words, Apple is perfectly happy to let users think apps are trash, even if the reason for the problem is Apple. Let’s charge them!

Apple doesn’t get to have only the good parts. I personally am sick and tired of all the ways they get to hide their awful behavior, and forcing developers to take the brunt of it.

The funny thing about that work-around is, what stops spammers from doing it either?

It’s the only income they receive in that case, and it is fixed, whereas their costs are variable (e.g. whether some app is downloaded thousands of times or dozens; whether apps decide to post video previews or not; they receive the same money but incur different costs on infrastructure).

App Review alone takes hours per update and is done many times a year for apps. Even if a single Apple employee is involved, and even if they are paid something pathetic like $5 an hour, that $99 will be eaten up quickly from reviews alone.

My point is that it doesn’t add up; Apple likes to claim all these “costs” for “running” the App Store but there are gaping holes in their accounting unless you consider that not all developers are really equal here.

Apple allows “free apps” that are entirely ad-supported, never giving Apple a dime (aside from $99/year), yet they are consuming infrastructure: hosting pages, downloads, reviewer time, etc. Why isn’t Apple concerned about any of those costs? Simple: they make overwhelmingly most of their App Store money from the handful of developers that offer purchases. This also leads to perverse outcomes like Apple dragging its feet on scams that make them heaps of money.

Developers are literally subsidizing other developers, and it’s not necessarily the richest ones helping the poorest ones. Someone trying to make money on a $0.99 app is sacrificing more to Apple than Facebook does with their free app.

That’s why I find all these percentage and payment discussions weird: income is so insanely distributed that a lot of this literally does not apply to more than 80% of the stuff on the store. There are fundamental issues that need to be resolved too.

I kind of wish the world would just move on from “star reviews”...they have so many problems that make them impossible to depend on, and yet psychologically it is hard to ignore whatever they say! They doom good products, promote bad ones, and generally do not force reviewers to even write something relevant to the product (cases like this). On top of that, they can literally be “bought” by the thousands.

Worse, stores do not encourage customers to follow proper channels for things like support or feedback. People clearly can’t figure out any other way to communicate so they use that giant “review” text field to vent about anything and everything.

What’s better? Remove all reviews. Publish real numbers, like: downloads, time spent using, time installed on device (I would love to see scam apps fail once everyone can see they have an “average time on device” of 30 seconds). And, make proper support channels much more obvious on store pages (not to mention, enough gatekeeping: let developers interact with their customers much more directly).

There is a difference between “the app has a pretty UI to set something” and “this setting is configurable”.

One of the great things about the Mac is that there is always the option to defer certain advanced settings to the `defaults` program on the command line (or just things you want to make configurable but do not yet have time to extend the GUI). So if you want a somewhat-streamlined UI with just a few of the most common options, you can do that without completely sacrificing the ability to expose the rest somewhere else.

It’s really too bad; I found the tagging alone to be far more descriptive than any other site, e.g. I can literally tell in an instant if a job is using: this IDE, that language, that build environment; and ultimately I can tell in seconds if the job makes any sense for me.

Frankly I have no problem with ads that are simple (text/images/untracked). The ad industry has made it clear they would rather be utterly obnoxious and creepy so therefore as far as I’m concerned they can wither and die.

Firefox+addons seem to work best for blocking ads which is why I am increasingly concerned about that browser being marginalized.

They also seem to design everything as if you’re going to press downward like some iPad in your lap. That’s wrong: since the screen is completely vertical, there’s a good chance your finger won’t accurately land on the spot you’re trying to reach. The area recognized for each button needs to be a lot bigger vertically, including the area above and below the icon/label. (The Apple Watch has a similar problem; when you try to press on it when tilted on your wrist, it is a lot harder to touch vertically-narrow buttons.)

What I want to see are very “tall” buttons WITH BORDERS ON THEM that are large enough to still hit when my finger slips down a bit, as it often does on such a display.

As a counter-point, my app was able to rely on the system Python 2.7 for FIFTEEN YEARS because it was an extremely stable component of the OS (and it allowed the app binary to be literally 10 megabytes).

Now? I honestly can’t think of a way to release without adding something like 100-200 MB to the app bundle, consisting of an entire Python installation. With a user-facing app it is not ideal to try to say something like “just download Python and tell me where it is”.

In the days when it was OS 10.8, 10.9, etc. those were major versions, updated over a year and a half apart.

Apple may call it “12.3” now but it is still released every few weeks or months, with just as much randomness as 10.8.3 would have been.

In a way, sure; but shouldn’t this have been a “macOS 11.0” or “macOS 12.0” change?

Slipping it into some minor update that many users will install without a second thought is not a reasonable thing. It could break software that people use, not realizing they depend on Python to use it.

At least two things happened here:

- The pandemic gave most people an unusually-long period of time at home to help them realize all the things they could have been doing (e.g. spending more time with family, not being stuck in a commute), if only their work had not been sucking up all their time and energy.

- Income vs. expenses changed to the point where people couldn’t hope to pay off their debts even if they worked. Work has not been paying anywhere near enough. At that point, what is there to lose: if you will be swamped and in debt with work, and you will also be swamped and in debt without work, at least the 2nd option means finally not having to put up with the crap from many workplaces.

Also, it has just become clearer and clearer where all the lies were told. Society did not treat “essential” workers that way at all. There was all kinds of prioritization of bottom line over employee health, especially early on. We all assumed that governments could/would do a lot more to help. Heap on all the unfilled promises for promotions, raises, etc. and many workers just have no reason at all to give a crap anymore.

I find that subprocesses are primarily valuable for stability and security, e.g. dealing with something that might crash (killing only the subprocess) or something that requires different privileges than the main process. And yet, the communication to (and possibly from) the child incurs a cost that cannot be ignored, more than what a simple wrapper to another language would have.

I think they’ve gotten remarkably far with the language but they still desperately need to build an “opinionated subset” (of both the language and the STL) so that new generations have a hope of learning it properly. Perhaps modules will make it easier to do so in a way that allows interoperable code.

I would love to see a backward-compatibility compiler and library that is essentially whatever C++ is now, frozen in time: any “.cpp”/“.cc” file is simply built with that. All new C++25 code should be something else (maybe “.ocp” for Opinionated C++?).

The “.ocp” files would build against a complete replacement for the compiler and standard library, offering ONLY the sane subset of the original language and library that we have always needed. Finally remove all these constructs that we are not supposed to be using anymore. Throw std::iostream into a dumpster and set it on fire. Refactor all of this code that had to be implemented in weird ways simply because of the desire for perfect backward-compatibility. And finally take the opportunity to have sane defaults, which alone will probably allow 12 different keywords to be stripped out of the evolved language.

While I think it is always good to see progress in the performance of interpreters, ultimately it is a mistake if you have something that needs to be fast and you implemented it entirely in an interpreted language (beyond just prototyping).

You have to be prepared to factor out the key parts of the code into faster languages like C++ with bindings, if necessary. Or you can virtually do this, e.g. learn more about the standard library, make sure you are choosing things that actually are implemented natively underneath instead of in pure Python, etc.

And sometimes, you find that the cause of a slowdown is far more fundamental (e.g. the entire algorithm is not good, and you see huge gains by redoing it, even if everything is still interpreted code).

Worse, even without the vectors, the initialization of single variables of these types would be different with the same syntax, e.g.

    string s; // initialized (empty)
    int i; // NOT initialized (garbage value)
    static int i; // initialized (to zero)
    char c; // NOT initialized (garbage value)

...I mean, it’s always been a complete mess.

Yes, “but” company projects often reach a certain size because of the fact that they’re driven by potential profit and have large investment. Whatever hobby/volunteer task you may find, while it might be interesting it probably will not be as far-reaching as what a job could entail. (That’s not to say they couldn’t still reach a lot, e.g. thousands of downloads, just maybe not what a company project could do.)

As long as you have an Apple ID (developer account), you can download Xcode from developer.apple.com (no store), though it is a few clicks to find where they bury release-quality app downloads.

Like Facebook and other networks, the fundamental problem is that you need “everyone” you interact with to move to the new thing at the same time, otherwise the new thing is basically useless.

At this point in time, I feel like the solution is more likely to be based in laws (e.g. “seamless export/migration must be supported”), and not in technology. That way, at least you remove the friction of having to recreate an entire profile, etc. on a new platform, and you “only” have to convince all your friends/colleagues to try migrating to the new thing (automatically).