killthebuddha

Disclaimer: I agree with you.

Devil's Advocate: I actually can't, absolutely **** take.

The author's grandpa reminds me of Sam Hamilton from East of Eden, someone who (though fictional, of course) I think about often when I think about the kind of man I'd like to be some day. A couple lines in particular jumped out at me:

> He had a visual vocabulary that amazed me

> do you know what it is like to make your whole life?

These two lines together hint at a kind of connectedness with the world that I sometimes feel (and observe in certain cases) an acute lack of. I see it in myself and in many people I care about, but also in the archetypes generated by the culture/society I'm embedded in. A lot of the time when I talk to people about this particular thing, they assume I'm being nostalgic, but I don't think so. I think we don't realize how many hard (as in "hard science") truths we really learn from casual observations of the wind and the stars and the trees.

Ha! Intellectually I completely agree. This particular term has recently worked its way back into my social circle's lexicon because we all have young kids and are trying to swear less. I'm not sure I have ever used it in writing before, and I guess I never will again!

This thread must have at least one A Fire Upon the Deep reference, so I'll do it: https://en.wikipedia.org/wiki/A_Fire_Upon_the_Deep

Edit: tldr; Vernor Vinge, the guy who originally coined the phrase "the singularity", wrote a really excellent SciFi novel about information archaeology, artificial intelligence, galaxy-spanning civilizations, black holes, and all sorts of other dope ish.

I'm having a weirdly difficult time finding some basic ELI5 answers.

  - What is the probability that this asteroid will hit us?
  - What is the time interval where that probability applies?
  - Do we have a probability distribution for where it might hit? I don't know anything about anything, but I assume we know what *general direction* it's coming from?
  - Do we have a probability distribution for the potential blast radius?

In general, I am very confused by this news because "400m diameter asteroid 3% chance of impact" is something I would expect literally everybody to be talking about all the time. It's also something where if I learned that everything north of Kansas has a 5% chance of getting hit but everything south of Houston has a 1% chance, I'd seriously consider taking an impromptu vacation.

Hot-ish take incoming:

It's even less complicated than all this. You spend X on a feature to increase revenue by Y. You pay a plumber N so you don't have to pay a flooring guy 10N. In some orgs, if they're large, you could replace $ with $KPI, but $KPI should still be obviously quantifiable. If you're an engineer without obviously quantifiable KPIs (especially if you're a young-ish engineer with ambitions of becoming really excellent one day), you might consider selling your skills to a more serious employer.

I've never used it for Mongo, but Prisma is a pretty great type-safe ORM that supports Mongo: https://www.prisma.io/docs/getting-started.

Zod is...so freaking great. I'm feeling kind of hyperbolic at the moment, so I'll even go so far as: for a certain style of programming, adding Zod to a codebase is as big of a win as adding TypeScript.

+1. Almost every time I actually write out a type it's because I want to communicate some domain knowledge. For everything else I use inferred types. IMO this is The Way.

IME if a join is the problem, a join is not the problem.

A similar approach I've been using recently and am so far really, really enjoying is to put all "conversation" into a dedicated "devlog" directory in the project root. We put everything in it: meeting notes, project status updates, memos, changelogs for every pull request, reviews, etc. Every file is markdown and named with a date prefix, a "nonce" for uniqueness, and a category (date.nonce.category.md). So you might have something like:

  - 2023-08-10.00.notes.md
  - 2023-08-10.01.notes.md
  - 2023-08-11.00.changelog.md
  - 2023-08-11.01.changelog.md
  - 2023-08-11.00.review.md
  - 2023-08-11.01.review.md
  - 2023-08-11.02.review.md
  - 2023-08-11.00.project.md

The file naming includes a small amount of ambiguity and a small opportunity for merge conflicts but in practice it's just not a problem. The best part of this workflow IMO is that it doesn't create a whole new workflow for communication, it treats high-quality async communication as part of the core (pull, read, commit, push, review) development workflow.

I don't want to make any real assertions but my intuitive reaction to this comment is _this person has no clue what they are talking about_. I would rather turn of syntax highlighting than turn off Copilot and I'd rather disable Google search rather than ChatGPT. And frankly, it's not even close, I use these tools "all the time for everything".

Since we're all sharing our favorite simplest solutions, I guess I'll throw https://fly.io out there. The DX is far from perfect right now so this answer is _ever-so-slightly theoretical_ but, if you know how to use Docker, `fly launch` is extremely hard to beat.

FWIW there are tons of ways to use Docker without an image (I assume you meant image) registry. If you're running Docker on the server you're deploying to then that's all you need.

dubioussoup.ai

Edit: I donno why, but the concept of dubious soup has me CRACKING UP right now.

FWIW they mention this in the article:

> I like this, because it kind of eliminates the need for radians: the x in usin(x) has the unit of “turns”. I think this is conceptually much simpler.

It's always seemed to me that Fly has a really awesome, modern perspective on software engineering and that they'd be a great place to work, but I've also always felt like there's a glaring inconsistency between their marketing and product. What I mean is it seems like their marketing (and docs) are all about how trivial it is to spin up globally distributed app servers but the only customers who would need globally distributed app servers are almost certainly not worried about spinning up app servers because they've already got extremely mature platforms with globally distributed data stores. It makes me feel like I'm misunderstanding something fundamental about internet application architectures.

I appreciate the detailed response. I'll look into the SocraticAI project as well.

FWIW I asked because I'm working on a toolkit for applying Monte Carlo tree search to agent graph generation and am always on the lookout for fundamental insights that could help direct its development.

Could anyone who's actually using this spare a moment for an elevator pitch? I am one of many developers who have a latent intuition that our shell programming environment could be made more efficient, but I've yet to see a "killer feature" that is an obvious (even 2x would qualify) productivity boost.

One tool that I'm really excited to implement and use, but haven't found the time (and I'm sure someone else has already started), is a command that wraps any other command and exposes a global hotkey that, when pressed, shovels the last N lines to an LLM and asks it for advice.

Further down the line, I'm imagining being on a team where all developers' error logs are piped into a central feed and that feed is used to eliminate a large swathe of duplicated effort (how often is it the case where a whole team spends an hour or two debugging the same regression, broken dev env, etc?).

This sounds quite interesting, could you expand on it? What is some of the low-hanging fruit in your opinion? Do you have any examples of projects that are explicitly building on top of these ideas?

Here's a couple (I apologize if some of these are already obvious to you):

  - https://python.langchain.com/docs/use_cases/code/code-analysis-deeplake
  - https://twitter.com/jerryjliu0/status/1636728577524916225?s=20 (GPT repo loader)

FWIW there's tons of tools you could use to do this. GitHub Copilot is pretty close to being a comprehensive solution as well.

This of course depends entirely on how big the codebase is. But the short answer is "yes".

I feel like the toy examples in the article might only make sense to people who already know why they want this feature. The examples don't make it at all obvious to me why I would want this feature. The new version in the examples have more code, more indirection, and more magic (in the sense that it relies directly on a specific property of the runtime). Could anyone here help me understand a more robust example where `try...finally` just won't work (or at least would be patently less readable/etc)?

I've scanned the codebase and IMO the statement is mostly misleading. I think LangChain agents (which this is a thin wrapper around) do have some default compression/reranking behavior to help fit relevant context into the context window, but it's very, very, very far from actually infinite short-term memory.

I think the framing where the statement could be considered true is if you assume "memory = persistent storage", which is IMO not what most people will do.

Note: I'm not trying to imply the authors are being intentionally misleading.

When you're building applications on top of LLMs, there are a number of central problems that you're trying to solve and this is one of them. Solutions are numerous and widely variable, everything from basic regex parsing to fine-tuning validator models to new programming/modeling languages. Here's some examples:

  - https://github.com/microsoft/guidance
  - https://github.com/NVIDIA/NeMo-Guardrails/
  - https://github.com/r2d4/rellm
  - https://shreyar.github.io/guardrails/
  - https://lmql.ai/
  - https://github.com/jbrukh/gpt-jargon

I didn't want to not reply but I also didn't want to be swept into a potentially fraught internet argument. So, I tried to edit my comment as a middle ground, but it looks like I can't, I guess there must be a timeout. If I could edit it, I'd add the following:

"I should point out that I wasn't personally involved, haven't looked into it in detail, and that there are many different perspectives that should be considered."

Another important detail about the ejections that I think is particularly classy is that the people he ejected are broadly considered to have world-class technical skills. In other words, he was very explicitly prioritizing collaborative potential > technical skill. Maybe a future BDFL[1]!

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

I skimmed the repo, one thing that I noticed and appreciate about this project is that it looks like it doesn't make any assumptions about your prompts.

One very similar tool is https://github.com/paradigmxyz/flux.

Another option that's not quite as good as `a + b + c` but that is possible with TypeScript is a fluent API:

  const sum = a.add(b).add(c);

Awesome! I similarly blew it by not mentioning that I think this is an awesome project. I bet tons of people have been similarly inspired by the book and by Penrose (I know I have) but you've actually gone out and done a thing, mad kudos to you!