ubertaco

>Whatever your thing is, make the thing you wish you had found when you were learning. Don’t judge your results by “claps” or retweets or stars or upvotes - just talk to yourself from 3 months ago. I keep an almost-daily dev blog written for no one else but me.

>Guess what? It’s not about reaching as many people as possible with your content. If you can do that, great, remember me when you’re famous. But chances are that by far the biggest beneficiary of you trying to help past you is future you. If others benefit, that’s icing.

I feel like this is sorta counter to the "peacockers who write posts about mundane things", because it's very explicitly "these are my notes for me".

You might say "why in public, then?", and I think the value _does_ get to "if someone else benefits" -- but admittedly, that requires some straining out the obvious materials (but really, are you that likely to keep around a blog post about "today I learned what public static void main(String[] args) means" for your own reference later?)

That's sorta Musk's primary operating mode. See also: the whole Twitter purchase fiasco (for a recent example), or the expensive lawsuit against the actual co-founders of the larger, more-successful tech company that bailed out his failing startup as a favor to him but didn't stroke his ego enough on titles (for a "this has always been his way" example)

This is indeed the main thing I use Spotlight/Alfred for on MacOS: I want to go to the window for this app, regardless of what virtual desktop it's on, and I don't want to hunt for it.

I use that "text-based finder" approach _everywhere_:

    - Telescope in NeoVim (https://github.com/nvim-telescope/telescope.nvim)  
    - The "Actions" (Cmd-Shift-A) and "Find Anything" (Shift-Shift) shortcuts in IntelliJ
    - Alfred on my work macbook
    - KRunner on my personal linux laptop (with KDE)
    - The `t` shortcut on github to jump to files
    - the `!` "bang" shortcuts on DuckDuckGo

I have the hardcore vim brainworms of "don't make me touch the mouse", and in _spades_ if that mouse is a laptop trackpad.

I haven't found a good equivalent on Windows, not because they don't exist, but because they're all focused on trying to do everything _but_ launch fast and swap to the application I want...so they wind up taking 4-5 seconds between "hit keyboard shortcut that invokes it" and "start typing", because they're busy indexing the registry or my recycle bin or whatever.

Exactly. Licensing is the easy part. Deploy + run are the hard parts, IMO.

You can build something amazing like Immich, a shining example of open-source software that, after a lot of setup, "just works"....until the next release wants you to make well-informed decisions to your `docker-compose.yaml` file.

My wife, who likes Immich but has no interest in learning to code, is not going to do those things if I get hit by a bus, because she won't know how. She's gonna give up and just go with paying some service for photo storage, or else losing photos like everyone else.

I wrote one once that I tried to also express using bad UML, as a sort of artistic experiment.

It was...not great. I still think the work was a decent expression of my emotional state at the time, even if the UML-ified version sucked.

(but then, _a lot_ of UML sucks, so....)

I didn't care about tabs vs spaces until I was handed a project to work on accessibility for a particular webapp, and that included firing up a screen reader.

That got me to learning about all the ways that markup can (and should) be used to convey _both_ the content _and_ the structure of the information on the screen, for the benefit of vision-impaired readers.

That in turn led to the epiphany that the tab character _is_ markup for indentation, and in the world of programming, where indentation is so significant for understanding (especially in whitespace-sensitive languages like Python), I wondered why we were making things harder for vision-impaired users by focusing so much on _visual_ consistency (which can still be achieved by syncing editor "how do I render tabs" settings)

Sounds like AI-generated content to me, especially since it's often fed into spam emails/comments/blog-posts.

I might suggest reading the second and third sentences of the article, which directly refute your interpretation:

>Want to try a craft or artistic hobby? Focus on mastering the skill and enjoy the variety it can provide.

"Focus on mastering the skill" is directly the opposite of "actively suck at what you do and take no pride in your work".

>Let me counter this with an age old adage that is simply true

A thing that is repeated often enough isn't "simply true" just because it's repeated often enough. Perhaps consider the situational applicability and limited-exhaustiveness of pithy proverbs.

I don't think it's "do things without an audience"; I think it's "don't give the audience absolute authority over your ability to enjoy the thing".

Comedy is good with an audience, and not so much without, so it's a great example.

If you're doing comedy as a hobby, even though comedy is done for an audience, then you can feel free to take time away (or stop entirely) when it's no longer interesting to you. If you're doing it "for the audience" in the sense that the OP is talking about (where the audience is the only point, rather than just being a part of the experience of your enjoyment of doing comedy), then no, the show must go on and you must sacrifice your own interests for the audience's sake.

It's sorta like the difference between the low-key hobbyist mindset of selling something at the local farmer's market vs the high-pressure "obligation to the shareholders" mindset of corporations.

Or to go back to the article title's advice to "stop acting like you're famous": a member of a local improv troupe might doesn't have to spend much of their life worrying about what the paparazzi will say or how the critics or box-office numbers will judge their improv (even though the improv is very directly a performance for an audience), but an A-list celebrity actor does have to keep that awareness in mind at nearly all times, and it often makes their life miserable.

Yeah, I think another way to think about this is "don't get distracted with cultivating and maintaining your brand", rather than "don't find any particular way that you enjoy doing the thing."

One of those is performative and creates pressure and expectation, often at the expense of personal enjoyment and rest. The other is just finding the bit that's interesting to you.

I mean, this is part of the story of Caravaggio, right? So much of the standards for art (if you wanted any patronage) at the time were around "what is the church willing to pay for", and Caravaggio alternated between painting stuff that would get him money from the church, and painting stuff that the church wouldn't condone (because of the unapproved ways he used particular symbols, or because they were just secular subject matter).

Well, that and his tendency to murder folks, of course. But that part's less relevant to the "how old is art-for-money-vs-art-for-art" discussion.

> My approach prefers extracting IO operations to adapters, testing them separately, then using reliable fakes to test the bulk of the system’s behavior from the outside

...which is exactly a unit test.

If you want to talk about "functional core, imperative shell" and its implications for tests, then do _that_. Writing clickbaity titles that directly contradict the content of your short blog post itself isn't a great way to foster nuanced discussion.

Yeah, I'm having trouble seeing how Rust/Nim/Gleam can be written in a logic programming style (like Prolog or Datalog).

At minimum, that means there are _two_ paradigms: logic programming and "beyond paradigms"....which sorta means that we're not really beyond paradigms now, are we?

I think the reality is that certain previously-niche paradigms became cool again, and folks started grabbing off some of the most-visible pieces of those paradigms (pattern-matching, ADTs, map/reduce/filter, maybe even a pipeline operator) and adapting them to other paradigms.

The example of Rust is one where no types are nullable by default, but only if you wrap them in an `Option<T>`.

Given these two function signatures:

    pub fn getUser() -> User

    pub fn getMaybeUser() -> Option<User>

This code won't compile, because `getUser()` cannot return a `None`:

    pub fn foo() -> Option<String> {
        let user = getUser()?;
        return user.name
    }
    

But this code will compile:

    pub fn foo2() -> Option<String> {
        let user = getMaybeUser()?;
        return Some(user.name)
    }

(rust playground link: https://play.rust-lang.org/?version=stable&mode=debug&editio...)

I'm still surprised the "use" syntax survived the 0.x release "experimentation" phase.

It's more confusing than explicit "I can read and tell what this is doing by matching the braces" callbacks, _and_ it's more confusing (and less expressive) than full-on do-notation (or F#-like "computation expressions").

Instead, it's the worst possible middle ground: it's a third, different mental model that is unfamiliar in an already-unfamiliar language amid other "rough-edges" choices (like not having if-then statements -- even though you can pattern-match on `case true...case false`, it's still another rock in the shoe), but it doesn't offer improved clarity (since you have to keep "what will the real code look like when this is desugared" in mind constantly when figuring out which variables to `use` and which to just assign, and which parameters should stay in the function call and which should get "magically" floated outside the parens, and so on...), nor does it offer improved power/flexibility (in the way that do-notation does, where you can generalize expressing any given nested/monadic operations as though they were not nested).

I love ML-family languages, and I find the BEAM VM intriguing. I want Gleam to be great, but it has just enough friction (in the form of unique-but-not-clearer-or-more-powerful language decisions) and just enough limitation (in the form of a very limited standard library) that I think it's currently just "okay".

Hey, thanks for responding! That's reassuring, but...how much input would Max still have to Homebrew if he chose to "return"? Like, if tomorrow Max decides that Homebrew is a great vector for another crypto scam, will the existing group of maintainers be able (and willing) to reject any changes in that direction?

To extend the thought experiment further, imagine if, in the co-op scenario, a survey was run to collect information about whether employees still wanted the company to buy local fish...and then the employees who didn't were slowly whittled down to a minority through selective firings.

The tendency for the most ruthless in leadership to "take the wheel" by excising any from the organization who aren't on board with increased ruthlessness is a common one (see the current GOP in the US, various stories of Soviet leadership, and common trends in executive-turnover-immediately-preceding-layoffs).

EDIT: if you're reading my comment, please see the response from Mike McQuaid, who's the _current_ project leader for Homebrew. It's good to know Max isn't involved over there anymore! Gonna leave my original comment below this line, so that the context still makes sense:

----

That fact paired with the fact that the guy behind Tea.xyz is the same as the guy behind Homebrew makes me _really_ distrust Homebrew going forward.

He's taking money from known crypto scammers to launch AI-generated nonsense (the pkgx nonsense from HN the other day) and abusive crypto-monetization patterns (this tea.xyz thing).

His biggest claim to fame was...a ripoff of the Arch User Repository, which is useful, sure, but not something that instills a lot of confidence in the "wants to promote himself off the back of others' work" aspect of his résumé thus far.

Gonna look into good alternatives to Homebrew.

Eh, the stock market was _always_ out of touch with reality. It's just that the rapid acceleration of income inequality (and thus, capital inequality) as made that way more visible than it used to be.

This is because the stock market has always been a measure of "how well are corporations doing?", _not_ a measure of "how well is the average individual doing?"

When economies shift harder to benefiting corporations in a way that disproportionately benefits those at the very top of the corporation and aggressively shrinks the benefits to those lower down in the corporation, the question of "how well are corporations doing?" has less and less to do with the question of "how well is the average individual doing?", except _maybe_ to have a negative correlation (although even when corporations aren't doing well, the average individual still sometimes gets screwed, like in the bank bailouts of 2008, or the PPP loans during COVID -- the whole "privatize the profits, socialize the losses" game that is now a core part of US corporate economic strategy).

>Sweep is open source (licensed under AGPL) and runs entirely on your laptop. The only remote calls will be to OpenAI.

Okay, so like...the part of this that's actually interesting is the part that doesn't run on my laptop, and instead requires handing my source code to an untrustworthy third party?

"The car runs entirely on electricity. The only part that requires gasoline is the engine."

I would love this. I created a Codeberg account to contribute to an OSS Android app I liked. Then, (thankfully, after my contribution was merged) I had a situation where I lost access to my 2fa codes. I could provide other identity verification, but where? Their official docs tell you there's a support at Codeberg email address....but that nobody looks at that inbox. They link a Discord room (kinda defeats the appeal of an EU-hosted indie forge, but okay). I went in there, and was told (eventually, when the apparently sole employee in the room) that I was out of luck. Not because they couldn't verify my identity or anything, but because support for account-related issues is something they categorically do not offer.

I'd love to regain the ability to contribute to stuff that is trapped in the Codeberg ice without having to create another account on a service with that sort of ramshackle operating approach.

I mean, it's an alternative for Bandcamp's _software_. It's not an alternative for Bandcamp's _infra_, and that's a pretty significant cost-and-complexity center for a new band or solo artist that just wants their music out there for purchase.

Still, I think getting viable alternative software is a huge checkbox on the path to getting good alternatives. Now there just needs to be an affordable hosting company that'll run Faircamp for up-and-coming artists.

It's been a few years since I did frontend dev, but Safari was _absolutely_ the most difficult browser we had to develop for, _especially_ on iOS.

With IE, you can polyfill missing APIs. With Safari, you have to put in extra work to ensure your polyfills override Safari's built-in implementations in all sorts of exciting ways based on which particular Safari version someone is running, because it's _obnoxiously_ common for Safari to have broken or incomplete implementations of web APIs. So if you're just checking for the presence of some particular global, it'll be there...but it'll be subtly broken in various ways. We had constant issues with Safari's implementations of LocalStorage and IndexedDB, and with its weird tendency to "ghost-hover" over elements after a completely different element in the page was tapped/clicked, and that's just what's off the top of my head from when I last did frontend dev consistently (about 7ish years ago).

The only way to repro any of Safari's weird bugs nonsense, of course, was to shell out for a Mac or iOS device. You can't repro any Safari issues on any other, less-expensive platform. It's classic Oracle-style vendor lock-in with their vertically-walled-off tooling and lack of test images.

Except at least Oracle never put out a constantly-broken browser, let alone one that had -- and still has -- monopoly capture of an entire platform.

If you've got a desktop Firefox or Chrome issue, you can launch Firefox or Chrome on a cheap Linux or Windows machine or VM and repro it, and then snapshot the VM for reproducibility.

If you've got a mobile Firefox or Chrome issue, you can launch Firefox or Chrome on a cheap android device (or emulator), and if for some reason it really truly proves to be something Google or Mozilla hasn't implemented correctly _and_ you can't polyfill it...then you can advise users to try a different browser as a workaround.

There _is no_ "different browser" on iOS. If Apple has screwed up yet another standard web API, your users are hosed unless you can get really creative at dancing around their broken pile of crap.

I left Salesforce exactly _because_ this was a lie 4ish layoffs ago, and I have no reason to believe it's less of a lie now.

They cut my engineering group into 1/3rd its size, put the other 2/3rds on a greenfield project, and gave us a couple of weeks to complete handoff such that the remaining 1/3rd had to maintain/finish/handle-support-for everything that the 2/3rds group used to own. This all happened in the _middle_ of one of their three yearly waterfall-planned release cycles, so that meant we were also on the hook for delivering everything the original teams had planned.

It was a dumpster fire. From what I gather, things have mostly gotten worse since. They could never pay me enough to go back (well, okay, they could pay me millions per month, and I'd consider going back and then quitting after like a month or two).

> signing code

...is baked into git, and is something I've used at my last two employers. You could daisy-chain a bunch of tools together for that, but why? And getting back to the original point: code signing isn't usually possible on "low-code" tools.

> there's more care over the code.

I think what you mean is "the minimum threshold of carefulness required of everyone at all times is higher." I don't think it's true to say "when you toss out industry-standard safeguards, everyone does better at never making any mistakes." I do, however, think it's true to say "when you toss out industry-standard safeguards, the likelihood of making a mistake is higher because of unfamiliar, imprecise, and/or buggy tools, and the cost of each mistake is higher."

This gets back to my original question about low-code tools: when (not if) a human makes a mistake, do low-code tools guarantee fast and simple rollback? Often the answer is "no."

> domain knowledge of the whole system is more valuable than "git skills"

This is just a strawman. No job where I've ever worked has valued "git skills" over systems knowledge — and even if you dug up a job where that was the case, that's a shortcoming of the company culture, not of the tool. In my experience, it's more common that companies value low-code-tool skills over domain knowledge, usually because they've gotten locked into their proprietary low-code tool already and are unable to select from the total pool of developers unless they're able to do a wholesale rewrite, and must instead prioritize "knows Pentagon" or "knows Salesforce" etc as their top hiring priority, instead of "understands software architecture".

Can I check a "low-code" implementation into version control, using standard free tooling? Can I, when something inevitably goes wrong, do a `git log` equivalent to spot the source of the problem? Can I then roll back to a specific commit, using off-the-shelf free tooling?

I find that generally the answer is most often "no," which is kinda a nail in the coffin for serious usage of "low-code."

Yeah, just like how physical mail works. Nobody ever has to deal with spam in their physical mailbox. (/s)

That just becomes marketing budget for spammers (which is to say, those for whom email is a component of a revenue stream), and a layer of cost friction for everyone else — meaning that you only really reduce the percentage of email that's actually sincere, non-"hustle"-driven communication.

Wow. Between the problematic grind culture that conflates "you have only live to serve the shareholders and take no personal time" with "you're valuable", and his constant "you fail at reading comprehension" and circling his own tweets in screenshots a million times and "math is not your strong suit huh, I look forward to giving you your next tutorial" responses, I feel really bad for anyone who is stuck working with this Kirkland Signature Elon Musk.

These are great receipts for Glassdoor or something to help warn folks away from the toxic "company owns your life" culture he's pushing at his rando startup.

>Based on some inspiration from OCaml...

My dream of getting to write more-OCaml-esque code at my day job continues to flourish. I'm glad bright minds in language design for the "majority" languages are looking to the wisdom found in more-niche languages.

A growing religious demographic group in the US "self-identified evangelicals who attend religious services fewer than once a month" [1].

"Christian" has, in the US, become increasingly synonymous with "Republican" rather than "follower of Jesus Christ". It's slowly becoming just another label that does the job "Traditional Values" used to do before that one lost its stickiness: it's increasingly just a dogwhistle.

As a Christian in a red state, it makes me pretty depressed. I find it hopeful to see trends outside the US political bubble. I hope in the long term it won't be just a political descriptor or a convenient in-group label to wear, but may again be used primarily to describe a set of binding values.

[1] https://www.christianitytoday.com/ct/2022/august-web-only/ch...