aldanor

6.5B is only 200k H100 chips

"Attention Is All You Need", as they say...

The difference being, inference is not cheap at all.

So the actual problem here is to find Nash equilibrium.

Yea. It's like falling down the recursion with a stack size of 5. Do the task. Plan doing the task. Start planning doing the task. Plan starting planning doing the task...

How big is a "big group chat" in your definition?

It's perfectly fine for a few thousand people

For a work project, my recent cargo clean removed 90 GB.

There's also interesting projects for serverside scaling of vega plots - https://github.com/vega/vegafusion

The way I see it, one of the reasons is to "keep your cache empty", so to speak.

You find something potentially interesting and you don't leave a tab open for later, you don't try to remember it in case you'll need to recall it a week later, you have a reliable procedure dumping this information into cold storage, removing the mental burden from yourself. Retrieval of information from that storage and the efficiency of doing that is a separate question.

More like enterprise-level spyware

Mamba fully replaces anaconda and uses a sat solver in c++. IIRC, conda now uses libmamba under the hood as well. If you post a list of dependencies, I can time it on my box and post the timings here. (Not saying conda/mamba are best nor perfect but the last time I've seen 10m resolve times was a very long time ago)

That's why byte strings exist. You don't know the encoding? Well, it's a binary chunk and nothing else.

They say that modern LLMs have reached intelligence of older kids. Perhaps it's the other way around...

Memory safety and safety is not "the whole point of Rust". It's a nice low-level language with proper sum types (!), neat sum-type approach to errors, proper and easy to use iterators and much else including nice tooling, dep management, very high standards in packages and docs overall, etc.

C++ lacks in pretty much all of those, so memory-safety or no, personally I can't picture myself choosing to do C++ for low-level work at will these days. Unless it's too low-level like dpdk or gpu kernels.

> the language is incredibly hard to learn

Not really. A few months from zero and you'll be up and running, provided you have prior C++ experience (based on cases I've observed in teams I've worked in). Maybe not including async rust though.

> it's impossible to implement any non-trivial data structures in safe rust

ANY, really? Any examples? (Other than linked list or other self-dependent structures)

They were smart enough to invent a new term, Apple Intelligence. You know, AI

Arrow is columnar storage, nothing relevant here.

And capnproto is basically another version of pb... (see discussion above)

Sufficiently BSD-like :)

Yes, it doesn't have much to do with the rogue anymore (except a few games). These days, the meaning is along the lines of "the game consists of many repeating runs, each one being reasonably short like 0.5-1h, failure is normal, you will progress in many different ways both within each run and globally even if you fail, there will be a predominant effect of randomness, there may be some exploration effect".

Rogues likes are probably the best fit.

If Firefox natively integrated TreeStyle tab or Sidebery and made it lightning fast, searchable and syncable, I would probably return to FF on that day.

Definitely not yet another "reduction of visual clutter".

German, and Russian, and a few other languages...

Feel thoughts or think feelings?

Or, use sonic_rs::Value which uses simd and arena allocation for keys and in my case for big payloads was 8x faster than serds_json.

Or, use sonic_rs::LazyValue if you want to parse json on demand as you traverse it.

Use this silk material as a cover for bass traps? Win-win

Nice game! 49,600 after a few tries.

Agreed with the above though, I think it might be a bit more strategic if combos were awarded non-linearly,

(Although, again, the game is pretty good as it is)

And then you'd rather just write a plug-in for Obsidian?

I'd replace "similarly" with "fortunately"

It's not only about it looking 'nice' (although there's that component as well as an added bonus).

Once you've read tons of code formatted with the same formatter, passing the same linter rules and following the same general idiomatic rules, it becomes so much easier to read and review new code that adheres to all the same rules.

I think it's like like saying the problem with rock music is all those thousands of rock bands out there. After a while, you know what you like or dislike and what pieces to listen to that you might subjectively enjoy.

It's all relative. I've done my fair share of both C++ and Rust for over a decade and yet I can quite easily read Rust source code for both the Rust standard library and any 3rd party crate. In comparison, reading C++ std headers is complete pain, same as sources of many popular C++ libraries, due to them being overly generic in a C++ way.