thanks man

at 1:02:20 ish, what does "[buying the] AV" refer to? Audio-Visual? Meaning "high quality/AAA (sound) effects/spectacle" etc.?

59:30 That depends on what kind of mods we are talking about. If it's e.g. adding another mob AI, then I would argue that doing it via a text based scripting language is easier. If it's a different level/map, sure, a visual scripting language should be easier.

Here's one thing people should not forget: The programs Rust considers "safe" is the union of a subset of all unsafe programs (yes, you can write e.g. segfaults entirely in safe Rust) and of a subset of all safe programs. This means that only because a program is safe, it doesn't mean that Rust accepts it as safe. But at least it's very likely (although not a guarantee) that if Rust accepts it, the program is memory safe (but not necessarily safe, because that question includes logic).

I'll admit I didn't like him when I first saw clips of him but my opinion changed once I started listening to him... wise guy with a no nonsense attitude

thank you

I did try state machine based lexer and it ran 2x slower than normal lexer with a bunch of switches and ifs. The entire entire state machine loop was 32 lines of assembly, but still it was way slower. I think that sean's state transition design is slower that regular, the real fast lexer might need to use 16 bytes simd to try beating the regular-style lexer.

Mod have to shif w please

10:40 a system of rules express what the game is about 17:27 interpretation of Moriarty's lecture (which is key for understanding The Witness) 29:00 the gist of meaning of Braid is understanding how the rules change from world to world

This looks like what is called 'polymorphism a la carte'.

This is a fantastic explanation but I wish he would stop talking about cheesecake and eating cheesecake. I’m trying to lose weight over here

I guess that in 2 years we will get access to Jai.

i dont understand how you have a position against writing unit tests and then in the course of this stream ive seen at least 3 major bugs that could have been fixed had unit tests been written before you started relying on the shader reload system and glsl code

I would really love to see a design talk with Daniel Benmergui as well. One day maybe...🙏📿

Do you think someone of similar IQ to you could learn programming and become as good as it as you are despite missing out in their formative years?

rare "pre-bald" jonathan blow clip

Thank you. Do you have and book recommendations so that i can expand mi knowledge of these concepts?

Hi Johnathan, hope you’re doing well! I recently came across your KZbin channel, although I’ve known of you for a while. I’m glad to have discovered your work! Thank you for sharing some of your wisdom on balancing life during sad times. You’re a fantastic creator-thank you!

Some of the best content out there. Recently I was writing my parser, and Pratt parsing seemed like the best way, but I ended up just writing a non-recursive shift-reduce parser. It's still Pratt-inspired, I guess

Good discussion!

1:15:05 I like that he's not pulling any punches. I have very specific and unpleasant experiences with this kind of stuff that we were sort of pushed towards and encouraged to do in college, gamification and 'educational games' being regarded as the sort of holy grail of what you could achieve as a designer. I had to sort of softly oppose this but nobody else in the class really seemed to understand why I hate it so much.

Waiting for open beta

System design 😂

Summary of the conversation for those short on time. Here are the main techniques mentioned in the talk, along with explanations for each: ### 1. **Observing Thoughts from a Distance** The first technique involves learning to observe your thoughts as if from a distance, rather than identifying closely with them. In everyday life, people often become fully absorbed in their thoughts, reacting immediately to whatever they think. This technique encourages separating your awareness from your thoughts, viewing them as small and transient parts of your experience. By practicing this, you create a mental space where thoughts can pass without triggering an automatic emotional or behavioral response. By detaching from thoughts, you build the ability to observe negative or intrusive thoughts without letting them take over your emotional state. You’re encouraged to recognize that thoughts, no matter how powerful they seem, are just one small part of your overall experience. This practice allows you to develop the strength to react less to thoughts, leading to a calmer, more reflective mental state. ### 2. **Understanding and Observing Physical Sensations** This technique focuses on the observation of bodily sensations without interpretation or judgment. The idea is to notice how physical sensations, such as pain or discomfort, are often neutral at their core. The mind tends to amplify these sensations, interpreting them as negative or unbearable. By focusing attention on the sensation itself-whether it's the pressure of sitting in a chair or the feeling of hunger-you can begin to see through the layers of interpretation imposed by the mind. The speaker points out that this exercise works particularly well for strong physical sensations like pain, which can often feel overwhelming. By focusing on the raw sensations, you’ll notice that they are more neutral than expected. Over time, this helps in reducing the mind’s automatic amplification of discomfort, making it easier to remain calm during challenging situations. ### 3. **Neutral Observation of Emotional States** This technique encourages observing emotional states, such as sadness or anger, without trying to change them. Similar to how bodily sensations can be observed neutrally, emotions can be viewed from a distance. When you place your attention on an emotion without trying to resist or amplify it, you may find that the emotion fades away. The speaker explains that emotions are like fire-they require constant fuel, often in the form of negative thoughts or physical discomfort, to keep going. By observing emotions in a calm, neutral way, you allow them to dissipate naturally. This practice helps you realize that emotions don’t need to control you. Even strong emotions can lose their intensity when observed without judgment. Over time, this technique strengthens your emotional resilience, allowing you to face difficult emotional states without being overwhelmed. ### 4. **Breaking the Self-Sustaining Cycle of Thoughts, Sensations, and Emotions** The fourth technique involves understanding how negative thoughts, bodily sensations, and emotions feed into one another to create a self-sustaining cycle of negativity. For example, a negative thought can trigger uncomfortable sensations, which in turn heighten emotional distress, which then leads to more negative thoughts. By becoming aware of how this cycle works, you can intervene at any point-whether it’s by observing your thoughts, tuning into your sensations, or calming your emotions. Breaking this cycle requires you to practice awareness of one or more components. For instance, when feeling overwhelmed, start by observing your body’s sensations (such as tightness or tension), which may be driving your emotional state. By addressing one aspect, like physical discomfort, you can weaken the entire cycle. Over time, this leads to a more balanced and controlled emotional and mental state, as each of these elements becomes less overwhelming when viewed separately. ### 5. **Recognizing Amplification by the Mind** This technique focuses on recognizing how the mind tends to amplify certain feelings and sensations. For example, a slight feeling of hunger or physical discomfort can be magnified into a full-body experience of frustration or anger. The speaker encourages questioning the mind’s exaggerations by diving deeper into the raw sensations or emotions, and recognizing when your mind is amplifying a minor sensation into a major emotional response. By frequently practicing this, you’ll begin to see how much of what you experience is a mental construction, rather than an inherent truth. This recognition can dramatically reduce the intensity of your negative experiences, giving you more control over your reactions to everyday discomforts and frustrations.

28:28 Jon doesn’t think techno music is real music

Design, design, feed me design

i just got here from Gamelab2018 Conference video. Mr Blow said back then that 80k LoC of the new game is written in Jai, and it compiles fast, and compiles to win, lin, macOS with a single line for each platform. I thought it will be ready by now. So, what went wrong and when?

Living in cold climate taught me that feeling cold is not actually painful(up to a certain point), so it is not to be "feared" as usual. Though that works only when you have energy, when youre feeling sleepy, cold cannot be resisted mentaly

„You go to Klaus Schwab and ask ‚Should I eat this‘. And if he says yes then it’s a bug“ 😂

PUT. IN. ON. GOG. 🙂

30minutes in and I see your point. As someone slowly building up knowledge over the last year, I found out about arenas not because some thing told me that there's a problem with the pointer lifetime, but because I was interested in memory management itself. As a result, I've found out about this system which isn't new and has been around and documented for quite some time. The interesting thing about this speech is that it's using it to solve pointer issues, when as you've said this is a mem alloc which can solve more lifetime issues and reduce alloc/free times in code.

Two steps, ahead. I am always, Two steps ahead.

It's now 10 Years Would Take Odin-Lang into consideration for Games?

The correction he made at 23:43 is deeply satisfying

I've been waiting so long for Jai to be released...

de-overfitting be upon ye, and all

im waiting sn 2022-2023 so maybe i can have a betakey(300 key -> 700 beta key increasment). (=

add to watch later

Happy 10 year anniversary of this classic

Hey man, this is a video from 7 years ago, so this won't get seen or get traction but I really appreciate this video. This stuff is not talked about. Nobody wants to sit in front of a computer, some of us just happen to be somewhat skilled in this area so that's what we'll do. It's a thankless and unappreciated life. Again, simply hearing you speak about it helps, it doesn't matter if you felt that it's hard to explain what you say, I feel what you mean to say. A lot of us don't want to acknowledge being depressed, we just feel we're bearing a burden that others don't care or think about. It's hard man. Thanks for speaking about it, it makes a difference.

Distributing just a compiler binary could be really beneficial for the language. Likely no headache of pollution or source code management as you talk about while letting a lot of people get hands-on with the language so it doesn't lose traction.

I just finished watching his first argument around 19:00. Another idea I would have is to provide an OnDeleteEntity event that could be passed through an event system. Other entities could check if they have a reference to that entity and even run specific code after remove all references of that entity from their data. Also, if the entity that is being deleted gets the OnDeleteEntity event, it can call its final deletion code. Of course, you would just need to be mindful of the order entities receive the event. I know this is not a solution for all potential pointer dereference situations, however, it could solve this issue without required numerous runtime checks with weak_ptr's and whatnot

This guy feels like a mix between Andrew Tate and Sheldon Cooper

Does anyone know what font he uses in the engine? It looks really nice.

This is a really good video. I've never heard about these techniques before. John calls them not scientific, but I guess that's because they're not researched well enough? The fact is that these exercises are easily explained, easy to reproduce and seem to (at least in my case) lead to similar outcomes. If you can repeat ideas, they're scientific enough for me. I do think that they're not the full solution to the puzzle. I still believe that I have personal issues that I will discuss with a professional psychologist, because I don't know myself how to deal with them efficiently. But these exercises definitely help me with managing the day to day life way better and so that I can focus more on enjoying the time with my loved ones, instead of moping around basically.

I am hoping someone with more exprience than me will find this comment and help me understand using entity IDs. Here is my question: Jon describes how the witness uses an integer pointer for its entity ID, which how I had my entities set up in my previous game. This seems fine, because I was writing a puzzle game, so at the start of each level I had a memory arena that would store the scene-specific lifetime allocations, one of which happened to be the array of entities. In my puzzle rules, entities could never be destroyed or created (but could be turned off temporarily), so having an array be allocated to the arena and then having the arena be "freed" at the end of the scene was no problem. For this, an array index of the entity was a good enough way to represent an entity. However, I am now working on a larger project which is a strategy roguelike. In it, I will have entities that can potentially be destroyed permanently, and entities that can be created dynamically. I can still represent an entity as an integer ID into an array, and just allocate the array with some MAX_ENTITIES value (like 1<<16 for example), and be sure that I will never run into the edge of my memory unless the player spends an unfathomable amount of time killing and respawning entities in the same level. However, the problem I see with this approach is that entities that die early on in the lifetime of the arena will now occupy memory that cannot be reused (if I reuse it, other entities that might have been referencing that index (via an entity ID) for any reason, will now be referencing the wrong entity. The solution in the video is to use a generational index, which is incremented whenever the entity space gets reused. Jon seems to dismiss this idea, because he claims that it does not solve the problem, since the programmer still has to check the generational index and handle the case of a mismatch, which destroys the advantage of using a raw pointer, since the bug will still exist, but will just have a different symptom (memory error vs accessing the wrong entity values). My question is: isn't using a generational index the only real solution in the case where entities need to be reused? How is it possible to reuse entities if all you use to identify them is an integer ID? With just an integer ID you have no idea if the entity at that ID is the same entity you want or a different entity that has been newly allocated to that ID. The only solution then is to never reuse ID until the lifetime of the memory arena has expired, and you free the entire arena. Am I missing something obvious here?

Why are you in the backrooms 🙀

"Staus Quo Bias". Truer words rarely if ever spoken!

I don't know what the upcoming video post 3:00 mark is going to be about, but so far everything you said about maintaining your drive with things you know you want to do and are completely capable of resonates all too deeply. I've had the exact same thing happen with game development and other ambitious pursuits and have happened on my own solutions that work a lot of the time, but I'm looking forward to hearing what you've found works.

Wow! I think rive app literally made a whole company around this simple idea, a binary file format that encodes animations(and some other stuff)