never_inline

Cosine similarity alone can't give you good results. For example, if you want to search specific names or acronyms, cosine similarity won't help much.

People act like embeddings are all you need for search.

Curse of dimensionality also means what you think is the most similar is not necessarily the most similar thing in vector space. See the last Hn discussion on word embeddings for some examples.

Having wide shoulders is cool but how does it help with software engineering?

It's just a copy of all other models in terms of functionality. I didn't find anything controversial nor extra-ordinary in it. Image generation sucked.

Some Indian twitterers found a way to get it to utter Hindi profane words, that's probably the most controversial thing I know about it.

Google Docs spellcheck has been really good for few years even before LLMs

> 1. This is using a lot of input context in formating as JSON and escaping a Json inside already a JSON.

Isn't it a model problem that they don't respect complex json schemas?

Me neither. But only because uv is compatible with pip. I am not going to use bun / dinosaur whatever instead of node at this point.

If I were rich, I would have a personal data center, an aeronautics lab, a tropical farm, mediaeval fort, things like that. Not this yatches and crap.

JS developer use tooling older than 3 years challenge. Level: impossible.

Thanks for the clarifications. Good if you mention the background in the medium post. Otherwise it reads like a PoC demo.

5. How did you handle java local and global ref lifetimes in rust callee? Was it assumed that java caller owns all the refs and freed after the rust computation returns? Or did your calls mostly involve byte buffers and primitive types? That latter is a sweet spot but not always feasible.

1. The article seems kind-of shallow. I didn't see any concrete (qualitative or quantitative) remarks about the "fast" part. I don't doubt you have reasons to do this - but I expected some information on what component are you writing using Rust + JNI, and how it helped? Or is it just a demo?

At some point, repeated calls into the JNI are counter-productive to performance, since the JIT can not optimize them. Pinning affecting garbage collection is another potential drawback if any of your rust calls are long lived. If we don't measure and just conclude "we are fast because rust is faster than Java, and we took average of both speeds", it's a disservice.

2. Also, I see unsafe for each call? I'd rather isolate this into a class / different file, since in JNI only few types of calls are possible. (method returning one of the primtive types, an object or `void`). This is the approach I took in dart jnigen. (Though there, the call is Dart -> Java, not Java -> Native language).

    unsafe {
      env.call_method_unchecked(
                java_logger,
                logger_method,
                ReturnType::Primitive(Primitive::Void),
                &[JValue::from(format_msg(record)).as_jni()]
      );
    }

3. I believe some details are missing here. What's native_add_one mapped to? And how is tokio futures awaited from Java? I believe that's the important part you should be presenting.

    public CompletableFuture<Integer> add_one(int x) {
        long futureId = native_add_one(x); // Call Rust
        return AsyncRegistry.take(futureId); // Get CompletableFuture
    }

4. Also please don't use ChatGPT for writing anything. It totally derails the reader by mentioning irrelevant details and long winded corporate conclusion at the end of every sentence.

Aider has a --copy-paste mode which can pass in relevant context to web chat UI and you can paste back the LLM answer.

Well technically Aider let's you use a web chat UI by generating some context and letting you paste back and forth.

The social-ification of tech is indeed a worrying trend.

This is exacerbated by low-quality / promotional medium articles, linkedin etc.. which promote Nth copycat HTML GPT wrapper app or kubernetes dashboard as the best thing after sliced bread, and not-so-technical programmers falling for it.

This applies to some areas more than others (eg, generative AI, cloud observability)

Can someone recreate it in Go?

To be honest I don't think they have any plans either.

I don't write perfect English. Far from it. But I'd prefer broken English any day over default LLM verbiage. It seems so unnatural and facetitious. I always have this in my prompts: "Be succinct and use simple English sentences".

Size issues and bloat can be solved by tree shaking which is orthogonal to granularity of the package ecosystem. It doesn't matter for server side (at least people don't care). On client side, most ecosystems have a way to do it. Dart does it. Android does it with proguard.

The more pressing issue with dependencies is supply chain risks including security. That's why larger organizations have approval processes for using anything open source. Unfortunately the new crop of open source projects in JS and even Go seem to suffer from "IDGAF about what shit code from internet I am pulling" syndrome.

Unfortunately granularity does not solve that as long as your 1000 functions come from 1000 authors on NPM.

They might pivot to some enterprise value added services. Probably around SAST - think sonarqube.

It's RAG never worked for me tbh. I thought it was simply because I didn't have Gpu.

What really is the moat of openwebui? I have seen at least 4 - 5 react UIs with similar functionality (chat, RAG, document library).

I have hacked together a shell script using tail -f with multiple inputs (from kubectl log), and fzf (to select namespace/deployment if there are many).

Can find tuning produce results as grounded as RAG?

How many epochs do you run?

Why would you love on-call though?

?? What happens to old code which sends messages with a system role?

> It's true that many engineer-designed products are terrible

Selection bias from there being too many avg UI open source tools?

Engineer-designed = low budget = no expertise on UX etc.. but product fulfills their purpose.

I am very sceptical and cautious user of AI tools, but this sounds like someone who didn't figure out a workflow which works for himself:

> Nothing indicates how this should be run.

That's why I usually ask it to write a well defined function or class, with type annotations and all that. I already know how to call it.

Also you can ask for calling examples.

> ... are not functions whose definitions are available within the script. Without external context, we don't know what they do.

Are already solved by having proper IDE or LSP.

> run in E environments with V versions

Fair enough, stick to "standard" libraries which don't change often. Use boring technology.

> The handler implicitly ignores arguments

Because you probably didn't specify how arguments are to be handled.

In general, AI is very helpful to reduce tedium in writing common pieces of logic.

In ideal world, programming languages and libraries are as expressive as natural language, and we don't need AI. We can marshal our thoughts into code as fast as we marshal it into english, and as succinctly.

But until that happens "AI" helps with tedious logic and looking up information. You will still have to confirm the code, so being at least a bit familiar with the stack is a good thing.

Given ollama has a openai compatible API[0], quick searching in repo returns this

https://github.com/alvinunreal/tmuxai/issues/6#issuecomment-...

1: https://ollama.com/blog/openai-compatibility

There was also coteditor, which is based on swift ui.

I wouldn't use LLM for serious refactors. It's actually the common "recipes" using popular libraries where LLM is most useful for me now.

1. You literally can't build something like Android studio emulator on the web.

2. Even if it's thinkable in last 4-5 years due to raising Popularity of web IDE, Android studio was built before that and they chose the IntelliJ platform.

3. Google also has flutter and go.