Tallain

Very cool, I like this a lot. Will be giving it a try!

It's a real shame they got rid of target display mode. But then people would hold onto iMacs even longer.

Today, you can use software like Luna or Duet, or native screen sharing to control an iMac from another Mac (or vice versa). I have a 2019 iMac, bought for pennies and upgraded after to max out; way better value than buying the display on its own or a comparable monitor alone. The screen quality is just great.

I use it both as a daily driver and as a "thin client" for all my other machines with the software above.

Hot dog I love to be wrong. They've got plenty at $25/TB there, too.

A terabyte is no longer $20, unfortunately.

Sure! Send me an email, my name on gmail.

I also built something similar to solve this, but more aimed at inspecting the impact of changes to a concept - think a vertical slice or domain, or even a feature. Often the same thing might be referred to by similar, but slightly different names, or separate pieces of the codebase might not immediately look related when they do share dependencies. So symbols, phrases, and words are attached to concepts for either LLM-based or user-based querying via MCP.

An indexer crawls the codebase and maps slices of code to concepts, then groups related concepts. You can inspect a concept to see things related to it, or ask about the impact of a change and see second-order changes required - things not so easy to see that are related by basic symbol linking (although it does use symbol linking - it heavily relies on Roslyn, since it's all C# focused).

It also returns confidence scores with everything, which adjust based on a dozen or so factors like whether the user defined the concept or the concept was auto-generated during the code crawl. Low confidence score === fall back to grep.

It was a super fun project and ended up being very useful, as much for people as the LLM. But, I'm not convinced it is materially better than grep in some ways and just haven't had the time to really focus on improving it.

Sounds like you fundamentally misunderstand the thing people have against using AI for these pursuits. If your imagination or capability needed LLMs in order to unlock their full potential (as in, if you waited until AI removed the barriers between a beginner and their future craft), maybe your potential wasn't that great to begin with. And all you're doing is producing things closer to the median, instead of somewhere toward one end of a bell curve.

I don't know if this is aimed at me or not. I don't use this workflow; in fact I'm pretty bog-standard in many of the ways I use my computers. In any case, I don't see how expecting to be able to bring up a context menu is in any way esoteric. We're in a thread about navigating GUIs using a keyboard. On many keyboards there's literally a key dedicated to opening a context menu, and on most OSs there's a pretty standard shortcut to do it as well, which is what GP was talking about and what sibling comments discuss being added more recently in MacOS. So, again, not very esoteric.

I also don't see how trying to emphasize empathy toward users translates to hubris. But sounds like you've got a bone to pick, so keep picking I guess.

In this case it's not a context menu, it's just a menu. User experience is degraded, see GP's case. There is an expectation and a common paradigm which is intentionally ignored because the OS developers thought they knew better than the users.

This reminds me of frequent conversations with other developers when presented with a bug report. "That's not a bug, it's working as intended." The intention is wrong, then -- the bug is in the design, not the code, but it's still a bug.

A few years back I threw Mint plus this theme on my old Thinkpad T430s. My intent was to use it for one thing and one thing only: writing. The theme helped me trick myself into thinking the machine was unusable for anything else.

This just in: multiple factors can contribute to the same result. Shocking!

I switched to Mint and never looked back. It's one of the easiest transitions IMO, and if you really miss Windows, you can bring the aesthetic with you: https://cinnamon-spices.linuxmint.com/themes/view/Chicago95

It sounds like you haven't touched (or heard of?) any of the recent DOOM games.

I've driven from Mukdahan to Kanchanaburi to Trang provinces so my experience is not centered around the major cities at all. I don't know what poor luck or exotic adventures you may have had, but I never once struggled to find a bathroom.

For the most part, yes, but I've gone much longer stretches without seeing a gas station in the US. To be fair, there's also no point in building gas stations at regular intervals in the desert or the many other long stretches of nothing across much of the country.

In every part of Thailand I've been to outside BKK, there's a gas station almost every few kilometers on every major road. Almost every gas station has a public restroom that's open 24/7, unattended. The ones that don't have a public restroom are typically right next to a string of restaurants that have a restroom you can use during the day for free if you ask.

I mean, Raymond Chen has been writing The Old New Thing consistently for over 20 years. Nearly every single entry is interesting, informative, and illuminating, aimed at every facet of software engineering, old and new, over the decades. He may be part of the final bastion of quality and care for detail at MS, dwindling and faint as it is.

Windows doesn't need or deserve defending. It's atrocious. But this is a silly comment.

It's not that hard if you put in the effort and practice.

But if you don't want to and still want to use an LLM, there are low-bar choices you can make (using a technical writing skill, using ASD-STE100 Simplified Technical English, choosing your audience, proofreading at the end with human eyes to make sure it makes sense and doesn't repeat itself uselessly).

I think it shows either a) low respect or consideration for your audience or yourself, or b) laziness.

Trust yourself to write even if it's bad. At least it's human.

Yeah, a lot of non-visual components still require (or want) you to drag-and-drop them in the builder and edit many or most properties there. It's a weird thing to adjust to, and it often leads to a very cluttered view if you have a lot of them. Conversely, a cluttered view with a ton of non-visual components can be a very easy-to-spot signal that you might be trying to do too much in one screen.

The RAD environment makes it insanely quick and easy to throw together a reasonably functional desktop app. Think WinForms on steroids. For all its age and the many cracks and seams, it's still very fast, easy for beginners and pros alike, and the final executable is a single tiny file (usually)

In my experience, the parent's view and your view are an example of the divide between the Silicon Valley / startup mindset -- it doesn't need to last, it just needs to get us a paycheck so we can go on to the next paycheck -- and actual software engineering where people build resilient systems meant for humans to use for a long time.

There's a conflation too that to approach things with this level of thought and care requires waterfall design (it doesn't), so people shrug it off or resist because if you want to think carefully and design thoughtfully you can't also Move Fast and Break Things.

Ironically, we all complain about enshittification.

Radio Paradise (https://radioparadise.com) has been my go-to for years. Discovered a lot of great new music through here.

You don't need it. The mouse functions perfectly fine without it. And you can even switch DPI when the mouse has a button to do that.

The software allows for fine-tuned settings, button remapping, etc. It is awful software, to be sure, but it's not necessary to use the mouse.

Thanks! I hate it!

In awe at whatever inspired this though

The death of what.cd was also the end of an era for me. I know "replacements" have popped up but the real value of what wasn't in the piracy, it was in the community. It was the best on the internet and nothing has taken its place since.

It's published but I would doxx myself by posting the link here -- I can email you if you'd like.

Also, full disclosure, because this was written entirely for myself, the code behind it is 100% LLM generated. I set the specs and direction but didn't touch code at all, just let agents churn while I did my day job and tested the results later.

For the recommendations:

- Seed selection is performed by building a mix of seed artists from recent listening, lifetime favorites, old obsessions, and underexplored artists.

- Seed weight combines `log(1 + play count)`, track diversity, number of listening months, and a recency decay

- Candidates are generated at the union of artists reached by "similar artist" edges through Last.fm and MusicBrainz-enriched local data (APIs are used to enrich DB initially, then after that it's all offline)

- Discovery excludes known artists, hidden and recently-reviewed artists

- Discovery requires edges with at least two distinct seeds, or one strong seed edge

- Discovery is scored by similarity (Last.fm + tag), feedback, and rediscovery thresholds. Then score is subtracted for excessive knownness within a genre, obviousness, recommendation fatigue, and shallow prior listening. The thresholds are by default but configurable:

    ```
    0.35 × calibrated Last.fm similarity
    + 0.25 × calibrated tag similarity
    + 0.10 × rediscovery
    + 0.10 × feedback
    ```

- Serendipity is additional score provided when a candidate connects several seeds that are themselves weakly connected, or are in separate connected components. This is a weak implementation of the Auralist serendipity algorithm, and will be improved on.

- Finally, diversity reranking; a greey MMR-style reranker.

    ```
    rerank score = λ × candidate score
                 − (1 − λ) × similarity to already selected results
    ```

Two things right now:

1. A music recommendation tool based on Last.fm scrobble history.

It's graph-based, no ML or "fancy" techniques, but I've had good results with it so far. It builds recommendations based on a listening window or just recent history. It combines several different recommendation algorithms (including an Auralist-inspired "serendipity" score for novel recommendations, meant to simulate the serendipity of being recommended something novel by a friend), scores and ranks candidates, and takes in feedback that inform subsequent recommendations.

Fun project. Found some good new music with it already. :)

2. A code exploration / indexing tool with CLI and MCP interfaces for exploring concepts and impacts of changes in a codebase.

Essentially, an overwrought "find all uses" that doesn't depend on exact symbol or string matching.

I have a codebase of non-trivial size, but thankfully it's fairly well-structured. This tool indexes the code and bundles modules into "concepts" -- these can be auto-discovered or preconfigured. Dependencies, inheritance trees, symbols and symbol usage are all also indexed.

Then you can ask, "what's the impact of extending the domain model of XYZ" or "I want to remove this property" and it shows where to start, where to look next, and fuzzy edges or dependencies that might need deeper exploration. It surfaces non-obvious connections, too, or things a junior dev (or LLM) might miss, like when a model is mapped to an API DTO, or intermediary states, etc.

It's been useful for a new dev exploring the codebase, because you can ask in terms of business concepts instead of needing to know the exact symbol name in the code. And it's been much more token efficient than grep for exploration subagents. But it's limited to dotnet only.

Another recommendation is LinearMouse. It lets you fix pretty much every problem that MacOS inflicts on mouse users: pointer acceleration, scroll behavior, click/button behavior. This and Karabiner make the OS much more usable for me.

Very interested to know how you built this; I'd like to see similar data for my own dump even though I quit Spotify some time ago.

There's also Reverse Shot: https://reverseshot.org/

The Dissolve alumni are all (mostly) writing at various publications: https://thedissolve.com/

While David Bordwell sadly passed, his blog is still a great resource (books, too!) and actively updated: https://www.davidbordwell.net/blog/