evdubs

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

evdubs

há 16 diasdiscuss

> 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.

evdubs

há 16 diasdiscuss

> `(== 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.

evdubs

há 22 diasdiscuss

[flagged]

evdubs

há 23 diasdiscuss

I hope 99% of that was documentation and testing.

evdubs

há 26 diasdiscuss

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

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

evdubs

há 26 diasdiscuss

Threading macros are nice, though, right?

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

evdubs

há 28 diasdiscuss

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.

evdubs

há 28 diasdiscuss

> 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.

evdubs

mês passadodiscuss

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."

evdubs

mês passadodiscuss

> 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.

evdubs

mês passadodiscuss

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

evdubs

mês passadodiscuss

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

evdubs

mês passadodiscuss

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.

evdubs

mês passadodiscuss

> 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.

evdubs

mês passadodiscuss

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

evdubs

há 2 mesesdiscuss

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

evdubs

há 2 mesesdiscuss

Assuming your comment applies to Common Lisp as well, if Scheme (and Lisp) truly was, "hard to read, unfit for most purposes and that even proficient coders never seem to fully grasp," it wouldn't be the language that introduced so many features later implemented in other languages.

> Lisp pioneered many ideas in computer science, including tree data structures, automatic storage management, dynamic typing, conditionals, higher-order functions, recursion, the self-hosting compiler, and the read–eval–print loop.

So many proficient coders were able to grasp features of Lisp, find the fitness of those features, and implement them in their own languages.

evdubs

há 2 mesesdiscuss

> types don’t have their core functions associated with them concretely.

They do in Racket? You look at the "List" documentation and you find all of the functions for lists. Likewise with hash tables, numbers, strings, sequences, files, etc.

> The only way to know strcat, puts, and strlen exist is…

... to look at the documentation on docs.racket-lang.org. The powerful search includes results not only for the standard ("batteries included") library reference, but also the standard guide and 3rd party libraries.

> once I had my traits that I also wanted compile-time attributes à la Rust/C# and there’s no clean way to add those to Lisp’s syntax

I mean, why are you not able to do (trait whatever) before (define whatever) or (for-each whatever) or (let whatever)?

> Lisp is neat but it just doesn’t fit in the future of programming that Rust and C#

Have you tried it or did you just try to figure out why you don't think you like it from an LLM?

Submissions

Tether Signs Big Four Firm to Complete First Full Audit

comments