this post was submitted on 02 Mar 2025
26 points (88.2% liked)

GenZedong

4454 readers
102 users here now

This is a Dengist community in favor of Bashar al-Assad with no information that can lead to the arrest of Hillary Clinton, our fellow liberal and queen. This community is not ironic. We are Marxists-Leninists.

This community is for posts about Marxism and geopolitics (including shitposts to some extent). Serious posts can be posted here or in /c/GenZhou. Reactionary or ultra-leftist cringe posts belong in /c/shitreactionariessay or /c/shitultrassay respectively.

We have a Matrix homeserver and a Matrix space. See this thread for more information. If you believe the server may be down, check the status on status.elara.ws.

Rules:

founded 4 years ago
MODERATORS
GrainEater@lemmygrad.ml
ComradePupIvy@lemmygrad.ml
Elara@lemmygrad.ml
American_Communist22@lemmygrad.ml
26
The AI Hoax is Destroying America with Ed Zitron (www.youtube.com)
submitted 2 weeks ago by Makan@lemmygrad.ml to c/genzedong@lemmygrad.ml
45 comments fedilink hide all child comments
 

And yet, China is using AI.

...I... don't know what to think about that.

...I really don't.

Because it seems that AI is just a scam.

It may "exist" but what it can do is a scam.

Maybe China thinks we have to use it just to "keep up" with the Western powers, but I dunno.

Anyway, interesting discussion with Adam Conover and Ed Zitron. It's long, but you can listen to it while doing other things. And the comments are interesting too, but then again, there are also trolls in the comments as well (AI supporters here and there).

Frankly, though? I oppose AI. I'm anti-AI. I'm anti-AI in China and anti-AI in America and anti-AI in the whole damn planet.

you are viewing a single comment's thread
view the rest of the comments
[–] yogthos@lemmygrad.ml 2 points 2 weeks ago (13 children)

I find it works well for many purposes, particularly R1 variant. I've been using it for lots of stuff and it saves me time. I don't think it's flawed technology at all, you just have to understand where and how to use it effectively just like any tool.

[–] footfaults@lemmygrad.ml 3 points 2 weeks ago (12 children)

I would argue that if your goal is to get an output that is the statistical mean for a given input, then sure an LLM will generate a set of outputs that statistically go together. It just happens that you throw enough data at it and waste a small country's annual energy consumption then of course you'll get something statistically similar. Congrats. You did it.

[–] yogthos@lemmygrad.ml 3 points 2 weeks ago (11 children)

The energy consumption has already been reduced drastically by reinforcement learning, mixture of agents, quantizing, and other techniques. We're literally just starting to optimize this tech, and there's already been huge progress in that regard. Second, it's already quite good at doing real world tasks, and saves me a ton of time writing boilerplate when coding.

[–] footfaults@lemmygrad.ml 2 points 2 weeks ago (1 children)

Second, it’s already quite good at doing real world tasks, and saves me a ton of time writing boilerplate when coding.

So, that's another thing that I wonder about. All these LLMs are doing is automating boilerplate code, and frankly that's not really innovative. "Programming via stack overflow" was a joke that has been in use for nearly two decades now (shudder) and all the LLM is doing is saving you the ALT+TAB between SO and your text editor, no?

If you're doing a TODO app in Angular or NextJS I'm sure you get tons of boilerplate.

But what about when it comes to novel, original work? How much does that help? I mean really how much savings do you get, and how useful was it?

[–] yogthos@lemmygrad.ml 3 points 2 weeks ago (1 children)

The reality is that most of programming isn't all that innovative. Most work in general isn't innovative. Automating the boring stuff is literally the whole point. Meanwhile, it's far more sophisticated than copy pasting from StackOverflow. It can come up with solutions in a context of a specific problem you give it, and the chain of reasoning DeepSeek R1 produces is actually interesting in itself, as it reads like a chain of thought.

This itself can actually be useful for doing novel and original work because it stimulates your thinking. Sometimes you see something that triggers an idea you wouldn't have had otherwise, and you can pull on this thread. I find it literally saves me hours of work, and it is very useful.

For example, just the other day I used it to come up with a SQL table schema based on some sample input JSON data. Figuring out the relationships would've taken me a little while, and then typing it all up even longer. It did exactly what I needed, and let me focus on the problem I wanted to solve. I also find it can be useful for analyzing code which is great for getting introduced to a codebase you're not familiar with, or finding a specific part of the code that might be of interest.

It's also able to find places in code that can be optimized and even write the optimizations itself https://github.com/ggml-org/llama.cpp/pull/11453

Based on my experience, I can definitively says that his is a genuinely useful too for software development.

[–] footfaults@lemmygrad.ml 2 points 2 weeks ago* (last edited 2 weeks ago) (1 children)

For example, just the other day I used it to come up with a SQL table schema based on some sample input JSON data

How likely is it that this JSON structure and corresponding database schema is somewhere in the (immense) training data. Was it novel? New?

Like I just have continual questions about an LLM doing 3NF a priori on novel data.

Like if we just outright say that LLMs are just a better Google or a better IntelliSense that can fetch you existing data that it has seen (which, given that it's basically the entire Internet, across probably the entire existence of the Internet that has been crawled by crawlers and the Internet archive, which is a boggling amount) instead of dressing it up as coming up with NEW AND ENTIRELY NOVEL code like the hype keeps saying, then I'd be less of a detractor

[–] yogthos@lemmygrad.ml 3 points 2 weeks ago (1 children)

How likely is it that this JSON structure and corresponding database schema is somewhere in the (immense) training data. Was it novel? New?

You seem to think that the way these things work is by just simply pulling up chunks of existing code from a big db. That's not actually what's happening. It's building a solution for a particular context based on its training data. This is not fundamentally different from how a human developer solves problems either. You learn through experience and once you've solved many problems, you recognize patterns and apply solutions you learned previously in a new context. It is writing new and novel code when it produces solutions.

[–] footfaults@lemmygrad.ml 2 points 2 weeks ago (1 children)

You seem to think that the way these things work is by just simply pulling up chunks of existing code from a big db

Sorry, that is not what I think. It's just that surely there was something very similar enough to your JSON to get the prediction to come up with something that looks similar enough. It's very annoying having to discuss an LLMs intricate details of how it works and then get nitpicked on a concept that I don't think I was saying

[–] yogthos@lemmygrad.ml 3 points 2 weeks ago (1 children)

Sorry, that is not what I think. It’s just that surely there was something very similar enough to your JSON to get the prediction to come up with something that looks similar enough.

That's the thing it's not that there was something similar to my specific problem. It's parts of many billions of problems that have been fed into the system have aspects that all come together to produce a solution for the particular problem. You don't even have to start with JSON, you can ask it to come up a JSON schema by simply giving it parameters.

I'm not nitpicking you, I'm pointing out that what you've described isn't actually how these things worked, and the way they do work is far more useful in practice. Let me give you a concrete example. Given a query of "write a json schema to represent a comment thread on a social media site like reddit", it'll do this bit of reasoning:

Okay, I need to create a JSON schema for a comment thread similar to Reddit. Let me start by breaking down what a Reddit-style comment thread includes.

First, each comment has an ID, author info, content, timestamps, votes, and replies. The replies are nested comments, forming a tree structure. So the schema should allow for nested objects within each comment's replies.

I need to define the required fields for a comment. The ID is essential, as is the content and author information. The author should have a username, maybe a profile link, and flags like is_mod or is_admin.

Voting information: upvotes and downvotes counts, and a total score. Also, whether the current user has voted, which could be an enum indicating up, down, or none.

Timestamps for when the comment was created and last edited. Maybe include an edited field that's either a boolean or a timestamp.

Replies need to be an array of comments, which means the schema will reference itself. That requires using "$ref" to point to the comment definition, allowing for recursion.

Moderation aspects: flags for removed, locked, spam, etc. Distinguish between user deletion and mod removal.

User mentions and links: comments might reference other users or contain URLs, so including arrays for those.

Awards or badges on comments, similar to Reddit's awards. Each award could have a name, image URL, and count.

Pagination for long threads? Maybe include a "continue_thread" field with a token for loading more replies.

Sorting options for replies (best, top, new, etc.), so a sort_order field with enum values.

Let me structure the schema with definitions. Start with the comment object, then define author, award, user mention, link, etc.

Required fields: id, author, content, created_at, score. Maybe others depending on necessity.

For the voting, current_user_vote should be an enum of "up", "down", or null.

Ensure that all optional fields are not required. For example, edited can be a boolean or a timestamp, but maybe just a timestamp if it's been edited.

Validation: each comment's replies must be an array of comment objects. Use "items" with "$ref" to the comment schema.

Testing edge cases: deleted users, removed comments, maximum nesting depth. But the schema might not handle depth limits, just the structure.

Include examples to illustrate how a comment with replies would look.

I think that covers the main aspects. Now, draft the schema with these considerations.

This alone is already useful because it goes through the steps of the problem, identifies some corner cases, and suggests what a good way to model this problem might be. It will then produce a json schema based on that:

{
  "$schema": "http://json-schema.org/draft-07/schema",
  "title": "Social Media Comment Thread",
  "type": "object",
  "definitions": {
    "comment": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "format": "uuid",
          "description": "Unique identifier for the comment"
        },
        "author": {
          "$ref": "#/definitions/user"
        },
        "content": {
          "type": "string",
          "description": "Markdown-formatted comment content"
        },
        "created_at": {
          "type": "string",
          "format": "date-time"
        },
...
    "total_comments": {
      "type": "integer",
      "minimum": 0
    },
    "depth_limit": {
      "type": "integer",
      "description": "Maximum allowed comment depth"
    },
    "comment_limit": {
      "type": "integer",
      "description": "Maximum comments per page"
    }
  },
  "required": ["thread"]
}

it highlights key features of the solution

Key Features:

    Nested Comments: Recursive structure for replies

    Voting System: Track upvotes/downvotes and user's vote

    User Identity: Detailed author information

    Moderation: Flags for removed/locked/deleted content

    Awards: Support for Reddit-style awards

    Mentions & Links: Track user mentions and embedded links

    Sorting & Pagination: Handle different sort orders and partial threads

    Safety Features: Distinguish user deletion vs mod removal

This schema supports:

    Infinite nesting of comments

    Multiple sorting algorithms

    User reputation systems

    Content moderation tools

    Rich text formatting

    Pagination for large threads

    User interaction tracking

and it gives an example usage (I've truncated it for brevity)

{
  "thread": {
    "id": "550e8400-e29b-41d4-a716-446655440000",
    "author": {
      "username": "tech_fan42",
      "avatar": "https://example.com/avatar.jpg",
      "is_mod": false
    },
    "content": "This new framework is amazing! 🚀",
    "created_at": "2023-08-20T14:30:00Z",
    "score": 1542,
    "replies": [
      {
        "id": "3f3e6c60-3d7d-461d-aa7a-5c94f5d5dc5d",
        "author": {
          "username": "framework_author",
          "is_admin": true,
          "distinguished": "admin"
        },
        "content": "Thanks! Check out our [docs](https://docs.example.com/)",
        "created_at": "2023-08-20T14:35:00Z",
        "score": 893,
        "links": [
          {
            "url": "https://docs.example.com/",
            "text": "docs"
          }
        ]
      }
    ],
    "awards": [
      {
        "name": "Gold",
        "image_url": "https://example.com/gold.png",
        "count": 2
      }
    ]
  },
  "total_comments": 45,
  "depth_limit": 8
}

Now, given that schema, I can get it to produce a SQL schema from that, write the queries to do operations against the DB, etc. So, I can go directly from getting requirements in plain English, to having a reasonable data model, and a persistence layer in a span of a few minutes. I can also ask it to explain design decisions, make adjustments, etc.

This is far closer to pair programming with a second developer than hunting for code to glue together on Stack Overflow.

[–] footfaults@lemmygrad.ml 1 points 2 weeks ago (1 children)

Just wanted to say that I'm holding on to this post to read it carefully since you put a lot of work into it. Haven't had the time to give it the attention it deserves. Not to argue, so don't think I'm winding up a rebuttal, I just haven't been able to give it the time it deserves

[–] yogthos@lemmygrad.ml 1 points 2 weeks ago (1 children)

No worries, and thanks for taking the time to read through it.

[–] footfaults@lemmygrad.ml 1 points 2 weeks ago* (last edited 2 weeks ago) (1 children)

ok first dumb question, is the block of code that you had below this line

Given a query of “write a json schema to represent a comment thread on a social media site like reddit”, it’ll do this bit of reasoning:

Was this an actual output from an LLM or a hypothetical example that you wrote up? It's not quite clear to me. It's a lot of output but I don't want to insult you if you wrote all that yourself

First, each comment has an ID, author info, content, timestamps, votes, and replies. The replies are nested comments, forming a tree structure. So the schema should allow for nested objects within each comment's replies.

I ask because I really want to nitpick the hell out of this design decision:

First, each comment has an ID, author info, content, timestamps, votes, and replies. The replies are nested comments, forming a tree structure. So the schema should allow for nested objects within each comment's replies.

Adding the replies as full items, that is going to absolutely murder performance. A better scheme would be for replies to be a list/array of IDs or URLs, or a URL to an API call that enumerates all the replies, instead of enumerating all the items and embedding them directly. That is going to absolutely kill performance. Depending on the implementation, you could easily be doing the classic N+1 query that a lot of web applications fall for.

But then again at this point I'm arguing with an LLM which is generating absolutely dogshit code.

[–] yogthos@lemmygrad.ml 1 points 2 weeks ago (1 children)

Was this an actual output from an LLM or a hypothetical example that you wrote up? It’s not quite clear to me. It’s a lot of output but I don’t want to insult you if you wrote all that yourself

That was copy pasted straight from the DeepSeek chat response.

Adding the replies as full items, that is going to absolutely murder performance.

Like I said earlier, you still have to understand how to code and what the code is doing. Thing is that you could literally paste what you said in, and it'll make adjustments. Or you can just make adjustments yourself. As a starting point I find that sort of output useful.

Another example is that I have to use node for an application for work right now. I haven't touched js in over a decade, I'm not familiar with the ecosystem, and DeepSeek lets me quickly get things running. Things I would've spent hours looking up before and doing through trial and error just work out of the box. As I pointed out in an earlier reply, most apps aren't doing really complex or interesting things. Most of it is just shuffling data between different endpoints and massaging it in some way. LLMs can do a lot of this boring work quickly and efficiently.

[–] footfaults@lemmygrad.ml 1 points 2 weeks ago

I want to say that you've piqued my interest, but honestly I'm not sure I can set aside my bias. I deal with enough wrong code already as it is that my co-workers write, so I don't know if having yet another one giving me bad code suggestions adds much, but I appreciate you putting in the work showing everything.

load more comments (9 replies)
load more comments (9 replies)
load more comments (9 replies)