Forem: Lucca Sanwald

Using External Editors in Godot

Lucca Sanwald — Sat, 14 Mar 2026 19:51:55 +0000

Godot: v4.6.stable.official [89cea1439]

When using Godot with an external Editor, like JetBrains Rider, Godot asks you to confirm every file when re-focusing the Godot Editor.

If you'd like to silently accept these changes, there is useful setting to make that happen.

In Editor Settings -> Text Editor -> Behaviour.
Set Auto Reload Scripts on External Change to On

Note: This doesn't seem to silence the Dialog on scene (.tscn) file changes. Also the Editor documentation states that it still displays the Dialog in some edge-cases. But straight forward script changes now no-longer need to be confirmed. 🥳

Visualizing UV on a Polygon2D in Godot

Lucca Sanwald — Sun, 15 Feb 2026 11:53:49 +0000

Run on: Godot: v4.6.stable.official [89cea1439]

https://github.com/idkshite/fragment-shader-uv

I wanted to try out Shaders in Godot and struggled with getting UV values in my fragment shader on a Polygon2D. Here is how managed to get UV values in my Shader.

TLDR;

I could only see my shader displayed on the Polygon2D in my Editor after:

adding the shader as a material to the Polygon2D
adding a 1x1 px dummy texture to the Polygon2D
manually adding UV data to to the Polygon2D (maps polygon coordinates to 0->1 UV range

Step by Step

My setup is a simple 200x200 px square, created with a Polygon2D Node.
I wanted to visualize the UV.x value on that square by setting this Shader

shader_type canvas_item;

void fragment() {
   COLOR = vec4(UV.x, 0.0, 0.0, 1.0);
}

And as soon as I set that Shader as a Material on the Polygon2D node, the material-preview displays what I would expect the shader to look like. But in the editor preview the shader doesn't get applied.

Then I applied a 1x1 px png (created in figma) as the Texture of the Polygon2D. This seems make UV values available to the shader. Now we see a bright red square, which indicates that UV.x is 1.0. But that still not what I'd expect. I assumed the UV.x differs throughout the entire Polygon2D and isn't uniform.

Now the Data -> UV on my Polygon2D is still empty. So I have to fill it.
My assumption was, that I could do that with the the Polygon tab at the bottom of the Editor and then Edit -> "Copy Polygon to UV"
But that literally copies over the Polygon coordinates into the UV data. And UV data needs to be represented in a normalized format (0->1). So after copying the Polygon Coordinates I normalized the UV data by hand.

Adding UV coordinates and normalizing them by mapping each vertex from world coordinates to the 0→1 UV range.

That's it. Now the shader get's displayed. Hope this helps someone out there 🙌

Running Multiple Claude Code Sessions in Parallel with git worktree

Lucca Sanwald — Sun, 29 Jun 2025 19:12:50 +0000

One way to push the boundaries of Claude Code is to turn a single Claude into many Claudes! This theoretically allows you to do twice the work in the same time it would take to build a single feature.

But using multiple agents has (at least) one significant problem...

If both agents work on the same file, all hell breaks loose. They’ll overwrite each other’s edits and manipulate the other agent’s context.

How do you prevent agents from stepping on each other's toes?

You need a way to keep their workspaces separate, like putting them into separate rooms of an office to avoid disturbing each other.

We can create those separate spaces with git-worktree

Let's say I want to implement a small quality of life feature and work on another feature simultaneously.

How to use `git worktree`?

I navigate to my project folder.
cd /Users/lucca/Godot/mobsters
I create a separate project version with git worktree.
git worktree add ../mobsters-worktree/find-my-mobster -b feat/find-my-mobster
I create a separate terminal tab where I navigate to the new worktree folder.
cd ./../mobsters-worktree/find-my-mobster
I can now start a Claude Code session in the first and second tab and work on separate features. (running claude)
Once I'm done, I commit my changes to my repo and navigate back to my main worktree (/Users/lucca/Godot/mobsters) to remove the linked worktree with git worktree remove ../mobsters-worktree/find-my-mobster

To find your main worktree, use git worktree list

Why not duplicate the folder?

Duplicating your repository folder takes more space than creating a git-worktree "copy".
Git keeps your repository copies in sync. (e.g. fetches happen on all worktrees, git keeps you from checking out the same branch twice)

Caveats

Despite the appeal of this parallel working method, it hasn’t become my default yet.

Setting up worktrees takes time. Depending on the project, I have to copy over files that are not checked into version control or install dependencies. Often, it’s not worth it for a change Claude finishes in 10min.
Juggling multiple Claude sessions is like moderating two separate meetings in neighboring conference rooms - you're endlessly ping-ponging between rooms, keeping track of different discussions, and trying to give meaningful input to both groups without losing the thread of either conversation. The mental gymnastics of context switching not only wears me out but makes me wonder how well I'm steering each session. Especially if Claude regularly needs my input on both features. I can benefit from the parallel approach if one feature is long running and lets me focus on the other.
It sucks up tokens like a Dyson V15. This is so far the only way how I exceeded my Claude Pro Subscription Usage.

I'd love to hear about your experience using multiple agents and how you deal with the context switch.

Building an RTS in Godot. What if Claude writes ALL code?

Lucca Sanwald — Sun, 22 Jun 2025 20:22:16 +0000

Part 1: Building an RTS in Godot. What if Claude writes ALL code?

I challenged myself to build a game in Godot. I have a web-dev background but very little experience with Game Dev. I watched some tutorials, built tiny projects, but never finished a game to share it.

This is about to change. I'm creating a pixel art clone of the lesser-known Real Time Strategy game "Gangland". It wasn't well received by critics (after watching the trailer I understand why), but as a kid I really enjoyed this pixel mush. There was something captivating about curating your crew of mafiosi to take over the neighborhood with tommy guns and persuasion. I've deliberately decided to start by copying a game to avoid getting stuck in overthinking.

You know what else is exciting? Seeing your own ideas come to life in your own creation. But it takes time and frustration to do that. If you have a full-time job and other responsibilities, you need to find the time and energy to do that. And even then, there are hundreds of distractions that can keep you from working on ambitious projects. Then there is also the mighty force of "fear of failure" (disguised as "perfectionism") that keeps me from building something like this.

But what if we could avoid some of that time suck and frustration by handing it over to our good friend Claude? Then I could see my own ideas and past impressions come to life, even with my limited time.

Introducing my experiment: "What if Claude writes ALL code?" This means:

1. I use Claude Code for everything I’d typically write down by hand

I reach for this extreme measure because I hope I will find some exciting truths if I lean all the way into this direction.

The only exceptions are some game-design related markdown files. Claude needs a ground truth to work with and I can't risk the truth changing behind my back. So the game's rules and ideas are handwritten.

2. The brain rot is part of the experience

The experiment aims to find out if building the game solely with AI is possible and to learn another workflow on the side.

Will my brain rot or will I shift my skills from coding to thinking deeply about the game’s fun aspects?
Will solely working with agents exhaust or energize me?
How does context switching affect me?
How will I handle situations where Claude can't figure out the solution? What are the options?
Will Claude drift into spaghetti Code?
Will I learn anything about Game Development through osmosis or
How do I adjust my workflow for this new meta?

Preliminary Results

I'm roughly 8 hours into the project and I've already made some interesting discoveries about building with my fingers glued to the Claude console.

The Importance of Clear Context

LLMs are great at whipping out "something" that resembles your request. But whether the result matches my expectation or not seems to largely depend on how precise I phrase my request. Not a huge surprise here. But nevertheless, I see myself writing short unspecific prompts all the time. Sometimes because I'm lazy, but mostly because I assume Claude can get the rest from the surrounding files and subtext.

But when I have a specific solution in mind, I need to communicate it precisely. That's where manual context provision comes into play.

I've created a folder where I document the entire game idea in markdown files. This serves as a ground truth for Claude, so I don't have to repeat myself all the time, but also to keep the game coherent for both the AI and me.

This approach has already paid off. When I first started building the game, the context contained conflicting information about how the character can move. Because of this, Claudes first character controller implementation didn't allow the main character to move around freely on the map. But because I've documented the intended behavior in my markdown files, I could easily resolve this misconception by pointing Claude at the right files and rephrasing things slightly.

Claude Code also draws context from adjacent code files in your project. But if your code doesn’t accurately represent your vision, Claude may draw wrong conclusions. The markdown files help to resolve those ambiguities.

I'm not yet sure if it's a good idea to separate the markdown files into multiple files, but time will tell.

Pushing the limits of Claude Code

My main issue with the current approach is that I’m using Claude Code reactively. I request a neatly defined feature and Claude delivers a usable result in under 5 minutes. This fast feedback loop is great for getting a feel for the tool because, but it leaves me in an awkward position where working on anything else wouldn’t make sense because Claude could be done any second. I’m treating Claude like a quick-response coding assistant, but it could tackle larger, more complex tasks that take real time to complete.

We’ll explore Claude Code’s limits in the next part of this series!

I'll keep you updated on what I'm learning about the process of developing a game without manually typing any code. And as a bonus, you'll see how a crappy prototype turns into a (hopefully) fun game!

Postgres Views: The Hidden Security Gotcha in Supabase

Lucca Sanwald — Sun, 09 Mar 2025 21:19:45 +0000

When building with Supabase, Postgres Views can be a powerful tool for simplifying complex queries. But they come with a critical security consideration that isn't immediately obvious: Views bypass Row Level Security (RLS) by default, potentially exposing sensitive data even when your tables are properly secured.

As a reminder: RLS is what allows you to safely query your Supabase database directly from the frontend, without routing through your backend server. But if RLS isn't working on a table, that table is like your phone screen on public transport—anyone who wants to take a glance, can.

The Security Challenge

Even if you've carefully configured RLS policies on your tables, views can create an unintended backdoor because:

By default, views don’t use RLS
Supabase's RLS policies page doesn't show or warn about exposed views (last checked 09.03.2025)
Views don't support RLS in the same way tables do

Testing Your View's Security

Before deploying any view to production, it's crucial to verify that it properly respects your RLS policies. Here's a quick way to test if your view is secure:

// First, sign in as a specific user
// Then try to fetch ALL rows from your view
const { data } = await supabase.from('my_view').select('*')
// If your view respects RLS, you should only see rows this user has permission to access.
// If you see ALL rows, your view is bypassing RLS! 🚨
console.log("view response" ,data)

Securing Your Views

To protect your data, you have several options:

For Postgres 15+:

CREATE VIEW public.my_view
WITH (security_invoker = true) AS
SELECT * FROM my_table;

This applies the RLS of my_table to the view you’re creating.

For older Postgres versions:

Create an internal schema: CREATE SCHEMA internal;
Re-create the sensitive view in the internal schema
Delete the public version of the view

When to Use Views

Views are particularly valuable when you need to:

Simplify complex queries that you use frequently
Add computed columns that can't be generated columns
Create virtual tables that recalculate with each request

Example: Active Subscription Status

I recently built a subscription system and wanted to avoid having to write active_until > NOW() in every query where I'd need to check for active subscriptions. Planning ahead, I first considered adding an is_active generated column to the table. But I hit a wall: Postgres doesn't allow volatile functions like now() in generated columns. That's when I turned to views as a solution:

CREATE VIEW public.active_subscriptions
WITH (security_invoker = true) AS
SELECT 
    *,
    (active_until > now()) AS is_active
FROM 
    public.subscriptions;

This view has been working perfectly, giving me clean queries while maintaining security through security_invoker.

Poor man's visual regression testing

Lucca Sanwald — Wed, 22 Jun 2022 07:57:38 +0000

Let's assume you've made some big changes to some global css styles in your web application.
You're unsure whether these changes broke any of your meticulously crafted pages.

You could set up automatic visual regression testing on your CI pipeline with tools from the "Awesome Visual Regression Testing" list.
That would probably be the safest option. But it requires some setup and time to get used to the tools.

You don't have time for that right now? Then let me introduce you to...

Manual Regression Testing

The idea is: Take a screenshot from a known working state of your webapp. For example your production environment. Then take this screenshot and overlay it on top of your potentially broken state of your webapp.
In this example I'm using the chrome plugins

screenshot-capture - to get a screenshot into my clipboard
PerfectPixel - to overlay the screenshot on top of the development page

First I configured screenshot-capture to copy the screenshot into my clipboard and to use a different shortcut as the default one (OPTION + S) was already occupied by PerfectPixel.

screenshot-capture plugin configuration to copy into clipboard

Prepare your browser

Then I prepare my browser to have both (local and production environment) open in equal sized browser windows.
It's important those pages have the same viewport size as comparing differently sized images will just make the process more complicated.
This also means the devtools need to be closed during the screenshot and comparison.
If the screenshot doesn't have the same size as the viewport of your browser window, you would need to manually position the screenshot later.

Screenshot and compare

Next I take a screenshot of my production webapp running on https://idkshite.com (with OPTION + SHIFT + S).
This screenshot is now in my clipboard. I can switch to http://localhost:3000/ and open PerfectPixel to click on the paste from clipboard link.
Now the screenshot of the reference page (production environment) should sit on top of the viewport of your localhost browser window.
Feel free to play around with the opacity slider to get an impression of how those changes differ.
Or turn your screenshot into a negative with OPTION + i to get a stronger contrast.

🎥 Original post contains a Video available on idkshite.com

In the long run I would probably invest in some automated regression testing, but as a provisional arrangement it's way more reliable than just glancing over visual changes. 👨‍🎨

Debugging by talking to yourself

Lucca Sanwald — Mon, 20 Jun 2022 06:45:42 +0000

Sometimes I have to read code that I either didn't write myself or haven't looked at in a while.
This can be a daunting task.

Where do I start?
How do I prevent getting lost in details?
How do I keep track of all the fractions of code I've already looked at?
How can I learn as much as possible from my endeavour?
How can I finish this task as fast as possible?

If the code is somehow observable (like a User Interface) I would probably want to observe what the code actually does before understanding the code itself.
Afterwards I identify the files responsible for the interactions seen on screen,
and come up with hypotheses which code component is responsible for which observable interaction on the screen.
But before I've verified my first hypothesis I may already feel overwhelmed by following a logical and trying to understand all its possible outcomes.
This is where my favourite debugging technique comes into play.

✍️ Talking to yourself in notion

Instead of running through all these logical branches in my head,
I pick the one that seems most relevant to my problem and start writing down my thought process in my favourite note-taking app.
I prefer notion as it supports nesting collapsible text blocks which allows you to hide your nested lines of thought if they become less relevant.

🎥 Original post contains a Video available on idkshite.com

I start with a question and try to answer it by following my line of thought.
Then I move through the code line by line and write down what it does and how it affects what I see on the screen.

In this example I wanted to find out: "what happens if I click the publish button when creating a new article?" inside the React RealWorld App (GitHub)
If this process brings up new questions, I write them down and try to answer them in a collapsible text block. Sometimes I decide to postpone answering a question.
Then I mark this question with a "🤔" emoji, so I don't forget that I haven't answered it yet.
In this example I asked myself the question: "Why do we set state.submitting flag to true . Which part of the app code reacts to this state? "
I assumed this flag could trigger something relevant in the code, but it turned out it only disables the editor form.

Occasionally I skip following a line of thought and make assumptions about how the code works to progress faster. To make sure I don't forget what I skipped, I mark it with a "🙈" emoji.
In my example I assumed that <ArticleEditor disabled={true} .../> will disable the whole form inside ArticleEditor. Because this is not relevant for my problem at hand I can safely ignore it until it becomes relevant.

You may think this is a time-wasting process. Why not go through this in my head instead?
It may be true that it takes a bit longer to write down your thoughts, but it has some undeniable benefits over "keeping everything in my head"

If I get distracted I still know where to continue
By writing down what I've done, I always have a record of the approaches I've used to solve the underlying problem.
I see which part of he code I may have only checked superficially, and I can come back to if it becomes relevant.
You also know which questions you haven't answered yet. Did you make some hypothesis but never verified them and based your whole debugging process on it?

In the end there is no silver bullet, and I don't find this approach particularly helpful if the task at hand is manageable in size.
But when I feel overwhelmed by a Task this is my go-to approach to eat the elephant with small bites 🐘

Public and Private key cryptography

Lucca Sanwald — Fri, 17 Jun 2022 19:15:50 +0000

With the power of cryptography, you can turn perfectly readable content into incomprehensible garbage. Great for hiding your secret "guilty pleasure" playlist from prying eyes.
Encryption usually incorporates something you want to encrypt. Let's call it a message and a key that allows you to lock (or encrypt) and unlock (or decrypt) the message. The last ingredient is an encryption algorithm that uses your key to turn your message into something that doesn't resemble the original message anymore.

But the "one key opens one lock" system only works flawlessly if you don't need to share the key with anyone.
Because then, the question arises: How do you safely transfer the key to a trusted party? Send them an Email? A carrier pigeon? A letter? None of these options sounds terribly convenient or safe.

This is where public and private keys come into play.

TLDR;

Public and private keys can be used to hide the content of messages from strangers but expose them to trusted parties. They can also act as a way to verify the integrity of a message.

Encryption

Imagine instead of 1 key you know have 2 keys.

Your private key is your own little secret You never share it with anyone Your public key on the other hand should be openly shared.

Those 2 keys are created from the same function and are inherently connected. You can encrypt messages with your private key and decrypt them with your public key.

But wait? If everyone has your public key, anyone can decrypt your messages. This doesn't sound secure at all. But stick with me.

One can also encrypt a message with your public key and decrypt it with the matching private key.
It starts to make more sense if we introduce a second pair of keys for your friend. An example will shed light on this.

You want to send your "guilty pleasure playlist" to your friend Mathilda, but you are concerned by the thought that someone could read the playlist's content while it's being transmitted. To protect the message, you encrypt it with your friends public key. Now the message can only be decrypted with her private key. So only she can read it. Profit!

Interactive node.js message encryption

Verify message integrity

There is only one problem with this example. If someone interferes with the transmission between you and Mathilda, they can create a new message with Mathilda's public key and pretend it is coming from you. What if they add your least favourite song to the playlist? Mathilda will never talk to you again if she finds out you listen to Wham!(I hope you your friends aren't that judgemental)

But fortunately, your keys can also help you with this challenge.
You remember you're the only person with your private key? We can use this to our advantage and encrypt your playlist with your private key. This won't prevent anyone from reading it. But Mathilda can now be sure the message is coming from you because she can decrypt it with your public key. If this is not possible anymore, the message has been tampered with.

Interactive node.js message verification

There is also a way to combine those two methods to protect the message from prying eyes and verify message integrity. But this a story for another post in the future.

Further Reads

Public Key Cryptography - Computerphile
Explaining public-key cryptography to non-geeks

Reveal the hackerman with js getters and setters

Lucca Sanwald — Wed, 15 Jun 2022 18:59:22 +0000

In this example we're observing a realtime hack of your own video game.
Someone managed to sneak some code into your brand new "first-person-hack-and-slay-roguelite-moba" that gives players a pretty high level from the start. You dislike this new "feature" because it takes all the fun out of "the grind for earning xp".
So you sally forth to find the culprit inside your codebase.

You know that the hacker is somehow directly increasing the level property in your game. You just have to find out how exactly they increased it.

Emoji Parade

Just recently you've added a small widget to your game, that logs an "Emoji Parade" onto the screen.
You were quite satisfied with its look. But something tells you this code may do more than just logging an "Emoji Parade".
But how can you prove it? 🤔

▶️ Run the replit below to see the hack in action

Getter and Setters

JavaScript offers a way to control the assignment and retrieval of existing object properties.
You can use getters and settters to "do something" if someone directly accesses the property or assigns something to it.

To see how the level changes over time we replace the level property on the game with a set and get function.

function monkeyPatchLevelProperty(game, logTrace = false){

      log = logTrace ? console.trace : console.log; // ignore this. This is only relevant for the logs

      let _level = game.level;

      Object.defineProperty(game, 'level', {
      get: function() {
        log("level up 🔥",_level);
        return _level;
      },
        set: function(newLevel) {
         _level = newLevel;
        }
      });

      game.isMonkeyPatched = true; // ignore this. This is only relevant for the logs
  }

First we define a new variable where the level value can live let _level = game.level; and set it to the current value of game.level
Then Object.defineProperty allows us to change the level property to a getter and seter.

In the get function we're logging the current level if the game.level property gets accessed.
We then return the current value of our new _level variable so the code relying on it still behaves as expected.

In the set function we're only recreating the expected behaviour behind setting game.level except we're saving the value in _level instead of game.level

▶️ Open Replit and Uncomment // monkeyPatchLevelProperty(game); to see how the getter logs every time someone accessed game.level

▶️ Pass in true as a second parameter to monkeyPatchLevelProperty() and you'll see a stacktrace for each time game.level gets accessed

And this is how we reveal. The hacker is increasing the level +1 every 50ms on line 14 inside "/hack.js". 🥸

🎥 Original post contains a Video available on idkshite.com

Lodash memoize() | Learn how to cache return values with _.memoize()

Lucca Sanwald — Wed, 27 May 2020 17:43:27 +0000

Who should watch this video:

If you want to learn how and why to use the lodash memoize function to cache return values and increase your application performance.

Leave a comment with feedback to help me improve my content.

Lodash get() | Learn how to safely access values with Lodash _.get()

Lucca Sanwald — Wed, 20 May 2020 13:22:26 +0000

Who should watch this video:

If you want to learn how and why to use the lodash get function to access javascript object properties. Start at 00:43
If you want to learn how lodash get was implemented and take a look under the hood. Start at 06:42

Leave a comment with feedback or fill out my 3 Questions form to help me improve my content.

Debounced Aggregated (Buffered) Actions with RxJS 6 or How to stop making your users wait

Lucca Sanwald — Sat, 22 Jun 2019 16:36:47 +0000

TLDR;

Full Codesandbox Example

// (1) Add products on click
const AddProductSubject = new Subject(); 
const onClick = (event, product) => {
    AddProductSubject.next(product); 
};

// (2) Create debounce Observable as notifier for buffer
const debounceAddProduct$ = AddProductSubject.pipe(debounceTime(1500)); 

// (3) Buffer values until notifier emits a value
const AddProduct$ = AddProductSubject.pipe(
    buffer(debounceAddProduct$)
); 

// (4) Receive results
const AddProduct$Subscriber = AddProduct$.subscribe(result => {
    console.log("subscriber", result);
    saveSelection(); // triggers the loading screen
}, console.error);

What will I learn?

Sometimes, you don't want to react to a users input immediately and instead wait until he's finished multiple interactions before you save their progress. Find out how to buffer these interactions with RxJS 6.

How does it help?

This can make the difference between a tedious user experience. Where you're forced to wait for every single action to be completed. Demo

And a pleasant user experience. Where the application only saves if you have stopped making actions for a certain timespan. Demo

How does it work?

(1) Create a new Subject to be able to emit and receive values.
Push selected Products into the AddProductSubject whenever the onClick function is called. (in this case; whenever someone clicks on a product)

const AddProductSubject = new Subject(); 
const onClick = (event, product) => {
    AddProductSubject.next(product); 
};

(2) Create the debounceAddProduct$ Observable that only emits a value if no additional values have been added to the AddProductSubject for 1500ms.

const debounceAddProduct$ = AddProductSubject.pipe(debounceTime(1500));

(3) Create the AddProduct$ Observable, which buffers any emitted values until debounceAddProduct$ emits a value and therefore closes the buffer.

const AddProduct$ = AddProductSubject.pipe(
    buffer(debounceAddProduct$)
);

(4) Subscribe to the AddProduct$ Observable and receive the buffered values, whenever the user has stopped selecting products for at least 1500ms

const AddProduct$Subscriber = AddProduct$.subscribe(result => {
    console.log("subscriber", result);
    saveSelection(); // triggers the loading screen
}, console.error);

Any ideas on how to improve this post? Tell me! I'm always grateful for valuable feedback ;)

Forem: Lucca Sanwald

Using External Editors in Godot

Visualizing UV on a Polygon2D in Godot

TLDR;

Step by Step

Running Multiple Claude Code Sessions in Parallel with git worktree

How to use git worktree?

Why not duplicate the folder?

Caveats

Building an RTS in Godot. What if Claude writes ALL code?

Part 1: Building an RTS in Godot. What if Claude writes ALL code?

1. I use Claude Code for everything I’d typically write down by hand

2. The brain rot is part of the experience

Preliminary Results

The Importance of Clear Context

Pushing the limits of Claude Code

Postgres Views: The Hidden Security Gotcha in Supabase

The Security Challenge

Testing Your View's Security

Securing Your Views

When to Use Views

Example: Active Subscription Status

Poor man's visual regression testing

Manual Regression Testing

Prepare your browser

Screenshot and compare

Debugging by talking to yourself

✍️ Talking to yourself in notion

Public and Private key cryptography

TLDR;

Encryption

Interactive node.js message encryption

Verify message integrity

Interactive node.js message verification

Further Reads

Reveal the hackerman with js getters and setters

Emoji Parade

Getter and Setters

Lodash memoize() | Learn how to cache return values with _.memoize()

Lodash get() | Learn how to safely access values with Lodash _.get()

Debounced Aggregated (Buffered) Actions with RxJS 6 or How to stop making your users wait

TLDR;

What will I learn?

How does it help?

How does it work?

How to use `git worktree`?