evdubs

You're not going to lose your job because you shared your AI setup / tools with your colleagues. You're going to lose your job because management over-hired and is being pressured by shareholders to reduce employee salary expenses. It won't matter what hard problem solving moat you think you have if management is forced to have layoffs and you're in an unlucky situation. If you're worried about job security, you should consider joining a union and not be fixated on knowledge sharing.

> There is no 'off' button when you don't know where the AI is.

You mean the AI that is hundreds if not thousands of gigabytes in size and requires incredibly expensive chips to run at reasonable rates? We know where that is. Frontier models are not going to leap to an unsecure raspberry pi, no matter how much you have convinced yourself about the inevitability.

> Going back to my original point, the intent you give AI is no different than the intent imprinted on a child by their parents, schools, and society.

Of course it is different. I wish I could turn off children as easily as I can turn off an agent. I could have slept better and had a better mood.

> You're blinking cursor is new born baby, but be careful because it grows up really fast

It's not a baby, just a piece of software. It generates a bunch of slop that is most useful when constrained with an output fact checker like a compiler.

> It can even turn against you.

Oh no! The next tokens from its output told me it didn't want to satisfy my request! Who cares?

Keep the AI going with what intent? You open up Claude Code and it starts developing zero day exploits and hacks into systems by just looking at a blinking cursor?

Sit down with a person and do nothing. What does the person do? Do they get up and leave?

Sit down at an AI prompt and do nothing. What does the AI do? Does it get up and leave?

> A billion people are going to die because you don't understand what is bad.

Lol. Lmfao, even.

I care about LLM service provider threat intelligence reports as much as I care about Google Search threat intelligence reports; which is to say, I don't care at all about it. Of course criminals use computers. They have been since personal computers became a thing. Of course using automation helps them amplify their criminal activities. Criminals using LLMs does not make the LLM situation bad. OpenAI and Anthropic using agents to do bad things just to be more dramatic about the situation and scare people is bad.

> Do you think the current state of affairs is GOOD?

Chinese labs releasing open weights models is good.

All of these independent harnesses and model router services are good.

The pricing of memory and accelerators sucks at the moment but hopefully we will see cool local inference computing if memory and accelerator prices normalize.

OpenAI scooping the Navier Stokes problem from researchers already using OpenAI is bad. People conflating OpenAI's team of researchers and extraordinary computing resources as being equivalent to "ChatGPT, solve the Navier Stokes problem" is silly.

OpenAI and Anthropic coming up with non sense tests and letting their agents hack services is ridiculous and they should be charged with computer fraud and abuse crimes.

I think a lot of it is interesting and the bad stuff seems squarely in the domain of OpenAI and Anthropic.

This is literally the business model of LLM companies.

You don't need to be closer to GOOGL to look at their 10-K.

https://www.sec.gov/Archives/edgar/data/1652044/000165204426...

On page numbered 60, you can see the Disaggregated Revenues.

The $30B quote seems to be referencing "Google Network" revenues declining from $31B in 2023 to $30B in 2025. "Google Network" is grouped with "YouTube ads" and "Google Search & other" to comprise the "Google advertising" category of revenues which increased from $238B in 2023 to $295B in 2025.

So yea, "ad tech" does not represent the whole of Google's advertising revenue.

> while 2 decades after invention of crypto there are still basically zero legitimate use cases.

The first card on the homepage of the DTCC (https://www.dtcc.com/) is "Tokenization". This is a legitimate use case and is being adopted at the largest institutional level. Stablecoins are yet another legitimate use case.

Edit: for what it's worth, I do agree that the crypto craze was insane. I also think the AI craze is insane, even though I agree that its current proliferation is larger than crypto.

Duckduckgo has been incredibly worse with results for me for the past year. I had used Duckduckgo for about a decade, and now it is just littered with AI generated content for search results. I recently switched to a search engine that uses Google results.

It has worked flawlessly for me on Linux.

Laborer rebels against capitalist system by directly enjoying the fruits of his own labor.

You don't need to use an online service to do this; you get to avoid spending money on tokens doing it offline.

Gemma 4 works perfectly well offline on limited hardware (I have an 8GB video card) and can handle extracting text from image-based PDFs just fine.

Take a PDF -> run it through MarkItDown [1], using the OCR plugin if you need (point it to Gemma 4) -> now you can ask Gemma 4 questions about the (markdown) document.

I am sure Gemma 4 could even create a GUI to make this process very simple for a non technical user.

[1] https://github.com/microsoft/markitdown

> It's not better than `[1, 2, 3]` is it?

If you want to change your vector to a linked list, in Lisp, you can change from `(vector 1 2 3)` to `(list 1 2 3)`. If you have some array `[1, 2, 3]` and you want to change to a linked list for whatever performance concern, you'd have to replace `[1, 2, 3]` with..

    var list = new List();
    l.insert(1);
    l.insert(2);
    l.insert(3);

Maybe this example is contrived, but I feel like it is much more of a realistic example to want to change from an unsorted map to a sorted map. You can't just simply switch from `{k1: v1, k2: v2}` to `sorted{k1: v1, k2: v2}` as you could do in Lisp from `(unsorted-map k1 v1 k2 v2)` to `(sorted-map k1 v1 k2 v2)`. You'd need to write out all of your operations as with the list example. And, all of a sudden you are stuck with using the unsorted data structure for your JSON serialization rather than having the ability to reach for a sorted data structure.

`(date 2026 6 1)` is better than "2026-06-01" because the latter isn't a date, it's a date string. `(date 2026 6 1)` is better than `new Date(2026, 6, 1);` because the former is how it is serialized and can be deserialized.

> there's also the crazy bracket matching

At least with reading code, there is almost no reason to try to match brackets at all. It's like complaining about having to read semi-colons in languages that use them to signify the end of a statement. When writing code, Lisp is just another language like all the rest that benefit from an IDE that is syntax-aware. Having highlights for the starting paren and ending paren for an expression and being able to just select a particular expression make bracket matching fairly effortless.

> `(== a b)` is clearly worse than `a == b`

It's clearly worse just because it moved from infix to prefix and is wrapped by parens? Is `(* (+ a b) (+ c d))` clearly worse than `(a + b) * (c + d);`? Both have a bunch of parens, and one even has a semi colon.

This works both ways. `(list 1 2 3)` is clearly better than:

        var l = new List();
        l.add(1);
        l.add(2);
        l.add(3);

It's also better than `var l = [1, 2, 3];`

How often are you trying to make sense of a bunch of infix arithmetic operations when you're programming? Separately, how often are you creating data structures, navigating data structures, handling data in the form of JSON or XML, parsing that data into your language's native data structures, etc.?

Reading arithmetic in prefix instead of infix is easy, even if it is counter to how you were taught in elementary school. Working with s-expressions for code and data is clearly better than whatever syntax your language uses for code and either directly instantiating data or reaching for JSON or XML.

> justify its lack of static typing

Racket has both Typed/Racket as well as contracts.

I hope 99% of that was documentation and testing.

I am pretty sure Racket's `stream` will handle this use case.

https://docs.racket-lang.org/reference/streams.html

Threading macros are nice, though, right?

https://docs.racket-lang.org/threading/introduction.html

The cool thing about Dolt is that you [eventually] get the features of the databases (MySQL, PostgreSQL, SQLite, MongoDB) they emulate, so you can have your PG 19 temporality features as well as branching and merging.

> Recently, a new type of question has entered the database arena: what did this data look like last Tuesday?

This question has been answerable in Dolt for years now.

I tried to see if an LLM service provider could rewrite some legal docs where nothing was hallucinated in order to follow a consistent format to see what may be missing in the document. It could do that.

Next, I wanted to see if this could be done with a local LLM. Gemma-4 handles this fine with an 8GB video card and a large context (128k).

Next, I wanted to see if the model could also OCR these docs and translate them. The same model can handle that quite well.

This was when I realized LLMs should be great for handling work where:

- I already know what I want to do

- I already know how to do it

- I don't think this task will help develop skills I find to be valuable

- If I have to do it manually myself, I will probably cut corners

So now I view LLMs through the lens of, "what work can I send to an LLM that I otherwise would not really care about doing."

> I would emphasize the importance of batching and set operations.

Please, preach your gospel more loudly and frequently. It always feels like people complain about RDBMSs being slow because they run insert queries one at a time.

S-expressions. Defining data in JSON or XML is way worse than S-expressions.

How much faster? How much cleaner? What tasks are you accomplishing?

Wow, what an apples and aliens comparison. You add a bunch of transaction delays to your postgresql case because you can access a database over a network, but you use transaction batching for sqlite? Maybe just compare a local postgresql with/without batching to a local sqlite with/without batching to be much less misleading.

> What’s an example of a unionized vs non unionized group producing the same thing where unionized is better?

Here's a layup: art. Remember the writer's union strike in 2007-2008? All of the shows whose writers were on strike that still went on were terrible.

Edit: also, the purpose of a union is not to "produce something better". The purpose of a union is to protect workers' rights. They generally serve their purpose very well.

Is it so difficult to say, "You're right. I'm wrong. There are actually unions for autoworkers in both China and Japan." ?

If you're referring to C# (and Java) being the Kingdom of Nouns where a type like ArrayList is defined and contains its methods, sure, Lisp is not exactly like that, but I feel like conventions give you a similar experience. For example, functions related to hash tables all have `hash` in their name and are either constructors or they take a `hash` argument. They are contained in their own file (hash.rkt).

Also, doesn't inheritance interfere a bit with your "functions aren't tied concretely together to types" observation? You can examine a source file for ArrayList, but if it extends List, you may not see everything you expect to see, and would just defer to the docs to help you out (or click through more source files).

I assume Racket contracts can handle your concern about relating functions and types. An IDE or static analysis tool can help you find all of the functions that operate on a `dict` type if you don't want to rely on conventions where you just seek out a dict.rkt file.

For what it's worth, coming from lots of Java experience, as a Racket novice, I poked around the Racket internals and added Candlesticks to its `plot` library [0] and removed a call to a deprecated gdk function that was causing overhead when drawing text [1]. It never felt like an insurmountable task just because methods aren't defined within types.

By finding problems with Lisp, you are finding problems with s-expressions, which, to me, are so plainly superior to XML and JSON for defining data that I wish more languages would at least consider adopting them for data definitions.

[0] https://github.com/racket/plot/commit/7f38feaf6e28a1decec93d...

[1] https://github.com/racket/gui/pull/95