diegof79

Thanks for the description. I can imagine the benefits, not only in that situation but also in situations with hostages or bombs.

However, my point is that the technology also enables bad use cases, and you don’t need much analysis to see that.

The difference between a human cop and a robot is scale and a lack of empathy (although it is hard to attribute any empathy to some cops). You can send a swarm of robots to scan a neighborhood, with little human intervention. The purpose of that scan could be to catch terrorists, immigrants, or political dissidents.

The people who designed these things are pretty aware of that, but they do it anyway and now act as if surprised. It's like Lockheed Martin employees complaining about missiles; don’t work for a missile manufacturer in the first place.

The Boston Dynamics website describes the product as being used by the government to “remotely assess and de-escalate tense or hazardous situations.”

So I’d love to hear from one of those employees about how they imagined those use cases.

Either they have huge cognitive dissonance, or I’m too cynical, because I cannot imagine a situation where a robot designed to remotely spy (sorry, assess) or apply force, lethal or not (aka de-escalate tense situations), wouldn't end up being used for the wrong things.

The title got me interested. However, I couldn’t bear your site, sorry.

My feedback: cut the slop. I see a wall of text with explanations that are full of marketing phrases, filler sentences, and there isn’t a clear, curated explanation.

Again, sorry for my blunt feedback.

The prototype ("Mocha") was created in a week, but the language went through multiple iterations. (See https://www.wirfs-brock.com/allen/jshopl.pdf)

Honestly, I can point you to languages with worse design than JS.

There was an idea (perhaps from BASIC) that "scripting" means permissive. Instead of failing fast, it was designed to fall back to something that works (e.g., '1'+1=2). That's a terrible design decision, and JS tried to reverse it in every future iteration.

The other two big issues for me were: trying to imitate Java (with the new keyword, instanceof, and null). The prototype mechanism that JS took from Self is simpler and easier to understand if you leave out those constructs.

The other issue was the lack of modules. That was part of the idea that JS was for short, interactive scripts on a page; the initial version didn't plan for how we use it today.

Other than that, I prefer JS over Perl, C, C++, PHP, shell scripting, or TCL.

Edit: Actually, '1'+1 is '11' in JS (facepalm), but '1'*2 converts to a number. That's why it was a terrible idea. But, to be fair, many "scripting" languages did that kind of type coercion. I guess that language designer hated cryptic compile errors.

I know ;)

Some OOP professors who taught at LIFIA (like Maximo Prieto, who sadly passed away at the beginning of 2026) and UBA (Hernán Wilkinson) had a lot of influence at the University of Buenos Aires, La Plata, and Quilmes.

Happy to see something related to ESUG so up in HN.

Smalltalk still has a small group of passionate people who love the language, the environment, and its concepts.

For some reason, Buenos Aires has a “large” group of Smalltalkers (large relative to the total, which is small in absolute terms). This group usually organizes the ESUG event in Argentina with very few sponsors.

This comment should be at the top. The title implies a non-issue: macOS silently disappears because the poster didn’t try to change the page's badly designed filter. The latest version of macOS probably will appear in months.

Sadly, this isn't a Florida problem.

I don’t live in the US. But this kind of broad law is hard to implement without surveilling all users, and it has multiple side effects.

What happens if I use Claude or ChatGPT to research sensitive social topics? Would that be considered a social network interaction and used against me when I apply for a visa?

Many governments (especially in Latin America) copy what the US does, meaning that similar laws will be pushed sooner or later.

I agree with you that we use analogies to name new things, and that’s the way language works.

However, you can see an airplane flying. Still, you cannot see software processes at work, and that causes misunderstandings and misinformation, which is at the core of the changes that we are experiencing with AI.

This is a fragment of another article posted here on HN about an ongoing dispute between OpenAI and the New York Times:

“The defendants say this is a simple application of fair use: Their argument is that if you read a story and simply remember what was in it to expand your base of knowledge, that cannot be considered a copyright infringement”

However, if you replace “read” with “web scraping” and “expand your base of knowledge” with “storing the information,” the perspective changes too.

I couldn't reproduce the Color Picker bug mentioned at the end.

Just one small thing to add about the Color Picker: I think it's a good example of how native UI apps have changed over the last decade.

The macOS Color Picker is nice. The idea is to have a single color picker for the whole system. It's extensible, so apps can add their own custom pickers (for example, an OKLCH picker), and you can reuse your palettes across applications.

Sounds great! But most of the applications where you might care about those features (customization, sharing your color schemes, etc.) don't work with the native Color Picker: Figma, Adobe apps, all Electron-based apps, and so on. So the Color Picker's features are useless. That component of the system is exactly the same as it was when I got my first Mac in 2007.

There are multiple nice native features that apps don't use; over time, they become forgotten and barely maintained.

I don't know what the solution is, but at some point, I think Apple should take frameworks like Tauri or Electron into account and build integrations for developers who use them. I know the integrations exists (they are the native APIs), and it's the developers' responsibility to use them, but that's not happening, and it ends up affecting the UX.

This seems like a hot topic this week, (I just commented in a similar thread).

When I read the article, I had an NFT déjà vu: when NFTs were a hot topic, the “lie” was obvious to me, but the information online made me think I was missing something.

AFAIK, the Hugging Face incident could have been avoided with a firewall or something similar. Just isolate the internet access for real. What am I missing? Why did Nvidia suddenly post this? Is it just PR BS, or was there something else going on?

I didn't downvote you, but your last paragraph is unnecessarily aggressive.

I've worked with agents, and I agree with you that often there isn't another way to express the interactions.

However, I also think the terms ML uses in general are a mimicry that misleads people who aren't informed. Ask anyone outside SWE what they think “training” means, and they'll usually picture something being taught.

I don’t think anybody can change that now, but it’s useful to point it out.

Perhaps my use of the word “liability” adds noise to what I’m trying to express.

My argument is very similar to the article in the parent post:

The messages OpenAI published around the recent incidents emphasized their model capabilities but shifted away from their negligence in how they set up and monitor their evaluations.

Forget for a second about AI.

The agent harness is a process, like any other process in an OS.

You are a researcher running thousands of unattended automations that can hack a website without supervision. The first thing anybody will do is put security at various levels and isolate the network as much as possible. If something escapes your allow list, it should stop the processes as soon as possible.

You cannot foresee a bug in a server (like the Artifactory server in the Hugging Face incident). But you can isolate that server at the network level in the first place. So even if you give that server read-only access, no unexpected packets go out. It's not rocket science; it's something a billion-dollar company experimenting with what they promote as the biggest possible threat to humanity (if they do not handle it) could easily do.

They minimize their liability by changing the message to “oh look how powerful our models are, now we are going to have a public awareness report of the model deviations”. The message should be, “Sorry, we ran experiments without proper sandboxing; it’s our fault, and we changed our testing practices since then.” The former message puts all the blame on the smart, uncontrollable force of AI; the latter is what really happened: an irresponsible test over the Internet.

100% That’s what bothers me about the descriptions of the OpenAI incidents.

OpenAI's reports use language that minimizes their liability.

The first question should be what the organization was doing around those tests, and why they were so naive as to run them without fully isolating the network.

However, all the attention goes to the human-like conclusions in agent thinking traces, which creates a misperception of sentient AI for people who don’t know how the magic black box works.

Lately, I've been using Matt Pocock's “/grill-me” skill more and more, rather than plan mode or a complex, spec-driven set of skills. I made a personal fork of the skill to use Claude’s ask tool, which has a nicer UX.

I used plan mode for two reasons: to review the choices before execution, and to execute with another model (i.e., using the barely documented opusplan feature).

The grill-me skill is much better for reviewing and clarifying choices (and modifying it to use the ask tool makes you go faster). Instead of opusplan, you can explicitly tell Claude to start a subagent with another model to divide the tasks.

Yes, but plan mode wasn’t that.

You can use Docker’s sbx or similar VM/containers for that.

The name inject and the argument order comes from Smalltalk (Ruby is heavily inspired by it). In Smalltalk arguments are part of the message name:

collection inject: aValue into: aBlock

It’s interesting how things have changed in 25 years. Around 2001, Microsoft was crusading against open source and facing an antitrust lawsuit with Netscape.

Now 25 years later, MS runs its cloud businesses with Linux, and their development in Rust.

This (points up)!

I've read many comments about how good CLIs are, and they are right. But for developers.

For non-tech people, installing the CLI is a hurdle: it involves having the right dependencies installed, controlling how you handle secrets (like API keys), and handling updates (ie. npx with a private registry). But for internal tools, once you create an MCP with OAuth, the installation (in Claude) is straightforward.

I'm surprised how non-tech people in the company use it for ad-hoc integrations, like pulling emails, getting deals from HubSpot, enriching that with the internal MCP, then drafting responses. Of course, this has scaling issues, and at some point it is better to move these everyday automations to a proper system, but I saw how MCP enables what products like Zapier, n8n, or IFTTT try to do: user-friendly ad-hoc integrations.

My only complaint: implementing MCP auth in an MCP server still isn't very streamlined. Some libraries, like Cloudflare MCP, simplify all of that, but AFAIK it's tied to using their services.

What we lost is simplicity across the stack.

I learned to program with BASIC. It was awful. I didn’t know how awful it was until many years later. So I don’t miss the language. But something I miss is how easy it was to learn what your machine was doing.

The DOS boot and config involved only two files: CONFIG.SYS and AUTOEXEC.BAT, that was it. Most programs were self-contained, so you could copy the directory to a floppy disk and run them on another machine. If you broke something, copy the files again and restart; that was it… I “broke” config and programs many times, and it was a good way to learn.

I imagine that it should be clear to everyone here now, until I read threads like this comparing child development to the advances in LLM building.

It’s like saying that a new M-Apple chip developed like a child. There is a clear tendency to give human like attributes to LLMs, probably caused by the terms used in ML: training, learning, etc.

This part of your comment, “just show me stuff that reflects what I value,” makes me think about the political manipulation used in social networks. It’s scary to learn about priming and how it affects our judgment; now imagine a politically (or religiously) charged ad in the middle of your learning session with ChatGPT that leads you to certain conclusions. Doesn’t feel like a good thing.

They don’t develop. We should stop anthropomorphizing LLMs.

AI labs are improving the ML techniques used to build better models; it’s a big difference.

A healthy life is more invigorating.

You can sustain a month of 996 if your project is under fire (it may happen in a startup). But more than that is unsustainable: you have less social life and get more tired. Which means that you get more irritable, make more mistakes, eat more calories, and have more chances of depression or burnout. There is nothing heroic or productive about 996

I had a similar situation. Google really needs to improve its model usage and payment UX.

My solution was OpenRouter. Their dev and testing chat can generate images with Google models, and you can also run the same prompt side by side with other models. It’s very handy for casual image generation.

To complement the excellent answers that I read in this thread: an eval is a test.

What makes it particular for the case of AI is:

- there are many situations where you can’t test using pattern matching

- you don’t only like to test correct answers but voice and tone too (imagine a bank support LLM-based chatbot that answers using slang)

- evals can be used to compare the performance of different implementations; given the costs of LLMs, it’s very important

- running evals is more expensive than running standard tests, because you rely on the LLM calls under test, and many times they use LLMs as a judge. It means that running them in every commit of your CI/CD is very expensive

- Knowing all the possible inputs for the LLM is impossible, so evals can also be run on runtime samples to detect anomalies

The UNIX scene was funny and probably included because of some marketing arrangement with SGI. I haven’t seen mentions of UNIX in other movies.

For context: in Jurassic Park, there is a scene where a 12-year-old girl sits in front of an SGI workstation to deactivate some doors (or similar) and says, “I know this! This is UNIX; it’s easy”, and uses a 3D UI to navigate files. At that time, an SGI workstation was very expensive and not something you could learn at home, and UNIX-like OSs weren't as common. The scene was like someone saying “I know this it’s a nuclear reactor, it’s easy”

It's funny that you mention CORBA, because my first contact with Java was through a C++ CORBA service that interfaced with Java (this was around 1999). After that, I worked for many years using Java.

While many things changed, the world of remote services didn’t change radically: different technologies, same concepts.