I would have at least 100 stutters trying to say all that

I wondered how to create repeat mapped memory page...

fuck this song is a banger

Me mentioning that I saved a little extra money for emergencies My phone after the Google/Apple spyware heard that: 0:05

I feel enlightened. Actually I think this is what makes zig a great language, when compared to C. I think it encourages n+1 thinking because allocators are kind of annoying so you want to feel less annoyed. I do think there are a few places with singletons (maybe a map) where n+1 approach might not be appropriate, but in general a lot of things aren't singletons...

I had this on 2x speed because i watched the last video on it and i thought that was how the video was supposed to be lol

As a developer with 30+ years of experience I can clearly see why "grouped element thinking" is so important and how it relates to good data oriented design.

Would you look at all that stuff..... they've got allen wrenches, gerbil feeders, toilet seats, electric heaters Trash compactors, juice extractor, shower rods and water meters Walkie-talkies, copper wires safety goggles, radial tires BB pellets, rubber mallets, fans and dehumidifiers Picture hangers, paper cutters, waffle irons, window shutters Paint removers, window louvres, masking tape and plastic gutters Kitchen faucets, folding tables, weather stripping, jumper cables Hooks and tackle, grout and spackle, power foggers, spoons and ladles Pesticides for fumigation, high-performance lubrication Metal roofing, water proofing, multi-purpose insulation Air compressors, brass connectors, wrecking chisels, smoke detectors Tire guages, hamster cages, thermostats and bug deflectors Trailer hitch demagnetizers, automatic circumcisers Tennis rackets, angle brackets, Duracells and Energizers Soffit panels, circuit brakers, vacuum cleaners, coffee makers Calculators, generators, matching salt and pepper shakers

I was fully expecting heavy to get shocked at the mention of "automatic circumcisors"

In the context of a web application server (request/response based, everything kinda is self-contained and hierarchical), how would one go from n to n+1? (With specific examples).

Casey out here being the hoe_math of programming.

Good stuff. So much of getting better at programming is recognizing how your choice of system design is causing you to do more work than is actually needed. When you've come up with a design that's so simple and has so few failure points, it feels so good.

Here's a fun game! Count every item scout has spoke out

Heavy: Wow Scout, is impressive you know all that! Um…Scout? Scout take breath now! DOCTOR

They’ve got: Allen wrenches, gerbil feeders, toilet seats, electric heaters, trash compactors, juice extractors, shower rods and water meters, walkie talkies, copper wires, safety goggles, radial tires, bb pellets, rubber mallets, fans and dehumidifiers, picture hangers, paper cutters, waffle irons, window shutters, paint removers, window louvres, masking tape and plastic gutters, kitchen faucets, folding tables, weather stripping jumper cables, hooks and tackle, grout and spackle, power foggers, spoons and ladles, pesticide for fumigation, high performance lubrication, metal roofing, water proofing, multipurpose insulation, air compressors, brass connectors, wrecking chisels, smoke detectors, tire gauges, hamster cages, thermostats and bug deflectors, trailer hitch demagnetizers, automatic circumcisers, tennis rackets, ankle brackets, Duracells and energizers, soffit panels, vacuum cleaners, circuit breakers, coffee makers, calculators, generators, matching salt and pepper shakers 😂😂

Remember, when they go to Home Depot use Engineer’s phone number he has a discount

Scouts teeth don’t move…

Fire🔥✨🔥✨🔥✨

My dad when I ask if we can get ice cream on the way to Home Depot:

eminem been real quiet ever since this dropped

Isn't he basically talking about arena allocation at that point?

What was the best piece of programming advice then?

Just plain wrong that this kind of thinking applies to all programming. Imagine if every process running on a server pre-allocated the amount of memory its programmers thought it would need at its peak. This is a classic case of a Dunning-Kruger applying to everyone, even folks who are experts in one area.

The jury listing the crimes i committed after the Discord chat got leaked:

Damn I forgot he used c++ I thought he mostly used c i guess that was just for some time only

how did bro go from Scout TF2 singing Hardware Store by Weird Al to programming

Good video

I think there are still many situations where "N" programming is by far the simplest and best approach. Like if you are just parsing a JSON config file on startup... Just use std::string, which is RAII. You can get huge performance improvements if you write some bespoke memory-arena string routines if you need to parse a very large log file or something. But for many things, that kind of performance just doesn't matter. j_blow said something similar about optimizing the loading in Doom... At first he thought John Carmack was an idiot for writing such inefficient code. Then he realized that you wouldn't actually gain anything by optimizing it, so Carmack did the right thing by keeping the code simple.

here for the bedhead

When someone taps my shoulder chip that makes me list everything in the hardware store:

Allocation in advance is definitely preferable and sometimes it is required (like for example in some embedded systems) - but it might be tricky when you write program driven by external data. You don't know in advance resource requirements - for example how much would you need extra memory to parse incoming JSON object? I think we might consider multistage processing - for example some preliminary parser with fixed overhead do preliminary processing and determines requirements for later stages.

Agree - pools might be extremely effective. I with Java had some ability to create pools (thread heaps?) for objects. For example it might have been very helpful for processing requests in HTTP servers.

“The hello kitty girl can’t be that bad” What the hello kitty girl is gonna use

SCOUT VS EMINEM!!!! WHO WINS!

360p Looks better

Why do people think memory arenas are something new, or associate them with some person in particular? The first time I heard about something like that, was in the Abuse game engine, released in 1997. It's basically a Lisp interpreter, but instead of doing GC, it just clears all non global variables after each frame (or something like that, I don't remember the exact details). There's also a similar pattern in Forth, in which you save the current pointer to the dictionary, create temporary definitions, and reset the pointer back to that point when you are done (I don't know for how long it's been in use, but Forth is pretty old).

I really don't like this Casey Muratory guy. There are much better, humbler and better teacher programmers out there you can listen to.

now do it in 8k

not gonna lie, I liked this video a lot

Or "How I learned to stop worrying and love coding in Rust". Ownership and lifetimes are not a constant concern when the language supports them out of the box.

I really like this content, more like this plz!

I dislike the rant about checking allocations. No one really does that. No one handles std::bad_alloc in C++ and Rust simply panics (exits the program with an error), if *any* allocations fail, so there isn't even a way to handle an allocation failure. Modern operation systems overcommit and page to disk, so there is almost never a way to have an allocation fail, except if you have limits somehow (like in a container) or you try to allocate a gigantic block of memory in one go. Exceptions suck, but they are so popular not because allocations may fail, but many other non-games software just has a lot more code that can fail. Pretty much *everything* is IO of some sort (mostly network, sometimes disk). Games usually do not work that way. I think that shows that Casey lacks a lot of perspective regarding software outside of games and frankly most existing large software projects. His opinion makes sense given his background, but with a different background the N mindset does make sense not just as an intermediate step.

He says it applies to everything, it is very specific to video games and he is privileged to not have to work with herds of people that aren't that good at programming. Most of my time writing code is making sure it cannot be misused and there is no way to use it incorrectly. I worked in telecommunications and sadly, as with most software jobs, most coworkers are incompetent. If you write code that does as little as possible and is super fast, but is effectively broken after only a few other people have touched it, phone networks can go down and you might get woken up in the night or lawsuits might happen. Most software that is used is written by dozens of people, many of which are simply too dangerous to be trusted with code that breaks easily.

This guy is better at articulating everything I've been trying to say in the past decade and I don't seriously consider myself a lower-level dev. The same applies to all software development.

Funnily, the n stage was a huge wall to me. There were so many tiny things working together that I couldn't visualize it, and thus couldn't understand it and it felt extremely demoralizing and like I was too dumb for programming. Only when I ditched trying to understand that stuff and go about it other ways (largely inspired by Casey's handmade hero and other talks about programming), it all started to click and make far more sense, because I could finally visualize what is supposed to happen. Whether I'm at the n+1 stage currently... I don't know. There is probably some of the n stuff in there while prototyping a feature just because it's quicker to check if it even works.

I feel like this issue is overblown in general. I still try to convince every programmer I meet that they really don't need memory allocations/the heap at all for 95% of their objects. Yes since I'm looking at this from the embedded world I am very biased. But frankly most things that I have to put on the heap are data containers (string, vector, map, set, ....). These need to dynamically change size so yeah they must go on the heap unless you have a definitive max size. The only other times something goes on the heap with a smart pointer is when it needs to cross thread boundaries. A conrete example was a large data structure (>150 KiB) that is produced in thread A and processed in thread B. I can just call unique_ptr's swap instead of having to copy the data from A's stack to B's stack.

Yes, more efficient. All dynamic memory allocation is expensive. If you can do it all static, it's better. Good luck doing everything static in a complex GUI, though. I was an assembly programmer long ago, and that gave me the ability to write way more performant code than most coders, and still does. However, it just all depends on the problem.. For me, as an assembly programmer, it was hard to understand how dynamic web pages are served. .. And never forget: premature optimization is the root of all evil.

Did he really say any memory from the OS is zero by default unless you are on an embedded system? Oh have seen that error made before! That's how you end up with code that runs on every computer BUT the one you want to run it on.

This is one of the worst takes I've heard in a while. It completely glosses over what your problem domain is, and that not all problems are amenable to the types of groupings we're talking about. This is especially true for programs where multiple things reference the same allocated structure, where it's not possible to statically reason about what may go out of scope if a part of the structure is removed. That actually hinders reuse, not helps it. The fact that reasoning at the element level is also *crucial*. It's the backbone of functional programming, and by forcing reasoning at a more holistic level you set yourself up for failure if your application changes direction, makes it easier to make mistakes about what you think your application will require, and ultimately complicates your overall architecture, all for the benefit of simplifying allocation specifically. This is really the crux to me: It is good to not have to think about allocations. They are a distraction from making code *correct*, and that is usually more important than performance. I also disagree on the argument that this reduces failure greatly. It does reduce the *points* of failure, but they're all homogeneous. Your 1000 allocations of 1kb will fail as often (actually slightly less often depending of paging) to your 1 allocation of 1mb. Even your case of 'literally not failing' is a failure case.

I can see this type of thinking being a god send in C where keeping track of many small allocations is quite difficult, however in Rust it really doesn't seem to be an issue whatsoever after adjusting to the initial friction of the borrow checker. Of course this style of allocation is still useful for large applications that need large chunks of memory to be reused frequently across different parts of the application but for average use cases of I/O when you already have the borrow checker to handle the "little" pieces the extra overhead of implementing a large allocator seems unnecessary. As much as I love performance and efficiency I think it's good to have the application in mind, if implementing a more sophisticated architecture will net negligible gains only noticeable by nanoseconds then it seems more reasonable to opt for a simpler design. My main point is that I find what he is saying to be useful but not for all use cases and applications as is insinuated.