dbmikus

We could complain about Stackoverflow, Google, automatic memory management, compiler optimization, the fact that a broken program doesn't crash your entire OS, ...

A related point: MIT dropped the SICP curriculum in 1997, the reasoning being:[1]

> Sussman said that in the 80s and 90s, engineers built complex systems by combining simple and well-understood parts. The goal of SICP was to provide the abstraction language for reasoning about such systems. > > Today, this is no longer the case. Sussman pointed out that engineers now routinely write code for complicated hardware that they don’t fully understand (and often can’t understand because of trade secrecy.) The same is true at the software level, since programming environments consist of gigantic libraries with enormous functionality. According to Sussman, his students spend most of their time reading manuals for these libraries to figure out how to stitch them together to get a job done. He said that programming today is “More like science. You grab this piece of library and you poke at it. You write programs that poke it and see what it does. And you say, ‘Can I tweak it to do the thing I want?'”. The “analysis-by-synthesis” view of SICP — where you build a larger system out of smaller, simple parts — became irrelevant. Nowadays, we do programming by poking.

As software becomes more powerful, it must become more complex. And thanks to the internet, we have tons of pre-built solutions out there. Now, much of the problem is combining them together. When doing this, you can't know or care about every line. I totally agree, we must treat a lot more systems scientifically, like an object under observation.

[1]: http://lambda-the-ultimate.org/node/5335

If you look at LLM performance on benchmarks, they keep getting better at a fast rate.[1]

We also now have models of various sizes trained in general matters, and those can now be tuned or fine-tuned to specific domains. The advances in multi-modal AI are also happening very quickly as well. Model specialization, model reflection (chain of thought, OpenAI's new O1 model, etc.) are also undergoing rapid experimentation.

Two demonstrable things that LLMs don't do well currently, are (1) generalize quickly to out-of-distribution examples, (2) catch logic mistakes in questions that look very similar to training data, but are modified. This video talks about both of these things.[2]

I think I-JEPA is a pretty interesting line of work towards solving these problems. I also think that multi-modal AI pushes in a similar direction. We need AI to learn abstractions that are more decoupled from the source format, and we need AI that can reflect and modify its plans and update itself in real time.

All these lines of research and development are more-or-less underway. I think 5-10 years is reasonable for another big advancement in AI capability. We've shown that applying data at scale to simple models works, and now we can experiment with other representations of that data (ie other models or ways to combine LLM inferences).

[1]: https://www.anthropic.com/news/3-5-models-and-computer-use [2]: https://www.youtube.com/watch?v=s7_NlkBwdj8

I used to debug with curse words until I accidentally pushed one of those into the company's open source repo and then we went and did some `git push --force` to scrub it from history.

Now I just use my initials at the start of a debug line.

Cursor is much better than Copilot. Also, change it to use Claude, and then use the Inspector with ctrl-I

I believe you're both saying the same thing. LLMs write "re-usable code" at the meta level.

The code itself is not clean and reusable across implementations, but you don't even need that clean packaged library. You just have an LLM regenerate the same code for every project you need it in.

The LLM itself, combined with your prompts, is effectively the reusable code.

Now, this generates a lot of slop, so we also need better AI tools to help humans interpret the code, and better tools to autotest the code to make sure it's working.

I've definitely replaced instances where I'd reach for a utility library, instead just generating the code with AI.

I think we also have an opportunity to merge the old and the new. We can have AI that can find and integrate existing packages, or it could generate code, and after it's tested enough, help extract and package it up as a battle tested library.

This is very cool! Most of the work I've seen on reducing inference costs has been via things like LoRAX that lets multiple fine-tunes share the same underlying base model.

Do you imagine Outerport being a better fit for OSS model hosts like Replicate, Anyscale, etc. or for companies that are trying to host multiple models themselves?

Your use case mentioned speaks more to the latter, but it seems like the value at scale is with model hosting as a service companies.

Making concurrent work deterministic and solving data races makes sense.

Thanks for explaining! I didn't fully grok this from the LangGraph docs

I've thought about the same things as we built our own open source project for LLM workflows (https://github.com/gofixpoint/fixpoint/).[1]

I like the Pytorch comparison, and I've seen DSPy position themselves as Pytorch for prompting.

I also think the actor model is a natural fit for AI agents, which has some similarities with Pregel (message passing), and some differences (there are no super-steps of graph execution, each actor has its own thread).

I definitely dislike state machines for most use cases.[2] I think we can learn a lot about good AI agent paradigms from game programming, and I enjoyed this article on game state: https://gameprogrammingpatterns.com/state.html

At the end, they mention that game AI doesn’t often use state machines anymore, because the structure they impose is limiting.

Also, the folks behind Temporal are anti-state-machine:

https://pages.temporal.io/download-state-machines-simplified...

https://community.temporal.io/t/workflow-maintainability-abs...

    [1]: our goal is to be an open-source alternative to the OpenAI Assistants API, not to compete with LangGraph, but there is overlap
    [2]: I understand that LangGraph is not a state machine

Good to know!

Is there a succinct explanation of the value that pregel brings to LangGraph? Is it the 3 items I mentioned?

I was thinking through, what are the benefits of coding up your agent system via a pregel-like graph, instead of just doing function calls? Or versus the actor model? The execution trace of a (concurrent or serial) computer program is a graph. And the actor model lets you do message passing between "nodes/actors" without having to predeclare your graph structure.

The three reasons I can think of:

    1. by predeclaring the structure, you can show debugging UI of the full graph, even if you've only executed part of it
    2. Pregel can make it easier to reason about global state transitions (you can accomplish this in other systems too, if you set it up right)
    3. by enforcing heavier structure on your program, you can ask the AI to reason about the whole graph or generate new graph parts

The downside is that this is an abnormal way of writing computer programs, originally designed for high-scale processing (Hadoop, Apache Spark, etc.). If you want to dynamically change the control flow of your program or special case control flow at various points, you'll wrestle against the up-front graph structure.

I personally have more of a preference to write normal-looking code, without having to predeclare my execution graph.

To get feature parity, you still need an IDL to generate types/classes for multiple languages. You could use JSON Schema for that.

Websockets do not follow a request/reply semantics, so you'd have to write that yourself. I'd prefer not to write my own RPC protocol on top of websockets. That said, I'm sure there are some off the shelf frameworks out there, but do they have the same cross-language compatibility as protobuf + gRPC? I don't think "just use JSON with websockets" is such a simple suggestion.

Of course, gRPC does have some of its own problems. The in-browser support is not great (non-existent without a compatibility layer?) last time I checked.

Information hierarchies are empirically important and are an essential part of communications design. Uniform syntax makes information hierarchies harder to parse, because the boundaries around different types of information all look the same. It's the same reason we have different sized headings, bold text, etc. They are distinct markers.

So yes, fewer symbols means easier memorization, but you could take that to the extreme and you'll find that binary is harder to read than assembly.

I think Lisp is really elegant, and the power to treat a program as a data structure is very cool. But scanning Lisp programs visually always takes me a little more effort than most other languages.

Super alignment is about aligning AIs that are smarter than us, while alignment is about aligning AIs dumber than us.

I would consider YC a pretty clear representative of "little tech", albeit little tech with startup/hyperscale ambitions. So, IMO it's not out of touch, it's very on-point.

Unwashed rice is normally gummier or more starchy

Just curious, does AGPL require actively publishing the source code, or making it available upon request within a reasonable timeframe?

Up until the end of 2023, I lived around the corner from one. It was always busy and then one day I walked over to buy some household supplies and it had suddenly closed. I guess this was why.

I think part of the problem for LLMs is that they don't operate in an easily scoreable "game". We can make them work well for optimizing next token(s) log likelihood, but how do we judge quality of the output for the task it was made for?

Then after that, there are other challenges, such as do LLMs have a world model that lets them think how to attain a reward?

Wherever you can have an automated feedback mechanism, you can start to address the first problem and allow for the AI to explore more of the "tree". These are situations like coding (you can run the code and evaluate the output), or situations where you can let the LLM crowd-source user feedback.

For models that have some actual world model, who can reason across modalities, and who can plan, LeCunn talks about this often. The videos/slides here[1] were good content.

[1]: https://www.ece.uw.edu/news-events/lytle-lecture-series/

Congrats on the launch! Image consistency is a big thing to solve. I don't make videos, but sometimes I try to get OpenAI to tweak an AI generated graphic and it ends up rendering it completely differently.

Good luck with Eggnog! I think AI generated media is really cool.

Congrats on the pg_analytics launch! Great to see ParadeDB consolidating some of these tools. Useful at the early stage to not manage multiple databases.

Didn't realize that Steve Yegge is now at Sourcegraph! He created Kythe[1] at Google, so Sourcegraph makes sense for a place to be.

[1]: https://en.wikipedia.org/wiki/Google_Kythe

Looks like it's launching with some nice developer tools: low-code/no-code AI agent workflow, a prompt playground, etc.

I'd actually guess that free accounts don't have the "toggle AI" option because they just disable AI inference for free users. LLM inference is pretty expensive.

I don't consider playing video games time wasting. If they were, then watching movies is time wasting, enjoying art is time wasting, playing board games or sports with friends is time wasting.

Certainly, an addiction to gaming is bad, as is playing games too much to the detriment of the rest of your life. Ultimately, everyone should do what they find enjoyable in the moment that they will simultaneously not regret later in life. Totally understand if video games fall under that category for you, but I dispute them as "time wasting" as a general statement.

Don't know any of these terms, but you gave me some interesting topics to google about. Thanks!

I've found this fun way to think of it: the goal is to invent a faster form of evolution for pattern recognition, learning, and autonomous task completion. I think one needs to consider it more like biology and a science than pure logic and math. We can discover things that work, and then after that we can study them to learn why they work, just like we don't fully understand the brain yet.

I think there are some really cool problems, such as:

    1. Is synthetic data viable for training?
    2. How do you make deep learning agents that can do task planning and introspection in complex environments?
    3. How do we efficiently build memory and data lookup into AI agents? And is this better/worse than making longer context windows?

I think Show HN posts from YC startups are actually boosted by the system. Same with the hiring posts for YC startups. So it's not people, but explicitly coded in.

But I don't know if this is truly the case.

Good point about the negative reinforcement training!

Instruction tuning is on top of the base LLM and is often RLHF to train the base LLM to produce certain kinds of responses.

IMO, they're missing out on building a lot of proprietary data if they don't drive more users to chatting with Claude.

The instruction-tuning is the guard rail. What other guard-rails is X AI removing? Just curious if I'm missing something.