lyjackal

Wish this was clarified. One thought would be to choose a stable component to in turn hash, such as the source coordinate hexagon, but then why not just put that in the hashtag

I’d recommend looking through the 20+ years of Laurie’s writing in the archives. The LLMs may very well be mimicking him. I wouldn’t put LLM assisted writing past him, but I feel like this is being judged on topical similarity, and is not the standard kind of egregious incoherent slop that has little substance or lacks coherence. See for example:

https://developer.nvidia.com/blog/introducing-cuda-rust-two-...

While I’m usually one to also get annoyed at uncurated slop, this doesn’t strike me in any way as LLM text, and likely something the author meant in earnest. I reads lot of LLM text. What part about it appeared generated to you?

From my perspective the piece was well structured, paced and thought through (and yes, a bit long)

I saw this for Luna and then looked at the uptime and it said 85%. My interpretation is that this is just a gimmick where they serve the OpenAI flex tier at the same discount OpenAI provides for flex and then fall back to azure

There’s export controls on nvidia. According to Jensen, they expect that Chinese models will start being optimized for Huawei

https://www.dwarkesh.com/p/jensen-huang

They're an Evals company. Its right up there in the top nav under Evals > Vending Bench 2

You’re quoting the batch pricing. On demand is 1.5 per input and 9 per M output. This is effectively comparable cost to Gemini 2.5 Pro in a flash tier model

I think the larger part implied is the design will be crappy, because the problem was unexplored

I want to build a shared postgres db with hundreds of small apps (OLTP) accessing shared tables using a RLS model model against well defined tables.

What are other limitations and mitigations folks have used or encountered to support stability and security? Things like

  - Query timeouts to prevent noisy neighbors
  - connection pooling (e.g. pgbouncer) also for noisy neighbors
  - client schema compatibility (e.g. some applications running older versions, have certain assumptions about the schema that may change over time)

github repository here https://github.com/run-llama/liteparse

it's Friday, and I'm avoiding doing work

I notice that the python versions and typescript versions are pretty different. Python is sort of class based, with python magic decorators

    class MyWorkflow(Workflow):
        @step
        async def start(self, ctx: Context, ev: StartEvent) -> MyEvent:
            num_runs = await ctx.get("num_runs", default=0)

whereas TS is sort of builder/function based

    import { createWorkflow } from "@llamaindex/workflow-core";
    
    const convertEvent = workflowEvent();
    
    const workflow = createWorkflow();
    
    workflow.handle([startEvent], (start) => {
      return convertEvent.with(Number.parseInt(start.data, 10));

Is there reason for this? });

Agree, thanks for the link. I was wondering what actually changed. The resource links and elicitation look like useful functionality.

I've been curious to see the process for selecting relevant context from a long conversation. has anyone reverse engineered what that looks like? how is the conversion history pruned, and how is the latest state of a file represented?

I recently did something similar. Using uv workspaces, I used the uv CLI's dependency graph to analyze the dependency tree then conditionally trigger CI workflows for affected projects. I wish there was a better way to access the uv dependency worktree other than parsing the `tree` like output

This is cool and something that I’ve wanted, but I don’t see hot listings requirements inline foregoes the need for a lock file to maintain reproducibility. What about version ranges? Versions of transitive dependencies?

Mobile 4g USB sticks you can usually rotate your IP address by reconnecting. I tried on a pi, it was inconsistent. This was just with some random test mobile plan from rando carrier renting off Verizon I think

An idea for more complete coverage: have 2 of them, and invert their intervals, such that one and only one is always on

I’ve wondered whether they use thanks as a signal to a conversation well done, for the purpose of future reinforcement learning

It's more the content creators who bear the brunt of toxic rage. Who you follow doesn't solve that problem

Yes, I run into it, but it’s intermittent. Cursor makes some internal decisions to limit its context budget, so my speculation is that it’s related to that, like the actual updated code is just not in the prompt sometimes

If the end goal is just rag or search over the pdfs, seems like ColPali based embedding search would be a good alternative here. Don’t process the PDFs, instead just search their image embedding directly. From what I understand, you also get a sort of attention as to what part of the image is being activated by the search.

drawio and its vscode plugin supports the same

Is there any way to use the TTS on its own? I maintain an obsidian TTS plug-in, and am starting to add new TTS providers (its just been OpenAI thus far). From the documentation at https://docs.play.ai/documentation/get-started/introduction, it looks like their API seems to couple it to an LLM for building conversational agents. Seems like it might be nice to use standalone as just TTS.

Apologies for the x link. I couldn’t find a more official announcement than this. Yesterday hugging face released new checkpoints with much higher quality output, trained for longer, and with speaker consistency.

Demo here: https://huggingface.co/spaces/parler-tts/parler_tts

GitHub: https://github.com/huggingface/parler-tts

character.ai seems to have good usage[1], especially among younger folks. According to this reddit thread[2], lots of users use it as a distraction, like video games, or to make more in-depth fan fiction, or just to scratch a social itch

[1] https://whatsthebigdata.com/character-ai-statistics/

[2] https://www.reddit.com/r/CharacterAI/comments/1abub22/charac...

I’ve been trying out fasthtml as a more scalable prototyping tool for a side project. I’ve really enjoyed using it! I tried gradio first, but 1. didn’t like the look, and 2. You can’t really go off the beaten path. So far I’ve really enjoyed working with fast HTML and htmx. Honestly my biggest complaint on working with “Python-only” dev has been the CSS. I wanted to give the app an easy, but unique/customized look. Most CSS libraries expect to be part of a JS based build pipeline for any type of customization. bootstrap still requires scss customizations, tailwind is its own thing of configuration, pre-processors and tree shaking. Really wish there was a robust css library that relied on css-variables to customize. There are a few but they’re relatively anemic. Anyone know of any good options out there that would be a good fit, or did tailwind just eat everything up?

From what I understand, that’s not the case. They are working on both. I’d be concerned about how you can differentiate and compete with them. They have a big head start