A huge pain of desktop development is managing dependencies particularly if you are coming from C++/Native code. Imagine you wanted to make a simple app in the 2010s that accesses the webcam for instance: If you use chrome you got the full html5 runtime, whereas with other tools you'd need bespoke libraries which your end user may not have.
The only way to ship the same code between linux, macOS, and Windows would have been to either use something like Qt or the JVM back in the 2010s. The JVM desktop stuff was super ugly and Java itself had become notorious (also if you wanted anything remotely interesting like webcam/microphone or multimedia access you'd still have to ship dynamic libraries). Qt required special packaging skills to ship to the end user especially if third party libraries were involved. Electron killed that by bundling chrome (and chrome has a huge api surface).
Today, I would argue the package management situation for a language like rust is a lot different. You dont have to cobble different DLLs together, you can just statically compile dependencies and cargo/rust do a pretty good job of making sure it's bundled with your app. Other languages also now have similarly useful tools.
I'm currently working on my own Zig project (an interpreter) and right now I'm working on designing a C interface for it. Seeing things mentioned like having objects as opaque handles, or enum-keyed getters and setters, made me think about how clunky my current API is, since I leak too many details to callers.
What really caught my attention was this: "So from the start, I took inspiration from C libraries I enjoyed working with and designed the API to have a strong, stable ABI that allows for future additions." What are good examples of this? I feel like I just don't have enough experience with well-designed C libraries to know what to look for.
i know everyone plays with their own rules, but from my perspective, a square root spends a 2 - it's not an operator like + or ! . there's an implicit "2" since you could also take the cube root or fourth root
I love looking back 10+ years for the cheapest Linux thing you could buy. People were buying devices that were for kids or a router or something and repurposing it because it was open enough to get a shell on / flash Linux to it and start doing projects with.
In the 2020s or somewhere before that we got a bunch of dedicated cheap MCUs that were good enough and I think stole the thunder from full Linux but there are still projects to run it on things like the ESP32 family.
Either way, hardware hacking is still my favorite hobby to watch.
I would buy an electric car tomorrow, I have access to cheap charging, and I don't even do long commutes. But there is zero chance I want a spyware car that's like another cell phone.
The U.S. is being protectionist because of Chinese cars that can spy on U.S. soil-- just do the right thing and stop all the car spying nonsense. Require manufacturers to open the code and let us even develop alternatives.
The floor for a functional local AI system keeps getting lower, dispite ram and GPU prices continuing to go up. An E5 workstation with lots of threads, $300 of RAM and at least $100 of GPU gets you something that can do >100tok/s+ prompt processing, and ~20tok/s output with Qwen3.8-flash-next:IQ3_S. Toss a $500 GPU in there, and it goes from barely usable to pleasingly performant. For less than $800 you have something that holds its own with where the SOTA was less than a year ago.
I don't see how anyone justifies a claude subscription. Do you want to rent the tools you use to making a living from the people who are trying to automate away your job?
The whole "let's make an Android device for seniors/the blind/whoever and pin it on an ancient Android version/spec it really low but charge a premium" thing is unfortunately not new.
If you look at the Blindshell 2 and 3 you see plenty of this happening as well, not to mention way more expensive hardware like the BrailleSense Polaris which last time I checked ran on Android 5, scary "Mind updating right now please?" Google Play warnings and everything.
If it helps any, Talkback does have a set of keyboard commands it responds to, perhaps making your keypad buttons fire those means the implementation might be less brittle but given what you've already had to deal with maybe just not touching it ever again might be thebest thing at this point :)
You lose some character moments, but you get to everything the parent post described far quicker. And it’s well, well worth it, especially for those of us working with AI.
PoI asks these incredible questions: how do you design an AGI system that can optimize for saving lives, without it taking a strictly utilitarian view that leads inexorably to it trying to take over the world?
And how do you, as a human trying to get the best of both worlds, keep yourself sane when the tradeoffs are visceral and painful and demand a sacrifice?
You get to know a group of lovable, flawed, but highly competent weirdos who are trying to muddle through this. (With Amy Acker’s incredible performance a particular highlight!)
(It’s also the source of the four-people-pointing-guns-at-each-other-in-church meme, which is delightfully lampshaded in universe.)
After they’ve been promoted to their level of incompetence, they lean in very hard on relationships to survive.
Organizations where they get away with this are miserable to work for, and their influence ensures nothing merit-related ever happens again. Literally the source of the famous expression “A-people hire A-people, B-people hire C-people”.
This is why the German's used heavy water instead of graphite as a neutron moderator, which made it much harder to build a reactor. Their early reactors consisted of concentric spheres of heavy water and uranium powder. This was an unfortunate combination, as uranium powder ignites on contact with water. Leaks caused explosions on two separate occasions [0].
In contrast, the first allied nuclear reactor was a literal pile of uranium and graphite on a squash court.
[0] The Bastard Brigade (great book on all of this)
> in the niche case where you want the model to have free reign, in a fully unopinionated environment, where it's allowed to make any changes and make any external calls.
That is not the niche case, that's the dominant use of models.
It would be helpful to distinguish between your own opinion on how models ought to be used, compared to how others actually use models.
I know this isn't the answer you want, but I sell people on Signal based on the user features. I’ve had great success in getting my friends and family to adopt it.
Signal is incredible user friendly, privacy respecting, the gold standard for encryption, cross platform, etc. Yes, it’s centralized, yes it’s imperfect in many ways, but it’s easy and it’s pretty damn good.
If you want to help the people around you to become more involved in understanding and owning their tech, it has to be an easy and good experience. It has to be tangibly better, not just abstractly better with tangible downsides.
I use XMPP, but would never try to convince my friends and family to use it; it’s too complicated, the user facing apps all suck (Snikket and Cheogram are the best of the bad lot), and the incentives to use it aren't there. As you said, it’s just not attractive to a regular user, since it’s all around a worse experience than what they currently use. The one exception is that I do occasionally recommend XMPP for SIP access via jmp.chat to some of my more technical friends who have a tolerance for clunky user experiences in favor of privacy and affordability. I am holding onto an unreasonable hope that Signal or Whatsapp or others will consider XMPP+OMEO in the future to popularize the standard, but that is extremely unlikely.
Matrix also is an unfortunately terrible alternative to discord (even Element is a rather lacking user experience), so while I have pushed to move groups there before, I no longer recommend Matrix. I suggest signal or nextcloud as alternatives when possible; the remaining large groups who need the closed server forum style system are usually unlikely to move to Matrix anyway.
I was bothered not so much by the slopful article as by the AI-written text in the dashboard that iKnow produces. I ran the program on my Mac and it did display charts and graphs with names of people and organizations I’ve interacted with over the years, but I couldn’t figure out what it all was supposed to mean.
One example: "323 people, 122 events and other records, 200 employers and 1 stored group — as the store on this Mac links them. Read live just now. Colour is what each node is to you: the stored group in red, family and closeness by iKnow’s rules on the kinship scorecard. Size is how many rows in the store name it."
Claude etc. can be prompted to produce clearer explanations than that.
This is deeply troubling,
this data is unnecessary collected and impossible to opt out from apparently and may be read at any point in the future by an attacker or by apple itself without notice
One thing I sort of wished was touched on a little more: the concept of country is surprisingly modern. Modern international relations theory tends to trace the concept back to the Peace of Westphalia in 1648, but honestly, even that is really too early.
The map shown of 14th century Europe is doing better than most in that recognizes that several borders (but still too few) are fuzzy rather than lines on a map. The other problem you run into is that, in most non-state societies (in the Weberian sense of "monopoly on the legitimate use of force"), political linkages tend to be fragile and based more on personal ties so that a Big Man's successor may well repudiate the alliances and homages the Big Man makes. Which makes it hard to draw maps, because is Burgundy a part of France? The Duke of Burgundy is as often as not fighting the French king.
This is what makes adjudicating the "oldest continuous republic" hard, because at what point do we say that the homages San Marino is paying stops counting as being part of that country?
IMO one of the remaining gaps of agentic coding is that it's hard for even multimodal LLMs to check interactive motion effects for correctness and "feel." Like, sure, they can take screenshots of a few snapshotted states, but in terms of how things react as underlying nodes move and (potentially) reflow. How do you QA the feel of moving your wrist rapidly in the context of nested zones?
The answer is that you avoid the need to: you have a (nearly-provably) correct foundation that ensures that behavior is predictable regardless of state, and just render accordingly.
The paper's approach is incredible here: simultaneous optimistic rendering of multiple possible states, and a composable algebra (a small combinator language) over how drop zones and distance are derived - allowing for an extremely high-level interface in practice. Everything feels snappy and right, and the code you write is about as minimal as you can get - though the paper notes that state management is somewhat complex. But this seems solvable!
Once this is ported to HTML, it'll become an incredible part of the modern dev toolkit. I'm very excited for what this means.
Google appears to be overlooking their explicit ban on this.
If your app handles personal and sensitive user data, then you must ... Not sell personal and sensitive user data.
The rule also applies to third-party code.
If you include third party code (for example, an SDK) in your app, you must ensure that the third party code used in your app, and that third party's practices with respect to user data from your app, are compliant with Google Play Developer Program policies... For example, you must ensure that your SDK providers do not sell personal and sensitive user data from your app.
Pretending Tesla isn't a car company and SpaceX isn't a satellite services company (Internet, maybe mobile) is wild stuff. The only real profits are from those traditional industries. All the sci-fi hype is for investors and fanatics.
Contract law fundamentally assumes two parties of equivalent bargaining strength. The system was intended for large, powerful entities dealing with one another hundreds of years ago and wasn't designed for how it's used often used today where one party has zero bargaining strength.
The only way to ship the same code between linux, macOS, and Windows would have been to either use something like Qt or the JVM back in the 2010s. The JVM desktop stuff was super ugly and Java itself had become notorious (also if you wanted anything remotely interesting like webcam/microphone or multimedia access you'd still have to ship dynamic libraries). Qt required special packaging skills to ship to the end user especially if third party libraries were involved. Electron killed that by bundling chrome (and chrome has a huge api surface).
Today, I would argue the package management situation for a language like rust is a lot different. You dont have to cobble different DLLs together, you can just statically compile dependencies and cargo/rust do a pretty good job of making sure it's bundled with your app. Other languages also now have similarly useful tools.