redman25

The point is the language forces you to explicitly handle the null. You have to make the choice. Using `expect`, the programmer would understand that that is equivalent to a panic. Why would they intentionally panic?

Crazy, they could call it the "internet" or something like that... kind of rolls off the tongue.

That's true typed languages seem to handle the slop better. One thing I've noticed specifically with rust is that agents tend to overcomplicate things though. They tend to start digging into the gnarlier bits of the language much quicker than they probably need to.

Not the parent but I would say bad defaults or naming. There are countless posts from newbies wondering why a model doesn’t work as well as it should.

It’s usually either because the context size is set very low by default or they didn’t realize that they weren’t running the full model (ollama uses the distilled version in place of the full version but names it after the full version).

There’s also been some controversy over not giving proper credit to llama.cpp which ollama is/was a wrapper around.

It may not have been intentionally misleading. Some benchmarks can take a lot of horsepower and time to run. Their preparation for release likely was done well in advance of the model release before the new deepseek r1 model had even been available to test.

The majority of successful attacks are business email compromise. In that context take9 makes sense in my mind because there _is_ responsibility for users to be mindful of clicks.

Not every phishing email can be caught before it reaches users and campaigns to raise user awareness I think are important.

Gemma-3-12b-qat https://huggingface.co/google/gemma-3-12b-it-qat-q4_0-gguf

Qwen_Qwen3-14B-IQ4_XS.gguf https://huggingface.co/bartowski/Qwen_Qwen3-14B-GGUF

Gemma3 is a good conversationalist but tends to hallucinate. Qwen3 is very smart but also very stubborn (not very steerable).

They can if they've been post trained on what they know and don't know. The LLM can first been given questions to test its knowledge and if the model returns a wrong answer, it can be given a new training example with an "I don't know" response.

It's not that simple how would the model know when it knows? Removing hallucination has to be a post-training thing because you need to test the model against what it actually knows first in order to provide training examples of what it knows and doesn't know and how to respond in those circumstances.

I think only 2/3 of ram is allocated to be available to the gpu, so like 14gb which is probably not enough to run even Q4 quant.

You could always run your own server locally if you have a decent gpu. Some of the smaller LLMs are getting pretty good.

I spent a couple weekends trying to reimplement microsoft's inferencing for phi4 multimodal in rust. I had zero experience messing with ONNX before. Claude produced a believably good first pass but it ended up being too much work in the end and I've put it down for the moment.

I spent a lot of time fixing Claude's misunderstanding of the `ort` library, mainly because of Claude's knowledge cutoff. In the end, the draft just wasn't complete enough to get working without diving in really deep. I also kind of learned that ONNX probably isn't the best way to approach these things anymore. Most of the mindshare is around the python code and torch apis.

Doesn't 8B need at least 16gb of ram? Otherwise, your swapping I would imagine...

Not the exact same comparison but I have an M1 mac with 16gb ram and can get about 10 t/s with a 3B model. The same model on my 3060ti gets more than 100 t/s.

Needless to say, ram isn't everything.

Minneapolis, Chicago, a lot of less temperate cities have protected walking tunnels, either underground or protected by buildings.

I do web dev and prefer safari. It’s less power hungry on a laptop. If you develop for the lowest common denominator, every other browser just works.

There’s something to be said for adding _less_ features to web browsers. A simple web is a web where open source solutions can compete with chrome. It helps avoid a browser monoculture.

What is the metric for LLMs? Shouldn't more than just accuracy be measured? If something has high accuracy but low recall, won't it be overfit and fail to generalize? Your metrics would give you false confidence in how effective your model is. Just wondering because the announcement only seems to mention accuracy.

If you consider that evolution has taken millions of years to produce intelligent humans--that LLM training completed in a manner of months can produce parrots of humans is impressive by itself. Talking with the parrot is almost indistinguishable from talking with a real human.

As far as pattern matching, the difference I see from humans is consciousness. That's probably the main area yet to be solved. All of our current models are static.

Some ideas for where that might be headed:

- Maybe all it takes is to allow an LLM to continuously talk with itself much like how humans have "the milk man's voice".

- Maybe we might need to allow LLMs to update their own weights but that would also require an "objective" which might be hard to encode.

Why does AI have to be smarter than the collective of hummanity in order to be considered intelligent? It seems like we keep raising the bar on what intelligence means ¯\_(ツ)_/¯

Ah, so this is a failure on nintendo's part for not protecting their email domain properly.

I had no idea spoofing email sender was so easy. Does anyone know of a good way to defend against this? I've always taken it for granted that if the sender was a domain that I trusted that I could trust the email itself.

I agree, class syntax is better. If javascript had been designed today, I imagine that would be the _only_ way to blueprint objects.

I know that a lot of people advocate for composition over inheritance. Inheritance can add a lot of complexity especially if it is deep or involves a lot of overrides. It can be difficult to find out where a method came from inside the inheritance chain or if it has been overridden and consequently how it will behave.

Composition at least makes things a little more obvious where methods are getting their functionality. It also has other benefits in terms of making objects easier to mock.

Complexity in javascript is probably more like the fact that there are three different ways of constructing classes. Async/await has it's own pitfalls but at least it is adding new functionality.

If you are trying overly hard to abstract things or work against that language, then yes, things can be difficult to refactor. Here's a few things I've found:

- Generics

- Too much Send + Sync

- Trying too hard to avoid cloning

- Writing code in an object oriented way instead of a data oriented way

Most of these have to do with optimizing too early. It's better to leave the more complex stuff to library authors or wait until your data model has settled.

Before switching to neovim, I used a split terminal with vim in one split and the other split for running `rg`, `make`, tests, etc. It's amazing what you can achieve with grep especially if you use something like ctrl+p in vim which can use ripgrep for fuzzy finding.

Vim land seems much larger than I expected.

I wonder if the sparse model would perform worse on out of sample test data.

One solution for performance degradation with soft deletes is to partition the table by some field like `created` monthly. Queries will need to include `created` in the query is the main downside.

Rust isn’t too bad if you throw clones everywhere. Otherwise, you might as well use a garbage collected language.