more major posts.

2026-08-25 16:10:57 -04:00
1 parent ab5e01c7b6
commit a5ffa9fb16
@@ -0,0 +1,37 @@
+---
+title: "@cmuratori The answers to OP : install a plugin on  top of VS to make it work !"
+type: archive
+source: twitter
+source_url: "https://x.com/0xlac/status/1691197452387287041"
+author: "antony"
+handle: 0xlac
+post_id: "1691197452387287041"
+date: 2023-08-14
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori The answers to OP : install a plugin on  top of VS to make it work !"
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/0xlac/status/1691197452387287041
+- Author: antony (@0xlac)
+- Posted: 2023-08-14 21:17:48
+
+## Branch
+
+**1/** @0xlac
+
+@cmuratori
+
+The answers to OP : install a plugin on  top of VS to make it work !
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,38 @@
+---
+title: "@cmuratori It can't even Ctrl+A after some update a few monhts before, just the 2022 (VS2019 also got updates but didnot break like this)."
+type: archive
+source: twitter
+source_url: "https://x.com/KDmitriy99/status/1691218906000629760"
+author: "Karbovskiy Dmitriy"
+handle: KDmitriy99
+post_id: "1691218906000629760"
+date: 2023-08-14
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori It can't even Ctrl+A after some update a few monhts before, just the 2022 (VS2019 also got updates but didnot break like this)."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/KDmitriy99/status/1691218906000629760
+- Author: Karbovskiy Dmitriy (@KDmitriy99)
+- Posted: 2023-08-14 22:43:03
+
+## Branch
+
+**1/** @KDmitriy99
+
+@cmuratori
+
+It can't even Ctrl+A after some update a few monhts before, just the 2022 (VS2019 also got updates but didnot break like this).
+I swear they do this on purpose. There is no way that in the whole multi-gb product they just happened to disable Ctrl+A. There is no way.
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,38 @@
+---
+title: "@cmuratori Funny enough when you write OOP, language design makes you think that you write less code by using virtual methods."
+type: archive
+source: twitter
+source_url: "https://x.com/Saniell_/status/1691193028046733312"
+author: "Alex Hollow"
+handle: Saniell_
+post_id: "1691193028046733312"
+date: 2023-08-14
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori Funny enough when you write OOP, language design makes you think that you write less code by using virtual methods."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/Saniell_/status/1691193028046733312
+- Author: Alex Hollow (@Saniell_)
+- Posted: 2023-08-14 21:00:13
+
+## Branch
+
+**1/** @Saniell_
+
+@cmuratori
+
+Funny enough when you write OOP, language design makes you think that you write less code by using virtual methods.
+Since those are in different files, individual files are small and nice to human brain. Especially compared to "dirty" switches
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,37 @@
+---
+title: "@cmuratori Not to mention how modern software shamelessly assumes the available resources, Many people still use low end laptops and the performance of most modern IDE/code editors are so sluggish and ultimately hurts the life of these machines more."
+type: archive
+source: twitter
+source_url: "https://x.com/TanishqSingla_/status/1691205716722561027"
+author: "Tanishq 📟"
+handle: TanishqSingla_
+post_id: "1691205716722561027"
+date: 2023-08-14
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori Not to mention how modern software shamelessly assumes the available resources, Many people still use low end laptops and the performance of most modern IDE/code editors are so sluggish and ultimately hurts the life of these machines more."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/TanishqSingla_/status/1691205716722561027
+- Author: Tanishq 📟 (@TanishqSingla_)
+- Posted: 2023-08-14 21:50:38
+
+## Branch
+
+**1/** @TanishqSingla_
+
+@cmuratori
+
+Not to mention how modern software shamelessly assumes the available resources, Many people still use low end laptops and the performance of most modern IDE/code editors are so sluggish and ultimately hurts the life of these machines more.
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,39 @@
+---
+title: "@cmuratori Just today, in VS 2022, the semantic analyzer crashed on me."
+type: archive
+source: twitter
+source_url: "https://x.com/TheBuzzSaw/status/1691222152853491714"
+author: "TheBuzzSaw"
+handle: TheBuzzSaw
+post_id: "1691222152853491714"
+date: 2023-08-14
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori Just today, in VS 2022, the semantic analyzer crashed on me."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/TheBuzzSaw/status/1691222152853491714
+- Author: TheBuzzSaw (@TheBuzzSaw)
+- Posted: 2023-08-14 22:55:57
+
+## Branch
+
+**1/** @TheBuzzSaw
+
+@cmuratori
+
+Just today, in VS 2022, the semantic analyzer crashed on me.
+
+My code is too powerful.
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,37 @@
+---
+title: "@cmuratori This is the best metaphor (not ironically also about Microsoft) https://x.com/ocornut/status/1691052987605467137?s=20"
+type: archive
+source: twitter
+source_url: "https://x.com/dmitriid/status/1691192339186782208"
+author: "Dmitrii"
+handle: dmitriid
+post_id: "1691192339186782208"
+date: 2023-08-14
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori This is the best metaphor (not ironically also about Microsoft) https://x.com/ocornut/status/1691052987605467137?s=20"
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/dmitriid/status/1691192339186782208
+- Author: Dmitrii (@dmitriid)
+- Posted: 2023-08-14 20:57:29
+
+## Branch
+
+**1/** @dmitriid
+
+@cmuratori
+
+This is the best metaphor (not ironically also about Microsoft) https://x.com/ocornut/status/1691052987605467137?s=20
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,39 @@
+---
+title: "@cmuratori My approach is to write code that I can come back to in a year or two and not want to throw my computer out the window."
+type: archive
+source: twitter
+source_url: "https://x.com/matt_j2/status/1691199889256931328"
+author: "Matt Johnson"
+handle: matt_j2
+post_id: "1691199889256931328"
+date: 2023-08-14
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori My approach is to write code that I can come back to in a year or two and not want to throw my computer out the window."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/matt_j2/status/1691199889256931328
+- Author: Matt Johnson (@matt_j2)
+- Posted: 2023-08-14 21:27:29
+
+## Branch
+
+**1/** @matt_j2
+
+@cmuratori
+
+My approach is to write code that I can come back to in a year or two and not want to throw my computer out the window.
+
+That means simple design and hopefully as little code as possible.
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,37 @@
+---
+title: "@cmuratori vs2022 on Mac is virtually unusable"
+type: archive
+source: twitter
+source_url: "https://x.com/snlwtn/status/1691200637424345088"
+author: "Sean Lawton"
+handle: snlwtn
+post_id: "1691200637424345088"
+date: 2023-08-14
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori vs2022 on Mac is virtually unusable"
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/snlwtn/status/1691200637424345088
+- Author: Sean Lawton (@snlwtn)
+- Posted: 2023-08-14 21:30:27
+
+## Branch
+
+**1/** @snlwtn
+
+@cmuratori
+
+vs2022 on Mac is virtually unusable
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,37 @@
+---
+title: "@cmuratori Performance is a feature."
+type: archive
+source: twitter
+source_url: "https://x.com/t3chn01200/status/1691233618167787521"
+author: "T3CHN01200"
+handle: t3chn01200
+post_id: "1691233618167787521"
+date: 2023-08-14
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori Performance is a feature."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/t3chn01200/status/1691233618167787521
+- Author: T3CHN01200 (@t3chn01200)
+- Posted: 2023-08-14 23:41:30
+
+## Branch
+
+**1/** @t3chn01200
+
+@cmuratori
+
+Performance is a feature. Change my mind.
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,37 @@
+---
+title: "@cmuratori I largely consider 'clean code' to mean that the system enables new content and new designs to be created with low code - ideally all at the same level of abstraction."
+type: archive
+source: twitter
+source_url: "https://x.com/00jknight/status/1691261726421901312"
+author: "Jason Knight"
+handle: 00jknight
+post_id: "1691261726421901312"
+date: 2023-08-15
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori I largely consider 'clean code' to mean that the system enables new content and new designs to be created with low code - ideally all at the same level of abstraction."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/00jknight/status/1691261726421901312
+- Author: Jason Knight (@00jknight)
+- Posted: 2023-08-15 01:33:12
+
+## Branch
+
+**1/** @00jknight
+
+@cmuratori
+
+I largely consider 'clean code' to mean that the system enables new content and new designs to be created with low code - ideally all at the same level of abstraction. I design systems, tools and APIs for myself and for my team to be more efficient.
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,37 @@
+---
+title: "@cmuratori VSCode will end up going the way of all editors that aren't Vim or Emacs."
+type: archive
+source: twitter
+source_url: "https://x.com/Bordonius/status/1691444543147704320"
+author: "Bordonius"
+handle: Bordonius
+post_id: "1691444543147704320"
+date: 2023-08-15
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori VSCode will end up going the way of all editors that aren't Vim or Emacs."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/Bordonius/status/1691444543147704320
+- Author: Bordonius (@Bordonius)
+- Posted: 2023-08-15 13:39:39
+
+## Branch
+
+**1/** @Bordonius
+
+@cmuratori
+
+VSCode will end up going the way of all editors that aren't Vim or Emacs. Its legacy will be LSP.
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,37 @@
+---
+title: "@cmuratori I do have both VS2022 and VS2019 on my machine, but I tend to use 2019 as the primary version."
+type: archive
+source: twitter
+source_url: "https://x.com/DefenceForceOrg/status/1691343173077946369"
+author: "Dbug"
+handle: DefenceForceOrg
+post_id: "1691343173077946369"
+date: 2023-08-15
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori I do have both VS2022 and VS2019 on my machine, but I tend to use 2019 as the primary version."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/DefenceForceOrg/status/1691343173077946369
+- Author: Dbug (@DefenceForceOrg)
+- Posted: 2023-08-15 06:56:50
+
+## Branch
+
+**1/** @DefenceForceOrg
+
+@cmuratori
+
+I do have both VS2022 and VS2019 on my machine, but I tend to use 2019 as the primary version.
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,37 @@
+---
+title: "@cmuratori Developers had no reason to uograde their machines every 6months so Microsoft gave them one"
+type: archive
+source: twitter
+source_url: "https://x.com/EduardKafe/status/1691370830972772352"
+author: "Eduard Kafe"
+handle: EduardKafe
+post_id: "1691370830972772352"
+date: 2023-08-15
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori Developers had no reason to uograde their machines every 6months so Microsoft gave them one"
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/EduardKafe/status/1691370830972772352
+- Author: Eduard Kafe (@EduardKafe)
+- Posted: 2023-08-15 08:46:44
+
+## Branch
+
+**1/** @EduardKafe
+
+@cmuratori
+
+Developers had no reason to uograde their machines every 6months so Microsoft gave them one
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,37 @@
+---
+title: "@cmuratori Does more code automatically mean more code paths? In the sense of different states your program can have? Or is it Just sth that is \"typical\"."
+type: archive
+source: twitter
+source_url: "https://x.com/Hannomalie1/status/1691483523385880576"
+author: "Hannomalie"
+handle: Hannomalie1
+post_id: "1691483523385880576"
+date: 2023-08-15
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori Does more code automatically mean more code paths? In the sense of different states your program can have? Or is it Just sth that is \"typical\"."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/Hannomalie1/status/1691483523385880576
+- Author: Hannomalie (@Hannomalie1)
+- Posted: 2023-08-15 16:14:32
+
+## Branch
+
+**1/** @Hannomalie1
+
+@cmuratori
+
+Does more code automatically mean more code paths? In the sense of different states your program can have? Or is it Just sth that is "typical".
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,43 @@
+---
+title: "@cmuratori Is there a good reason to use VS instead of VSCode?"
+type: archive
+source: twitter
+source_url: "https://x.com/enjoyingthewind/status/1691423123931873281"
+author: "//TODO: fix later 🐳"
+handle: enjoyingthewind
+post_id: "1691423123931873281"
+date: 2023-08-15
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori Is there a good reason to use VS instead of VSCode?"
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/enjoyingthewind/status/1691423123931873281
+- Author: //TODO: fix later 🐳 (@enjoyingthewind)
+- Posted: 2023-08-15 12:14:32
+
+## Branch
+
+**1/** @enjoyingthewind
+
+@cmuratori
+
+Is there a good reason to use VS instead of VSCode?
+
+**2/** @cmuratori
+
+@enjoyingthewind
+
+I don't use either. Last time I looked at VSCode, it couldn't do assembly-level debugging, so that's one reason - but they may have fixed that.
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,43 @@
+---
+title: "@cmuratori Generally speaking that’s a good principle."
+type: archive
+source: twitter
+source_url: "https://x.com/unclebobmartin/status/1691407659923042304"
+author: "Uncle Bob Martin"
+handle: unclebobmartin
+post_id: "1691407659923042304"
+date: 2023-08-15
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori Generally speaking that’s a good principle."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/unclebobmartin/status/1691407659923042304
+- Author: Uncle Bob Martin (@unclebobmartin)
+- Posted: 2023-08-15 11:13:05
+
+## Branch
+
+**1/** @unclebobmartin
+
+@cmuratori
+
+Generally speaking that’s a good principle. But it’s not an absolute. At some point reducing code volume starts to increase coupling. 
+
+@KentBeck’s advice works well for me. 
+
+First make it work. 
+Then make it right. 
+Then make it small and fast.
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,37 @@
+---
+title: "@cmuratori Agree completely."
+type: archive
+source: twitter
+source_url: "https://x.com/DavidBBlack/status/1691859487638909212"
+author: "David B. Black"
+handle: DavidBBlack
+post_id: "1691859487638909212"
+date: 2023-08-16
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori Agree completely."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/DavidBBlack/status/1691859487638909212
+- Author: David B. Black (@DavidBBlack)
+- Posted: 2023-08-16 17:08:29
+
+## Branch
+
+**1/** @DavidBBlack
+
+@cmuratori
+
+Agree completely.  Another aspect is the importance of eliminating redundancy.  Zero redundancy = minimal code = fast debugging and feature change. See https://www.blackliszt.com/occams-razor-occamality/
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,38 @@
+---
+title: "@cmuratori Strange, never had that problem with that waaaay older editor, called  vim ;)"
+type: archive
+source: twitter
+source_url: "https://x.com/SamvStachelski/status/1691695743986524326"
+author: "Samuel von Stachelski"
+handle: SamvStachelski
+post_id: "1691695743986524326"
+date: 2023-08-16
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori Strange, never had that problem with that waaaay older editor, called  vim ;)"
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/SamvStachelski/status/1691695743986524326
+- Author: Samuel von Stachelski (@SamvStachelski)
+- Posted: 2023-08-16 06:17:50
+
+## Branch
+
+**1/** @SamvStachelski
+
+@cmuratori
+
+Strange, never had that problem with that waaaay older editor, called  vim ;)
+(admittedly, LSPs can fail/lag/crash, but I can still code away, even with syntax highlighting :)
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,38 @@
+---
+title: "@cmuratori True and false, depends on the project and the compiler."
+type: archive
+source: twitter
+source_url: "https://x.com/rudiservo/status/1691743453527294388"
+author: "Rudi Servo"
+handle: rudiservo
+post_id: "1691743453527294388"
+date: 2023-08-16
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori True and false, depends on the project and the compiler."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/rudiservo/status/1691743453527294388
+- Author: Rudi Servo (@rudiservo)
+- Posted: 2023-08-16 09:27:25
+
+## Branch
+
+**1/** @rudiservo
+
+@cmuratori
+
+True and false, depends on the project and the compiler.
+CPUs hate jumping around, so having a compiler like C that allows inline functions helps with that, if you try and do DRY in assembly, your program will be slow, sometimes to the extreme.
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,41 @@
+---
+title: "@cmuratori Architecture is difficult, and most people have no idea how to approach it."
+type: archive
+source: twitter
+source_url: "https://x.com/hasen_95dx/status/1693179795423867063"
+author: "ハセン حسن"
+handle: hasen_95dx
+post_id: "1693179795423867063"
+date: 2023-08-20
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "@cmuratori Architecture is difficult, and most people have no idea how to approach it."
+in_reply_to: ""
+parent_post_id: "1691186899212472321"
+---
+
+## Source
+
+- URL: https://x.com/hasen_95dx/status/1693179795423867063
+- Author: ハセン حسن (@hasen_95dx)
+- Posted: 2023-08-20 08:34:55
+
+## Branch
+
+**1/** @hasen_95dx
+
+@cmuratori
+
+Architecture is difficult, and most people have no idea how to approach it.
+
+As far as I can tell, they are trying to guard against the prolifiration of spaghetti code.
+
+They probably think the explosion of code paths is an essential feature of programming that can't be avoided.
+
+## Related
+
+- Spine: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -0,0 +1,42 @@
+---
+title: "Programming practices that increase total code volume lead to more bugs and less performance."
+type: archive
+source: twitter
+source_url: "https://x.com/cmuratori/status/1691186899212472321"
+author: "Casey Muratori"
+handle: cmuratori
+post_id: "1691186899212472321"
+date: 2023-08-14
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - cmuratori
+description: "Programming practices that increase total code volume lead to more bugs and less performance."
+in_reply_to: ""
+---
+
+## Source
+
+- URL: https://x.com/cmuratori/status/1691186899212472321
+- Author: Casey Muratori (@cmuratori)
+- Posted: 2023-08-14 20:35:52
+
+## Thread
+
+**1/** @cmuratori
+
+Programming practices that increase total code volume lead to more bugs and less performance. It's not a tradeoff, it's a lose-lose. When you use significantly more code than is necessary to implement a feature, you provide an order of magnitude more code path combinations for bugs.
+
+People think "delivering features" is somehow at odds with delivering reasonable performance. The opposite is true. Reliable code often tends to perform very well on modern CPUs. It's unreliable code that manages to cripple a modern CPU, because it is built out of massive stacks of unnecessary layers whose interactions have never been thought through by anyone.
+
+Branches: [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-14-dmitriid-this-is-the-best-metaphor-not-ironically-also]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-14-Saniell_-funny-enough-when-you-write-oop-language-design]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-14-0xlac-the-answers-to-op-install-a-plugin-on-top-of-vs]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-14-matt_j2-my-approach-is-to-write-code-that-i-can-come-back]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-14-snlwtn-vs2022-on-mac-is-virtually-unusable]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-14-TanishqSingla_-not-to-mention-how-modern-software-shamelessly]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-14-KDmitriy99-it-cant-even-ctrl-a-after-some-update-a-few]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-14-TheBuzzSaw-just-today-in-vs-2022-the-semantic-analyzer]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-14-t3chn01200-performance-is-a-feature-change-my-mind]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-15-00jknight-i-largely-consider-clean-code-to-mean-that-the]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-15-DefenceForceOrg-i-do-have-both-vs2022-and-vs2019-on-my-machine]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-15-EduardKafe-developers-had-no-reason-to-uograde-their]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-15-unclebobmartin-generally-speaking-thats-a-good-principle-but-its]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-15-enjoyingthewind-is-there-a-good-reason-to-use-vs-instead-of-vscode]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-15-Bordonius-vscode-will-end-up-going-the-way-of-all-editors]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-15-Hannomalie1-does-more-code-automatically-mean-more-code-paths]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-16-SamvStachelski-strange-never-had-that-problem-with-that-waaaay]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-16-rudiservo-true-and-false-depends-on-the-project-and-the]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-16-DavidBBlack-agree-completely-another-aspect-is-the-importance]], [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code/2023-08-20-hasen_95dx-architecture-is-difficult-and-most-people-have-no]]
+
+**2/** @ExodusPgame
+
+@cmuratori
+
+When I was into clean code and wrote code to be "future proof", what caused me to slowly snap out of it, was that adding new features became more and more difficult due of the code structure, which directly contradicted the promise.
+
+Your videos accelerated the process.
@@ -0,0 +1,12 @@
+---
+title: cmuratori
+type: note
+draft: false
+description: Archived threads by cmuratori.
+tags:
+  - archive
+  - twitter
+  - cmuratori
+---
+
+- [[archive/threads/cmuratori/2023-08-14-programming-practices-that-increase-total-code]]
@@ -24,6 +24,7 @@ Example of the note shape (single spine, no branches): [[archive/threads/How to
 - [[archive/threads/Triang3l]]
 - [[archive/threads/VPCOMPRESSB]]
 - [[archive/threads/VictorTaelin]]
+- [[archive/threads/cmuratori]]
 - [[archive/threads/kenpex]]
 - [[archive/threads/mmalex]]
 - [[archive/threads/nicbarkeragain]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury example?"
+type: archive
+source: twitter
+source_url: "https://x.com/SubstrataVr/status/1869424048742232480"
+author: "SubstrataVR"
+handle: SubstrataVr
+post_id: "1869424048742232480"
+date: 2024-12-18
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury example?"
+in_reply_to: ""
+parent_post_id: "1869409243251827152"
+---
+
+## Source
+
+- URL: https://x.com/SubstrataVr/status/1869424048742232480
+- Author: SubstrataVR (@SubstrataVr)
+- Posted: 2024-12-18 16:46:40
+
+## Branch
+
+**1/** @SubstrataVr
+
+@rfleury
+
+example?
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury @threadreaderapp unroll"
+type: archive
+source: twitter
+source_url: "https://x.com/TriggerCoder/status/1869417818250420400"
+author: "TriggerCoder"
+handle: TriggerCoder
+post_id: "1869417818250420400"
+date: 2024-12-18
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury @threadreaderapp unroll"
+in_reply_to: ""
+parent_post_id: "1869409243251827152"
+---
+
+## Source
+
+- URL: https://x.com/TriggerCoder/status/1869417818250420400
+- Author: TriggerCoder (@TriggerCoder)
+- Posted: 2024-12-18 16:21:54
+
+## Branch
+
+**1/** @TriggerCoder
+
+@rfleury @threadreaderapp
+
+unroll
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a]]
@@ -0,0 +1,71 @@
+---
+title: "@rfleury At what point do you think you should convert a switch statement to \"behavior flags\"? Suppose there are N entity types and K behaviors."
+type: archive
+source: twitter
+source_url: "https://x.com/cairnc1/status/1869448847807898074"
+author: "cairno"
+handle: cairnc1
+post_id: "1869448847807898074"
+date: 2024-12-18
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury At what point do you think you should convert a switch statement to \"behavior flags\"? Suppose there are N entity types and K behaviors."
+in_reply_to: ""
+parent_post_id: "1869414867113009626"
+---
+
+## Source
+
+- URL: https://x.com/cairnc1/status/1869448847807898074
+- Author: cairno (@cairnc1)
+- Posted: 2024-12-18 18:25:12
+
+## Branch
+
+**1/** @cairnc1
+
+@rfleury
+
+At what point do you think you should convert a switch statement to "behavior flags"? Suppose there are N entity types and K behaviors. There should be optimal values of N, K and number of shared behaviors. At least for the purpose of source code length.
+
+**2/** @rfleury
+
+@cairnc1
+
+The problem is that the definition of the problem changes. Assuming there are "entity types" at all is partly the problem. If there is only one entity type, but N possible features for each entity, then there are 2^N possibilities for each individual entity's features.
+
+**3/** @rfleury
+
+@cairnc1
+
+Personally I have found I only very rarely want the switch. I instead want a single type at the bottom, which expands out into these large 2^N spaces, so that a great deal is possible via small changes in data.
+
+**4/** @cairnc1
+
+@rfleury
+
+I prefer behavior flags in theory but I find myself often having very bespoke indecomposable behaviors that correspond 1:1 with a "object". Is it because I am too OOP brained? Fwiw I've only ever programmed in C. I guess it is still a win since sharing behaviors is still easier
+
+**5/** @rfleury
+
+Yeah, I think that is still preferable to "object types". It also makes it much lower friction to decompose them, if/when you see how that should happen. If it never happens, doesn't really matter. For heavier data payloads associated with those specific features, just store them out-of-band.
+
+**6/** @cairnc1
+
+@rfleury
+
+Btw organizing logic this way really makes me wish C had metagen built-in. 😔 I guess we still have X macros
+
+**7/** @rfleury
+
+@cairnc1
+
+Yeah, I get that, although once you have your own general-purpose codebase, it is not a big deal, because *you do* have metagen built in then :)
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a]]
@@ -0,0 +1,45 @@
+---
+title: "@rfleury Maybe you already wrote this somewhere, but I'd be interested in seeing a practical example of your approach, even a basic one."
+type: archive
+source: twitter
+source_url: "https://x.com/count_mascetti/status/1869425640103129200"
+author: "Conte Mascetti"
+handle: count_mascetti
+post_id: "1869425640103129200"
+date: 2024-12-18
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury Maybe you already wrote this somewhere, but I'd be interested in seeing a practical example of your approach, even a basic one."
+in_reply_to: ""
+parent_post_id: "1869414867113009626"
+---
+
+## Source
+
+- URL: https://x.com/count_mascetti/status/1869425640103129200
+- Author: Conte Mascetti (@count_mascetti)
+- Posted: 2024-12-18 16:52:59
+
+## Branch
+
+**1/** @count_mascetti
+
+@rfleury
+
+Maybe you already wrote this somewhere, but I'd be interested in seeing a practical example of your approach, even a basic one. It all sounds very appealing, but I'm struggling to come up with specific use cases.
+
+**2/** @rfleury
+
+@count_mascetti
+
+https://www.rfleury.com/p/ui-part-3-the-widget-building-language
+https://www.rfleury.com/p/emergence-and-composition
+https://www.rfleury.com/p/the-codepath-combinatoric-explosion
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a]]
@@ -0,0 +1,69 @@
+---
+title: "@rfleury any concrete example?"
+type: archive
+source: twitter
+source_url: "https://x.com/pr0meteu5/status/1869438149832946012"
+author: "pr0meteu5"
+handle: pr0meteu5
+post_id: "1869438149832946012"
+date: 2024-12-18
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury any concrete example?"
+in_reply_to: ""
+parent_post_id: "1869409243251827152"
+---
+
+## Source
+
+- URL: https://x.com/pr0meteu5/status/1869438149832946012
+- Author: pr0meteu5 (@pr0meteu5)
+- Posted: 2024-12-18 17:42:42
+
+## Branch
+
+**1/** @pr0meteu5
+
+@rfleury
+
+any concrete example?
+
+**2/** @rfleury
+
+@saddev24
+
+- https://www.rfleury.com/p/ui-part-3-the-widget-building-language
+- https://www.rfleury.com/p/emergence-and-composition
+- https://www.rfleury.com/p/the-codepath-combinatoric-explosion
+
+**3/** @LazarTo42297588
+
+@rfleury @saddev24
+
+Let's say you're creating a generic table component, with different types of table columns. How will you design the cell render function so it handles all the different types of data that can be displayed: image, url, list, object, button.
+
+**4/** @rfleury
+
+The first thing I’d say is that this is not an architecture I even agree with. Any helpers for constructing a table should build *just the table*, with all UI & rendering capabilities being written by the user.
+
+For instance, in my codebase it’d look like:
+
+UI_Table(…)
+{
+  UI_TableRow
+  {
+    UI_TableCell { … }
+  }
+}
+
+In that table cell block, the usage code can simply build whatever they want. The table constructs are completely orthogonal.
+
+But in any case, in any codepath which can conceptually accept 1 of N things, it can also be reframed to accept any combination of those N things. Instead of N possibilities, you get 2^N possibilities. So if the codepath took an image AND a URL, rather than an image OR a URL, and you build the codepath to handle all 4 cases (with the same amount as that which would handle the OR case), then you get new features for free (e.g. image AND URL, standalone image, standalone URL).
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury This reminds me of games and simulations, where entities have a set of attributes."
+type: archive
+source: twitter
+source_url: "https://x.com/spacebat/status/1869488275423207781"
+author: "spacebat"
+handle: spacebat
+post_id: "1869488275423207781"
+date: 2024-12-18
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury This reminds me of games and simulations, where entities have a set of attributes."
+in_reply_to: ""
+parent_post_id: "1869409243251827152"
+---
+
+## Source
+
+- URL: https://x.com/spacebat/status/1869488275423207781
+- Author: spacebat (@spacebat)
+- Posted: 2024-12-18 21:01:52
+
+## Branch
+
+**1/** @spacebat
+
+@rfleury
+
+This reminds me of games and simulations, where entities have a set of attributes. That supports the use of entity component systems which gives each entity a key into various tables of related attributes, with subsystems for position/velocity, hit-points, buffs etc.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a]]
@@ -0,0 +1,43 @@
+---
+title: "@rfleury I completely agree."
+type: archive
+source: twitter
+source_url: "https://x.com/Walley_Alex1/status/1869875982645244406"
+author: "Alex Walley"
+handle: Walley_Alex1
+post_id: "1869875982645244406"
+date: 2024-12-19
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury I completely agree."
+in_reply_to: ""
+parent_post_id: "1869409243251827152"
+---
+
+## Source
+
+- URL: https://x.com/Walley_Alex1/status/1869875982645244406
+- Author: Alex Walley (@Walley_Alex1)
+- Posted: 2024-12-19 22:42:29
+
+## Branch
+
+**1/** @Walley_Alex1
+
+@rfleury
+
+I completely agree. I am interested in your thoughts on allowing these megastructure/product types to be used as part of a user API? One issue with product types: it is harder to see what a “valid” set of fields are. With a sum type, they are type checked
+
+**2/** @rfleury
+
+@Walley_Alex1
+
+The idea is more that there *aren’t* invalid subsets of fields. All possibilities are on the table. This is actually more useful for usage code, because the underlying mechanisms are more flexible.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury interesting projection of combinatorics system into coding system."
+type: archive
+source: twitter
+source_url: "https://x.com/wetfsdffsdasd/status/1870045591582933041"
+author: "wetfsdffsdasd"
+handle: wetfsdffsdasd
+post_id: "1870045591582933041"
+date: 2024-12-20
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury interesting projection of combinatorics system into coding system."
+in_reply_to: ""
+parent_post_id: "1869409243251827152"
+---
+
+## Source
+
+- URL: https://x.com/wetfsdffsdasd/status/1870045591582933041
+- Author: wetfsdffsdasd (@wetfsdffsdasd)
+- Posted: 2024-12-20 09:56:27
+
+## Branch
+
+**1/** @wetfsdffsdasd
+
+@rfleury
+
+interesting projection of combinatorics system into coding system. problem is, none of this yields always. an eg. is when you decouple the system into axbxcxd... such as the space of any of a,b,.. is small, you will be losing sanity and time. there are many other cases too
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a]]
@@ -0,0 +1,43 @@
+---
+title: "@rfleury thank you for this thread- read it a while ago, but now working on a game and something *clicked* when thinking about modeling data in this way (understanding the power of the 2^n benefit)"
+type: archive
+source: twitter
+source_url: "https://x.com/s0ulware/status/1882596282017186049"
+author: "sam"
+handle: s0ulware
+post_id: "1882596282017186049"
+date: 2025-01-24
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury thank you for this thread- read it a while ago, but now working on a game and something *clicked* when thinking about modeling data in this way (understanding the power of the 2^n benefit)"
+in_reply_to: ""
+parent_post_id: "1869409243251827152"
+---
+
+## Source
+
+- URL: https://x.com/s0ulware/status/1882596282017186049
+- Author: sam (@s0ulware)
+- Posted: 2025-01-24 01:08:25
+
+## Branch
+
+**1/** @s0ulware
+
+@rfleury
+
+thank you for this thread- read it a while ago, but now working on a game and something *clicked* when thinking about modeling data in this way (understanding the power of the 2^n benefit)
+
+**2/** @rfleury
+
+@s0ulware
+
+It’s seriously insane how useful it is, once you see it!
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a]]
@@ -0,0 +1,64 @@
+---
+title: "One of the most powerful lessons I learned as a programmer was to use combinatoric spaces to my advantage, rather than allowing them to explode into—for example—handwritten source code."
+type: archive
+source: twitter
+source_url: "https://x.com/rfleury/status/1869409243251827152"
+author: "Ryan Fleury"
+handle: rfleury
+post_id: "1869409243251827152"
+date: 2024-12-18
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "One of the most powerful lessons I learned as a programmer was to use combinatoric spaces to my advantage, rather than allowing them to explode into—for example—handwritten source code."
+in_reply_to: ""
+---
+
+## Source
+
+- URL: https://x.com/rfleury/status/1869409243251827152
+- Author: Ryan Fleury (@rfleury)
+- Posted: 2024-12-18 15:47:50
+
+## Thread
+
+**1/** @rfleury
+
+One of the most powerful lessons I learned as a programmer was to use combinatoric spaces to my advantage, rather than allowing them to explode into—for example—handwritten source code. This required relaxing, for example, an obsession with static type checking.
+
+Branches: [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a/2024-12-18-TriggerCoder-unroll]], [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a/2024-12-18-SubstrataVr-example]], [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a/2024-12-18-pr0meteu5-any-concrete-example]], [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a/2024-12-18-spacebat-this-reminds-me-of-games-and-simulations-where]], [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a/2024-12-19-Walley_Alex1-i-completely-agree-i-am-interested-in-your]], [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a/2024-12-20-wetfsdffsdasd-interesting-projection-of-combinatorics-system]], [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a/2025-01-24-s0ulware-thank-you-for-this-thread-read-it-a-while-ago-but]]
+
+**2/** @rfleury
+
+Instead what I learned was to use static product types to form homogeneous building blocks for large combinatoric spaces, and to organize data transforms around forming those spaces. Choosing actual points in this space becomes a completely dynamic capability.
+
+**3/** @rfleury
+
+This is related to my comment the other day on sum types. The reason you won’t find many of them in my code is that I find that they leak combinatoric spaces into the source code itself, by forming one “axis” (1 of N types), which might be multiplied by another. That puts it in the path of non-temporal physical reality—physical code—which must either be handwritten or generated. This is either slow for the programmer, or for the computer.
+
+**4/** @rfleury
+
+Whereas if you keep the source code looser, with homogeneous types, you can allow defining points & transitioning between points in the combinatoric space to be much more natural & trivial of a computation. In practice this means you’ve turned an O(N*M*…) into an O(N+M+…), for either yourself or the compiler, or code generator (all three are good).
+
+**5/** @rfleury
+
+The fundamental reason for this is machine code, being representable by a transform from A -> B (where A and B are definitions of data formats, or types), must have a shape which expects/fits A as the input, and expects/fits B as the output. A|C -> B means you must have two paths: A -> B | C -> B. This suggests that, as the number of types grows, the number of codepaths must also grow. Or, put another way, the structure of types is reflected in the source code which uses those types.
+
+**6/** @rfleury
+
+You can often see this concretely in C - a discriminated `union` implies a `switch` (or some other branching mechanism on the tag). An array can imply a loop over the indices. A linked list can imply a loop over the links. And so on.
+
+**7/** @rfleury
+
+Thus, when someone attempts to take static type checking to the extreme, and maximally fit all potential data payloads into a format which only stores data which those payloads use (e.g. no unused fields in any case), they are not only exploding the number of types, they are also exploding the number of codepaths.
+
+When confronted with this reality, one impulse is to force compilers or other generators to iterate the combinatoric space manually; this is perhaps preferable to doing it by hand, but what's preferable over both options is to simply avoid the combinatoric space being present in this domain at all.
+
+**8/** @rfleury
+
+This makes distinctions in combinatoric spaces a very trivial data problem, rather than an arbitrarily difficult code problem. It makes the code small, yet the set of possible effects from the code large.
+
+Branches: [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a/2024-12-18-count_mascetti-maybe-you-already-wrote-this-somewhere-but-id-be]], [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a/2024-12-18-cairnc1-at-what-point-do-you-think-you-should-convert-a]]
@@ -74,6 +74,24 @@ You can just make the free method of the allocator be empty. If the arena is blo

 There’s no point.

+**9/** @slendidev
+
+@rfleury
+
+Sure, but then you can still make that free method empty
+
+**10/** @rfleury
+
+@xslendix
+
+Or you can just not do any of this ridiculous RAII nonsense at all.
+
+**11/** @slendidev
+
+@rfleury
+
+At that point it’s just personal preference on wether you want your frees explicit or not in the code. Don’t think having an empty free method adds any overhead either since the compiler can just exclude the destructor entirely because of inlining
+
 ## Related

 - Spine: [[archive/threads/rfleury/2025-04-30-to-the-degree-this-is-true-its-only-in-a]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury I like using lambdas or local functions to extract some common logic and put it behind a good name without cluttering things up outside"
+type: archive
+source: twitter
+source_url: "https://x.com/0x6e616461/status/2061659934119354768"
+author: "𝗻𝗼𝗯𝗼𝗱𝘆"
+handle: 0x6e616461
+post_id: "2061659934119354768"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury I like using lambdas or local functions to extract some common logic and put it behind a good name without cluttering things up outside"
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/0x6e616461/status/2061659934119354768
+- Author: 𝗻𝗼𝗯𝗼𝗱𝘆 (@0x6e616461)
+- Posted: 2026-06-02 04:03:26
+
+## Branch
+
+**1/** @0x6e616461
+
+@rfleury
+
+I like using lambdas or local functions to extract some common logic and put it behind a good name without cluttering things up outside
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury yes! A similar problem comes when you follow retarded bob martin-esque rules like not exceeding 6 lines per function."
+type: archive
+source: twitter
+source_url: "https://x.com/AlexAegis/status/2061831568537071703"
+author: "Sandor 🦔"
+handle: AlexAegis
+post_id: "2061831568537071703"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury yes! A similar problem comes when you follow retarded bob martin-esque rules like not exceeding 6 lines per function."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/AlexAegis/status/2061831568537071703
+- Author: Sandor 🦔 (@AlexAegis)
+- Posted: 2026-06-02 15:25:27
+
+## Branch
+
+**1/** @AlexAegis
+
+@rfleury
+
+yes! A similar problem comes when you follow retarded bob martin-esque rules like not exceeding 6 lines per function. You can end up having a bunch of small functions mutating one common state that are now dependent on their call order. That’s not any better than a comment.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury I completely agree, adding a helper function rarely reduces complexity and often leads to a lot of argument bloat."
+type: archive
+source: twitter
+source_url: "https://x.com/Arrghtv/status/2061670156401611263"
+author: "Arrghtv"
+handle: Arrghtv
+post_id: "2061670156401611263"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury I completely agree, adding a helper function rarely reduces complexity and often leads to a lot of argument bloat."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/Arrghtv/status/2061670156401611263
+- Author: Arrghtv (@Arrghtv)
+- Posted: 2026-06-02 04:44:03
+
+## Branch
+
+**1/** @Arrghtv
+
+@rfleury
+
+I completely agree, adding a helper function rarely reduces complexity and often leads to a lot of argument bloat.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury oh I hate helper functions, especially the ones that get used exactly once and serve no purpose but hiding code"
+type: archive
+source: twitter
+source_url: "https://x.com/ChickenBurner2/status/2061723452571082945"
+author: "ChickenBurner"
+handle: ChickenBurner2
+post_id: "2061723452571082945"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury oh I hate helper functions, especially the ones that get used exactly once and serve no purpose but hiding code"
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/ChickenBurner2/status/2061723452571082945
+- Author: ChickenBurner (@ChickenBurner2)
+- Posted: 2026-06-02 08:15:50
+
+## Branch
+
+**1/** @ChickenBurner2
+
+@rfleury
+
+oh I hate helper functions, especially the ones that get used exactly once and serve no purpose but hiding code
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury I've come to refer to declarative as \"just fucking say it\" coding."
+type: archive
+source: twitter
+source_url: "https://x.com/JoelStransky/status/2061851334278877273"
+author: "Joel Stransky ✨"
+handle: JoelStransky
+post_id: "2061851334278877273"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury I've come to refer to declarative as \"just fucking say it\" coding."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/JoelStransky/status/2061851334278877273
+- Author: Joel Stransky ✨ (@JoelStransky)
+- Posted: 2026-06-02 16:44:00
+
+## Branch
+
+**1/** @JoelStransky
+
+@rfleury
+
+I've come to refer to declarative as "just fucking say it" coding.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,39 @@
+---
+title: "@rfleury I've been compressing in terms of \"section functions\" as opposed to helper functions."
+type: archive
+source: twitter
+source_url: "https://x.com/Mallchad/status/2061632296784941234"
+author: "Mallchad 🏴󠁧󠁢󠁥󠁮󠁧󠁿"
+handle: Mallchad
+post_id: "2061632296784941234"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury I've been compressing in terms of \"section functions\" as opposed to helper functions."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/Mallchad/status/2061632296784941234
+- Author: Mallchad 🏴󠁧󠁢󠁥󠁮󠁧󠁿 (@Mallchad)
+- Posted: 2026-06-02 02:13:37
+
+## Branch
+
+**1/** @Mallchad
+
+@rfleury
+
+I've been compressing in terms of "section functions" as opposed to helper functions. I find the concept of small functions teniously useful.
+
+If long sections self-organizes into related "sub-sections" I might split it out- and that naturally forms data-structures to pass around
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury I noticed focusing on the data you work and how you work on it helps a lot"
+type: archive
+source: twitter
+source_url: "https://x.com/MrModez/status/2061700108933365773"
+author: "MrModez Pineapple"
+handle: MrModez
+post_id: "2061700108933365773"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury I noticed focusing on the data you work and how you work on it helps a lot"
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/MrModez/status/2061700108933365773
+- Author: MrModez Pineapple (@MrModez)
+- Posted: 2026-06-02 06:43:05
+
+## Branch
+
+**1/** @MrModez
+
+@rfleury
+
+I noticed focusing on the data you work and how you work on it helps a lot
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury I'll often inline every 'helper function' I find while coding."
+type: archive
+source: twitter
+source_url: "https://x.com/Ravicale/status/2061912906921304345"
+author: "Ravicale"
+handle: Ravicale
+post_id: "2061912906921304345"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury I'll often inline every 'helper function' I find while coding."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/Ravicale/status/2061912906921304345
+- Author: Ravicale (@Ravicale)
+- Posted: 2026-06-02 20:48:40
+
+## Branch
+
+**1/** @Ravicale
+
+@rfleury
+
+I'll often inline every 'helper function' I find while coding. This frequently lets me find more general patterns that can be more compactly expressed, and it also often results in me finding removable state that existed because of coupling between 'helpers'.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury Entry point you mean indirection ?"
+type: archive
+source: twitter
+source_url: "https://x.com/SaladeTomate18/status/2061680147627958466"
+author: "🇫🇷 Salade Patriote 🇫🇷"
+handle: SaladeTomate18
+post_id: "2061680147627958466"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury Entry point you mean indirection ?"
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/SaladeTomate18/status/2061680147627958466
+- Author: 🇫🇷 Salade Patriote 🇫🇷 (@SaladeTomate18)
+- Posted: 2026-06-02 05:23:46
+
+## Branch
+
+**1/** @SaladeTomate18
+
+@rfleury
+
+Entry point you mean indirection ?
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury fewer entry points = fewer surprises"
+type: archive
+source: twitter
+source_url: "https://x.com/alienorg/status/2061739363117973966"
+author: "Alien"
+handle: alienorg
+post_id: "2061739363117973966"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury fewer entry points = fewer surprises"
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/alienorg/status/2061739363117973966
+- Author: Alien (@alienorg)
+- Posted: 2026-06-02 09:19:04
+
+## Branch
+
+**1/** @alienorg
+
+@rfleury
+
+fewer entry points = fewer surprises
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury I'm not exactly sure what do you mean with this statement."
+type: archive
+source: twitter
+source_url: "https://x.com/anicic_filip/status/2061769712824995927"
+author: "Filip Aničić"
+handle: anicic_filip
+post_id: "2061769712824995927"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury I'm not exactly sure what do you mean with this statement."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/anicic_filip/status/2061769712824995927
+- Author: Filip Aničić (@anicic_filip)
+- Posted: 2026-06-02 11:19:40
+
+## Branch
+
+**1/** @anicic_filip
+
+@rfleury
+
+I'm not exactly sure what do you mean with this statement. Could you give a comparison example to solidify the statement with something we could analyse?
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,41 @@
+---
+title: "@rfleury I like giant matching functions with lots of helper functions as closures with limited scope."
+type: archive
+source: twitter
+source_url: "https://x.com/eron_wolf/status/2061625769684566075"
+author: "Eron Wolf"
+handle: eron_wolf
+post_id: "2061625769684566075"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury I like giant matching functions with lots of helper functions as closures with limited scope."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/eron_wolf/status/2061625769684566075
+- Author: Eron Wolf (@eron_wolf)
+- Posted: 2026-06-02 01:47:41
+
+## Branch
+
+**1/** @eron_wolf
+
+@rfleury
+
+I like giant matching functions with lots of helper functions as closures with limited scope.  At least then you're kinda containing the mess.
+
+**2/** @rfleury
+
+That is definitely fair; I build as C (and I want to build with MSVC as well as the others, so I don't have all of the extensions), so I do not have local functions and certainly not closures, but I often find myself approximating similar patterns with command buffers. That said, I still find the statically linear flow preferable when possible.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury Only way to compress is dsl vv everything else is just the dsl with some extra boilerplate"
+type: archive
+source: twitter
+source_url: "https://x.com/gcoum/status/2061640674576101837"
+author: "gcoum"
+handle: gcoum
+post_id: "2061640674576101837"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury Only way to compress is dsl vv everything else is just the dsl with some extra boilerplate"
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/gcoum/status/2061640674576101837
+- Author: gcoum (@gcoum)
+- Posted: 2026-06-02 02:46:54
+
+## Branch
+
+**1/** @gcoum
+
+@rfleury
+
+Only way to compress is dsl vv everything else is just the dsl with some extra boilerplate
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,38 @@
+---
+title: "@rfleury 100% agree, DRY can be extremely overdone."
+type: archive
+source: twitter
+source_url: "https://x.com/guywald/status/2061801368533315756"
+author: "Guy Waldman"
+handle: guywald
+post_id: "2061801368533315756"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury 100% agree, DRY can be extremely overdone."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/guywald/status/2061801368533315756
+- Author: Guy Waldman (@guywald)
+- Posted: 2026-06-02 13:25:27
+
+## Branch
+
+**1/** @guywald
+
+@rfleury
+
+100% agree, DRY can be extremely overdone. LLMs love doing this especially…
+There is also a huge price for cognitive complexity, for anyone, human or otherwise, that works on a codebase.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,38 @@
+---
+title: "@rfleury Do you have an example or a before and after by chance?"
+type: archive
+source: twitter
+source_url: "https://x.com/jrjnorton/status/2061639688935317743"
+author: "Jacob Norton"
+handle: jrjnorton
+post_id: "2061639688935317743"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury Do you have an example or a before and after by chance?"
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/jrjnorton/status/2061639688935317743
+- Author: Jacob Norton (@jrjnorton)
+- Posted: 2026-06-02 02:42:59
+
+## Branch
+
+**1/** @jrjnorton
+
+@rfleury
+
+Do you have an example or a before and after by chance?
+I don't find myself pulling out helper functions too often anymore so I'm having trouble thinking of what that looks like in practice
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,39 @@
+---
+title: "@rfleury Very well said."
+type: archive
+source: twitter
+source_url: "https://x.com/jshurmer/status/2061626322707734909"
+author: "Jordan Shurmer"
+handle: jshurmer
+post_id: "2061626322707734909"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury Very well said."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/jshurmer/status/2061626322707734909
+- Author: Jordan Shurmer (@jshurmer)
+- Posted: 2026-06-02 01:49:53
+
+## Branch
+
+**1/** @jshurmer
+
+@rfleury
+
+Very well said. 
+
+It would be useful to see examples side-by-side of the two approaches "simplifying" the same starting code
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury My mental model for this: Are you putting the mess in a closet, or are you actually organizing the it?"
+type: archive
+source: twitter
+source_url: "https://x.com/katanadash/status/2061904729975001095"
+author: "Jake Federico"
+handle: katanadash
+post_id: "2061904729975001095"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury My mental model for this: Are you putting the mess in a closet, or are you actually organizing the it?"
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/katanadash/status/2061904729975001095
+- Author: Jake Federico (@katanadash)
+- Posted: 2026-06-02 20:16:10
+
+## Branch
+
+**1/** @katanadash
+
+@rfleury
+
+My mental model for this: Are you putting the mess in a closet, or are you actually organizing the it?
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,55 @@
+---
+title: "@rfleury A function explicitly limits the variables that its code depends on."
+type: archive
+source: twitter
+source_url: "https://x.com/ndwork/status/2061896821023383829"
+author: "Nicholas Dwork"
+handle: ndwork
+post_id: "2061896821023383829"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury A function explicitly limits the variables that its code depends on."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/ndwork/status/2061896821023383829
+- Author: Nicholas Dwork (@ndwork)
+- Posted: 2026-06-02 19:44:44
+
+## Branch
+
+**1/** @ndwork
+
+@rfleury
+
+A function explicitly limits the variables that its code depends on.
+
+For many functions, they can be independently tested. When possible, that also seems useful. If there’s a bug, it’s highly likely not to be inside the function.
+
+These things make functions extremely useful.
+
+**2/** @rfleury
+
+No. By adding entry points which are independently tested (e.g. in a vacuum, removed from context), you are combinatorially increasing the number of possible test cases. It’s vastly easier to exercise one single codepath than several thousands.
+
+Second of all, sub-scopes also allow limiting exposed variables to other scopes. If a scope fairly far into a function depends on the entire set of exposed variables that came before, functions do not stop that, because you’d simply need to pass them all. There is way less boilerplate and way less complexity in the single codepath version.
+
+**3/** @ndwork
+
+@rfleury
+
+I’m taking the fact that you didn’t tell me to delete my account as a huge mark of success.  :)
+
+All the best Ryan.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,39 @@
+---
+title: "@rfleury I like this as it maps the problem with input on one side and output on the other."
+type: archive
+source: twitter
+source_url: "https://x.com/patrickgwsmith/status/2061690097158815943"
+author: "Patrick Smith"
+handle: patrickgwsmith
+post_id: "2061690097158815943"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury I like this as it maps the problem with input on one side and output on the other."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/patrickgwsmith/status/2061690097158815943
+- Author: Patrick Smith (@patrickgwsmith)
+- Posted: 2026-06-02 06:03:18
+
+## Branch
+
+**1/** @patrickgwsmith
+
+@rfleury
+
+I like this as it maps the problem with input on one side and output on the other.
+
+What do you mean by tables?
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury Does this imply if you took an external dependency, like Linux or matrix library, and started folding that code into your own, instead of calling into it, your code would  improve?"
+type: archive
+source: twitter
+source_url: "https://x.com/pbwinston/status/2061774820073734389"
+author: "Philip Winston"
+handle: pbwinston
+post_id: "2061774820073734389"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury Does this imply if you took an external dependency, like Linux or matrix library, and started folding that code into your own, instead of calling into it, your code would  improve?"
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/pbwinston/status/2061774820073734389
+- Author: Philip Winston (@pbwinston)
+- Posted: 2026-06-02 11:39:57
+
+## Branch
+
+**1/** @pbwinston
+
+@rfleury
+
+Does this imply if you took an external dependency, like Linux or matrix library, and started folding that code into your own, instead of calling into it, your code would  improve?
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury Can't tell just how many times I've pulled out something into it's own function only to use it once."
+type: archive
+source: twitter
+source_url: "https://x.com/pegvvin/status/2061783632067633224"
+author: "Aditya M."
+handle: pegvvin
+post_id: "2061783632067633224"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury Can't tell just how many times I've pulled out something into it's own function only to use it once."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/pegvvin/status/2061783632067633224
+- Author: Aditya M. (@pegvvin)
+- Posted: 2026-06-02 12:14:58
+
+## Branch
+
+**1/** @pegvvin
+
+@rfleury
+
+Can't tell just how many times I've pulled out something into it's own function only to use it once. I was taught "clean code" incorrectly.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury I got a mess (kind of working fine but dirty) with c# extensions."
+type: archive
+source: twitter
+source_url: "https://x.com/polloimperial/status/2061632717666623787"
+author: "🐔🇩🇴 kikirikii"
+handle: polloimperial
+post_id: "2061632717666623787"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury I got a mess (kind of working fine but dirty) with c# extensions."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/polloimperial/status/2061632717666623787
+- Author: 🐔🇩🇴 kikirikii (@polloimperial)
+- Posted: 2026-06-02 02:15:17
+
+## Branch
+
+**1/** @polloimperial
+
+@rfleury
+
+I got a mess (kind of working fine but dirty) with c# extensions.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury db 설계에 앞서 모든데이터를 파일 입출력 으로 해서 최소 부하를 해보는것도 도움이됨"
+type: archive
+source: twitter
+source_url: "https://x.com/sipubot/status/2061782202275524654"
+author: "시퍼렁어"
+handle: sipubot
+post_id: "2061782202275524654"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury db 설계에 앞서 모든데이터를 파일 입출력 으로 해서 최소 부하를 해보는것도 도움이됨"
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/sipubot/status/2061782202275524654
+- Author: 시퍼렁어 (@sipubot)
+- Posted: 2026-06-02 12:09:17
+
+## Branch
+
+**1/** @sipubot
+
+@rfleury
+
+db 설계에 앞서 모든데이터를 파일 입출력 으로 해서 최소 부하를 해보는것도 도움이됨
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,38 @@
+---
+title: "@rfleury Never thought of helper f-ns as code compression, you still have all the same stuff elsewhere."
+type: archive
+source: twitter
+source_url: "https://x.com/vf42/status/2061694115520164235"
+author: "Vadim Fedorov"
+handle: vf42
+post_id: "2061694115520164235"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury Never thought of helper f-ns as code compression, you still have all the same stuff elsewhere."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/vf42/status/2061694115520164235
+- Author: Vadim Fedorov (@vf42)
+- Posted: 2026-06-02 06:19:16
+
+## Branch
+
+**1/** @vf42
+
+@rfleury
+
+Never thought of helper f-ns as code compression, you still have all the same stuff elsewhere. Not to say it's useless.
+For the compression exercise ypu mention, I like to add a twist "...and make it easier to understand", which unlocks a whole new level to it.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,91 @@
+---
+title: "@rfleury What about polymorphism and inheritance?"
+type: archive
+source: twitter
+source_url: "https://x.com/wizplum/status/2061622209383379247"
+author: "wizplum"
+handle: wizplum
+post_id: "2061622209383379247"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury What about polymorphism and inheritance?"
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/wizplum/status/2061622209383379247
+- Author: wizplum (@wizplum)
+- Posted: 2026-06-02 01:33:32
+
+## Branch
+
+**1/** @wizplum
+
+@rfleury
+
+What about polymorphism and inheritance?
+
+**2/** @rfleury
+
+@wizplum
+
+Largely useless and terrible
+
+**3/** @SaladeTomate18
+
+@rfleury @wizplum
+
+You still need callback for buttons OnClick.
+
+I assume that's why you said largely (99%) and not always (100%)
+
+**4/** @rfleury
+
+@SaladeTomate18 @wizplum
+
+No, you don’t. You shouldn’t even have that concept. It’s not a good design.
+
+**5/** @SaladeTomate18
+
+@rfleury @wizplum
+
+How would you handle it ?
+
+It is totally not my domain so I am just repeating basic patterns I've seen in many UI libraries.
+
+Thinking about it on the spot all I see is using IDs on buttons and a big switch.
+
+**6/** @rfleury
+
+@SaladeTomate18 @wizplum
+
+Check this out
+
+https://youtu.be/Z1qyvQsjK5Y
+
+**7/** @SaladeTomate18
+
+@rfleury @wizplum
+
+Already watched it years ago 😅
+
+I thought we were talking specifically retained UI. Not Immediate ones.
+
+I do have some friends that worked on AAA with IM UI and they told me performance was not good compared to retained mode (could be just bad code ofc)
+
+**8/** @rfleury
+
+@SaladeTomate18 @wizplum
+
+Even with retained mode you do not need callbacks. But no, your friends are incorrect. There is nothing in principle about IM UI that makes it less performant than RM. In many cases it’s quite the opposite.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury will love to read a long article on this"
+type: archive
+source: twitter
+source_url: "https://x.com/0paperpal/status/2062097820493193622"
+author: "Paperpal"
+handle: 0paperpal
+post_id: "2062097820493193622"
+date: 2026-06-03
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury will love to read a long article on this"
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/0paperpal/status/2062097820493193622
+- Author: Paperpal (@0paperpal)
+- Posted: 2026-06-03 09:03:26
+
+## Branch
+
+**1/** @0paperpal
+
+@rfleury
+
+will love to read a long article on this
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,43 @@
+---
+title: "@rfleury Can you share an open source project that follows this strategy? As someone deeply entrenched in the web and java world, I am finding it hard to wrap my head around."
+type: archive
+source: twitter
+source_url: "https://x.com/alecodex/status/2062309622510170465"
+author: "ALE"
+handle: alecodex
+post_id: "2062309622510170465"
+date: 2026-06-03
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury Can you share an open source project that follows this strategy? As someone deeply entrenched in the web and java world, I am finding it hard to wrap my head around."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/alecodex/status/2062309622510170465
+- Author: ALE (@alecodex)
+- Posted: 2026-06-03 23:05:04
+
+## Branch
+
+**1/** @alecodex
+
+@rfleury
+
+Can you share an open source project that follows this strategy? As someone deeply entrenched in the web and java world, I am finding it hard to wrap my head around.
+
+**2/** @rfleury
+
+@alecodex
+
+https://github.com/EpicGamesExt/raddebugger
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury rad debugger is easy to read for such a complex project, I'm experimenting with the same long proc and noticed that when I add something I'm not constrained to early abstractions, I can connect dots much easier."
+type: archive
+source: twitter
+source_url: "https://x.com/javiercbk/status/2061970388205146329"
+author: "Javier Lecuona"
+handle: javiercbk
+post_id: "2061970388205146329"
+date: 2026-06-03
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury rad debugger is easy to read for such a complex project, I'm experimenting with the same long proc and noticed that when I add something I'm not constrained to early abstractions, I can connect dots much easier."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/javiercbk/status/2061970388205146329
+- Author: Javier Lecuona (@javiercbk)
+- Posted: 2026-06-03 00:37:04
+
+## Branch
+
+**1/** @javiercbk
+
+@rfleury
+
+rad debugger is easy to read for such a complex project, I'm experimenting with the same long proc and noticed that when I add something I'm not constrained to early abstractions, I can connect dots much easier. Yet  I have to resist years of brain programming for programming
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,37 @@
+---
+title: "@rfleury I like a big ass on my functions."
+type: archive
+source: twitter
+source_url: "https://x.com/jeremdak/status/2061966313636131122"
+author: "Jeremy"
+handle: jeremdak
+post_id: "2061966313636131122"
+date: 2026-06-03
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury I like a big ass on my functions."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/jeremdak/status/2061966313636131122
+- Author: Jeremy (@jeremdak)
+- Posted: 2026-06-03 00:20:53
+
+## Branch
+
+**1/** @jeremdak
+
+@rfleury
+
+I like a big ass on my functions.
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,39 @@
+---
+title: "@rfleury Interesting! I was just reviewing code and thinking of solution when I read this tweet and realised \"table + removing enum\" solved it better than expecting the helper function to be used correctly."
+type: archive
+source: twitter
+source_url: "https://x.com/p_mbanugo/status/2062293339030843846"
+author: "Peter Mbanugo"
+handle: p_mbanugo
+post_id: "2062293339030843846"
+date: 2026-06-03
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury Interesting! I was just reviewing code and thinking of solution when I read this tweet and realised \"table + removing enum\" solved it better than expecting the helper function to be used correctly."
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/p_mbanugo/status/2062293339030843846
+- Author: Peter Mbanugo (@p_mbanugo)
+- Posted: 2026-06-03 22:00:22
+
+## Branch
+
+**1/** @p_mbanugo
+
+@rfleury
+
+Interesting! I was just reviewing code and thinking of solution when I read this tweet and realised "table + removing enum" solved it better than expecting the helper function to be used correctly.
+
+I need to bookmark this so that I re-read anytime I'm reaching for helper fns :)
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,38 @@
+---
+title: "@rfleury Do you have a code example of how you would compress / simplify something?"
+type: archive
+source: twitter
+source_url: "https://x.com/partnano/status/2062209120782966979"
+author: "bernie wick | FADING SERENADES OUT NOW"
+handle: partnano
+post_id: "2062209120782966979"
+date: 2026-06-03
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "@rfleury Do you have a code example of how you would compress / simplify something?"
+in_reply_to: ""
+parent_post_id: "2061619837877780961"
+---
+
+## Source
+
+- URL: https://x.com/partnano/status/2062209120782966979
+- Author: bernie wick | FADING SERENADES OUT NOW (@partnano)
+- Posted: 2026-06-03 16:25:43
+
+## Branch
+
+**1/** @partnano
+
+@rfleury
+
+Do you have a code example of how you would compress / simplify something?
+I think I agree, and really need to be more mindful in my next coding session about it, but there's nothing specific coming to my mind, reading your post 😅
+
+## Related
+
+- Spine: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
@@ -0,0 +1,38 @@
+---
+title: "The first way people usually learn code compression is by pulling common things out into helper functions, but in my view the complexity of adding a new entry point is often overlooked, and things quickly turn into a mess."
+type: archive
+source: twitter
+source_url: "https://x.com/rfleury/status/2061619837877780961"
+author: "Ryan Fleury"
+handle: rfleury
+post_id: "2061619837877780961"
+date: 2026-06-02
+archived: 2026-08-25
+draft: false
+tags:
+  - archive
+  - twitter
+  - rfleury
+description: "The first way people usually learn code compression is by pulling common things out into helper functions, but in my view the complexity of adding a new entry point is often overlooked, and things quickly turn into a mess."
+in_reply_to: ""
+---
+
+## Source
+
+- URL: https://x.com/rfleury/status/2061619837877780961
+- Author: Ryan Fleury (@rfleury)
+- Posted: 2026-06-02 01:24:07
+
+## Thread
+
+**1/** @rfleury
+
+The first way people usually learn code compression is by pulling common things out into helper functions, but in my view the complexity of adding a new entry point is often overlooked, and things quickly turn into a mess.
+
+It’s a useful exercise to try compressing code without helper functions, and instead merging similar work by using loops, tables, and reordering. In my experience this leads to dramatically simpler architecture, and it’s a lot easier to keep the whole picture in your head.
+
+Branches: [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-wizplum-what-about-polymorphism-and-inheritance]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-eron_wolf-i-like-giant-matching-functions-with-lots-of]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-jshurmer-very-well-said-it-would-be-useful-to-see-examples]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-Mallchad-ive-been-compressing-in-terms-of-section]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-polloimperial-i-got-a-mess-kind-of-working-fine-but-dirty-with]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-jrjnorton-do-you-have-an-example-or-a-before-and-after-by]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-gcoum-only-way-to-compress-is-dsl-vv-everything-else-is]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-0x6e616461-i-like-using-lambdas-or-local-functions-to]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-Arrghtv-i-completely-agree-adding-a-helper-function]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-SaladeTomate18-entry-point-you-mean-indirection]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-patrickgwsmith-i-like-this-as-it-maps-the-problem-with-input-on]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-vf42-never-thought-of-helper-f-ns-as-code-compression]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-MrModez-i-noticed-focusing-on-the-data-you-work-and-how]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-ChickenBurner2-oh-i-hate-helper-functions-especially-the-ones]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-alienorg-fewer-entry-points-fewer-surprises]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-anicic_filip-im-not-exactly-sure-what-do-you-mean-with-this]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-pbwinston-does-this-imply-if-you-took-an-external]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-sipubot-db]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-pegvvin-cant-tell-just-how-many-times-ive-pulled-out]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-guywald-100-agree-dry-can-be-extremely-overdone-llms-love]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-AlexAegis-yes-a-similar-problem-comes-when-you-follow]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-JoelStransky-ive-come-to-refer-to-declarative-as-just-fucking]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-ndwork-a-function-explicitly-limits-the-variables-that]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-katanadash-my-mental-model-for-this-are-you-putting-the-mess]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-02-Ravicale-ill-often-inline-every-helper-function-i-find]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-03-jeremdak-i-like-a-big-ass-on-my-functions]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-03-javiercbk-rad-debugger-is-easy-to-read-for-such-a-complex]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-03-0paperpal-will-love-to-read-a-long-article-on-this]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-03-partnano-do-you-have-a-code-example-of-how-you-would]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-03-p_mbanugo-interesting-i-was-just-reviewing-code-and]], [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code/2026-06-03-alecodex-can-you-share-an-open-source-project-that-follows]]
+
+**2/** @rfleury
+
+(It also naturally organizes work by computational requirements rather than abstract similarity, which simplifies code but also puts you in a much better position to make performance considerations)
@@ -9,5 +9,7 @@ tags:
  - rfleury
 ---

+- [[archive/threads/rfleury/2024-12-18-one-of-the-most-powerful-lessons-i-learned-as-a]]
 - [[archive/threads/rfleury/2025-04-30-to-the-degree-this-is-true-its-only-in-a]]
+- [[archive/threads/rfleury/2026-06-02-the-first-way-people-usually-learn-code]]
 - [[archive/threads/rfleury/2026-08-07-a-good-way-to-evaluate-one-axis-of-quality-of-an]]