While the title is quite obnoxious, the author is right.

I don't think that anyone would argue against standardizing training for any model on ways of invoking tools through specific output templates (with MCP being an extension of that). However, the question is what is the best way of having the model use those tools? There are 2 options

1 - Encode actual functionality during training, let the model figure out how to use available tools to do what it needs to. Latest Claude models are a good example of this, when editing files if it encounters issues with the under the hood tool, it will write a bash python command to edit the file

2 - Describe functionality in instruction context. This allows you to define complex sequences of things to do, but at the risk of the model losing context as the conversation continues.

3 - Use tool calling, where every request gets an available tools section appended to it, and define the complex functionality in the static code (whether its local tools or MCP servers)

Ideally, if we are pushing towards smarter models, the answer is between 1 and 2, where you have a model that only has access to be able to run shell commands, and some memory that it can reference on sequences of shell commands to run. An MCP invocation is then a simple echo jsonrpc pipe to local executable or a curl command. Eventually, its probably worthwhile to have your LLM run in a CPU like sandbox where it can execute arbitrary assembly commands from sequences stored in memory to do what it needs to do.

Until then, 2 and 3 are really what we have for adapting with current frameworks.

Structs are a defined type, which means its construction (and therefore total size) has to be known , the array definition with size is necessarily part of that struct type. So anytime that struct is used, the compiler needs to see its definition, and thus can safely infer the size. Thats pretty much the whole reason structs are a thing - the very basic type that allows you to pass around data format during the compilation process.

Arrays are not defined as types in C, they are really at most just syntax convenience. So if another function takes an array as a parameter, and it gets compiled as part of a file, there is no way for the compiler to auto infer what would get passed into it.

Char allocation usually involves +1 bytes for null terminated strings, which is used as a signal for allocated memory. So strlen(char *) is accurate.

>quite the contrary, it's a terrible practice for that. In particular, this is almost exactly the issue that caused the infamous HeartBleed vulnerability in OpenSSL to stay hidden for so long: the use of a memory pool for the buffers used to store TLS packets

The heartbleed vulnerability was not due to mempool. It was due to a combination of lack of bounds checking, and not zeroing out the memory containing secure keys when its deallocated. Even if it didn't use mempool, leaks would still be possible.

Nowdays, most video games are made for the lowest common denominator of people and targeted at consoles, so the mod scene is a fraction of what it used to be, you don't meet interesting people anymore in the gaming world. So no wonder Lan parties aren't a thing anymore.

No, if we are using the definition of an array that is like int c[] = ..., that is always going to be on the stack. Heap continuous memory =/= array. You can use the [] operator to access it like an array, but fundamentally, as far as structures in C language are concerned, those 2 are different, because they get treated by compiler differently.

>but the size is actually always stored and accessible, and this is virtually mandated by the standard: otherwise, `free(arr)` couldn't realistically work,

That would only be true if each element in the array was a char.

The dynamic data structure stores total amount of memory allocated by address, it has no info about the size of the element, so it can't infer the actual number of items at runtime. You could write your own malloc that does this, but generally, that is left to the user for flexibility. For example, a really good practice in C coding that basically solves any double free is a mempool that allocates all the memory up front. That way, you never really even have to call free, and the memory you allocate can be partitioned any way you chose dynamically.

Array memory is on the stack. The size of that array is actually not known at run time, its only known at compile time, where any reference to that length gets resolved by the compiled.

If your 2d array sits on the stack, then inferring memory layout is pretty easy. If you are dealing with pointer that was passed to a function, then you can't assume anything about data size or limits, which is why many functions that take pointers take a size parameter as well.

the 40-80 tok/sec is only for initial prompt processing, and with the "medium" models, like Qwen3.6:27b. The actual token generation is in the 10 token/second Thats very slow. And your Macbook pro will stop being a LAP-top, because it will get very warm.

Meanwhile, my 2x3090s happily crank out ~100 tok/sec generation. Oh and I can run 100 tok/sec on my phone as well, because I can just access ollama on my home desktop over ssh from termux.

https://www.youtube.com/watch?v=FkNkSQ42jg4. Watch this video and tell me if he speaks like an intelligent person.

b) Musk has made crazy amount of promises and predictions, none of which turned out to be true, and his history is full of dumb ideas and decisions. He literally drove a truck to the Twitter server location, and started ripping out servers, despite people telling him that it will break stuff, and then when it broke stuff, he was like oh, you are right. Is that indication of someone intelligent?

c) Intelligence is not separable by topic. There are no smart people that are conservatives. There are conservatives who remember a whole bunch of technical information and appear to be smart, but information recall is not intelligence. Being able to analyze reality and determine what is true is not is a core skill, and if you apply that to politics or social issues, you end up pretty much center left in terms of political spectrum. Musk is solely on the far right. Someone who is so convinced in his conspiracy theories absolutely does not have the mental machinery to correctly parse technical topics.

That money could have been spent on way more bang/buck performance in the form of a set of 4 graphics cards.

Also I would probably put the odds 70:30 that Apple marketing is astroturfing on HN from the amount of posts about running llms on Macbooks, because in reality, the inference speed of any decent llm is unusable on a Macbook despite the ability to fit it into RAM.

Ive been more excited for this https://www.kickstarter.com/projects/interrupt/ interrupt-linux-powered-hacking-gadget/description. I used to have a One Plus One with Nethunter. That was a lot more useful as a hacking device. The only issue is that it required external adapters for things like wifi deauth, ir remote, e.t.c. But the ability to customize things on the fly was way better, compared to Flipper which you really can't do.

A lot of people across all fields seem to operate in a mode of information lookup as intelligence. They have the memory of solving particular problems, and when faced with a new problem, they basically do a "nearest search" in their brain to find the most similar problem, and apply the same principles to it.

While that works for a large number of tasks this intelligence is not the same as reasoning.

Reasoning is the ability to discover new information that you haven't seen before (i.e growing a new branch on the knowledge tree instead of interpolating).

Think of it like filling a space on the floor of arbitrary shape with smaller arbitrary shapes, trying to fill as much space as possible.

With interpolation, your smaller shapes are medium size, each with a non rectangular shape. You may have a large library of them, but in the end, there are just certain floor spaces that you won't be able to fill fully.

Reasoning on the flip side is having access to very fine shape, and knowing the procedure of how to stack shapes depending on what shapes are next to it and whether you are on a boundary of the floor space or not. Using these rules, you can fill pretty much any floor space fully.

From all the interviews and stuff that came out within the past few years, its pretty clear that Musks only contribution to anything is just throwing money at stuff while also scamming suppliers, governments, and so on. The dude has no technical knowledge of his own, he just lies and lies about what actually happens, and takes credit for accomplishments that aren't his.

When you hear someone who is supposedly smart talk about a dumb person like he is smart, it raises questions on whether that person that is doing the talking is actually smart.

Nobody really knows the answer to which one is more optimal

* Large model trained on a large amount of data across multiple domains, that doesn't need any extra content to answer questions.

* Smaller model that is smart enough to go fetch extra relevant content, and then operate on essentially "reformatting" the context into an answer.

EXACTLY.

Apple is a fashion company. They don't care about improving usability of any of their devices. The most important thing is to them is selling a lifestyle.

This is why eGPU will never happen - having an external gpu is too nerdy for a lifestyle of an apple user. Same thing of having a phone plugged into a monitor and keyboard. Thats why all their products are separate. You are meant to buy a iphone for phone things, and iPad for the plane, a Macbook for work and a Mac Pro for any serious compute. Them trying to offer a cheaper solution like eGPU dilutes the lifestyle image.

The original question was

>"clean up" dropped databases, compromised computers or leaked personal data?

For each of those things, you can right now build an agent that handles all of that. Or use a large frontier model with enough context to build code that ensures all of those edge cases are handled.

Future coding will essentially be like this. The concepts of dynamic vs compiled language will shift towards having frontier edge models put together code versus small runtime edge models dynamically processing data.