DryIoc

[Casey Muratori @cmuratori]

Parser generators seem to have the longest unbroken losing streak in programming history.

[Jonathan Blow @Jonathan_Blow]

I hereby announce that I will be announcing an announcement 90 minutes from this tweet, at 9am Pacific time, over in the livestreaming place. Thank you!

https://t.co/W5yDbT8OZT

[Richard Feldman @rtfeldman]

First-ever Advent of Code solution in the new compiler, authored by @mattpiz! 🎉

This solution makes extensive use of some of the new features; `for` and `var` did not exist in the original compiler!

[Damian Płaza @raimeyuu]

@Aaronontheweb And pair it with hypermedia driven apps using @htmx_org or datastar by @DelaneyGillilan . Have plans to port your draw together app, but had no time 😔

[Aaron Stannard @Aaronontheweb]

V2 idea for this: Sponsorship Consequences

"We will drop .NET Standard 2.0 support unless we hit $15,000 / month in sponsorships"

[Aaron Stannard @Aaronontheweb]

Ah cool, so I suppose .NET users are going to run out and start contributing to / donating to projects with FOSS licenses - right? .... Right?

[Jonathan Blow @Jonathan_Blow]

We're looking for someone who wants to do a bunch of cool shader stuff on a game over the next 6-7 weeks. Ability to dive in and get stuff done quickly. Your work will be showcased in the gameplay videos / etc we use to promote the game. Compensation good. DM me for info.

[Jonathan Blow @Jonathan_Blow]

It has been a while since I uploaded a programming video to the You Tubes, so, here's one:

https://t.co/PQWtiD9V1r

[Vjekoslav Krajačić @vkrajacic]

"Some applications need performance"
- Literally the first thing you said in this video is wrong.

"It will have a profound effect on the structure and readability of your code, generally a negative one"
- Again, I could say the exact same thing about clean code and OOP.
- Readability and reasonable performance are not mutually exclusive.
- You don’t need to write in assembly to outperform most apps today.
- But you do need to reason about data structures and their memory layout, something that becomes impossible when everything is split into a million tiny classes doing their own thing.

When you say that most applications aren’t sensitive to microseconds, you’re missing an important point:
- It’s not about a single component doing its job in microseconds, it’s about the entire system working together.
- There’s a name for this, "death by a thousand cuts".
- You might think the cost of small inefficiencies is negligible, but your system ends up slow because every object is "thinking for itself".

"Most of us live in a world where our programs execute in human time."
- That’s for sure, and it’s painfully obvious when using modern software.
- Everything is slow enough to be noticed by the human eye.
- In fact, I could almost draw the frames on paper in real time, it’s that slow.

"Our machines are so fast today."
- Yes, but "our programs are even slower" by a huge margin.

Regarding the last part of your video, where you sneaked in a reference to Casey Muratori’s video without properly mentioning it:
- It’s honestly sad how disingenuous you are about this entire discussion, even after Casey put enormous time and effort into engaging with you on GitHub.

And one more thing that’s often overlooked:
- Good performance is a first order effect.
- But it can also be a gateway to second order effects, like new features or entirely different design decisions.
https://t.co/VVfdLHMD20

[Sebastian Aaltonen @SebAaltonen]

Unit tests have lots of advantages, but cons are ignored:
- Code must be split to testable parts. Often requiring more interfaces, which add code bloat and complexity.
- Each call site is a dependency. Test case = +1 dependency. Added inertia to refactor and throw away code.
...

[Łukasz | Wookash Podcast @wookash_podcast]

I am scheduling the discussion with @lemire on what makes CPU go brr.

If you have questions, (reasonable questions!), you'd like answered, let me know in the comments!

[Anna Rettberg @aerettberg]

Ugh, this one hurts. Lynch is not only one of my favorite directors, but one of my favorite creative minds. Twin Peaks, Eraserhead, Mullholland Drive, Blue Velvet. He was truly the master of dreams and nightmares.

[Łukasz | Wookash Podcast @wookash_podcast]

Just finished the conversation with @rfleury. Almost 3 hours, deep dive into debuggers, the man is a machine!

Anyone looking forward to hearing it?

[Jacob Christian Munch-Andersen @NoHatCoder]

I have released the first preview of my new hash and RNG functions called Tjald and Gesus. This project is an offshot of the Meow hash function that I codeveloped with @cmuratori. https://t.co/l4lZtkoR1s https://t.co/4XrO9nv14q

[Casey Muratori @cmuratori]

Best "Hello World" tutorial for Java by far!
https://t.co/PNhihIYsVR

[Ryan Fleury @rfleury]

Sum types in general aren’t great

https://t.co/MLKooyyP8a

[gingerBill @TheGingerBill]

https://t.co/jrZGrImxAu

[konrad @konradgajdus]

Minimal neural network in C

- preprocess
- training
- inference

200~ lines of code, standard library only

[Ryan Fleury @rfleury]

Programmers have internalized the idea that code reuse is inherently good, and there are no upsides—even temporary upsides—to duplication. This is false upon further inspection.

[Daniel Lemire @lemire]

Hotspot performance engineering fails:

Developers often believe that software performance follows a Pareto distribution: 80% of the running time is spent in 20% of the code. Using this model, you can write most of your code without any care for performance and focus on the narrow pieces of code that are performance sensitive.

This is wrong, empirically so.

The more you optimize, the more code you must consider. It is relatively easy to double the performance of an unoptimized piece of code, but much harder to multiply it by 10. You quickly hit walls that can be unsurmountable: the effort needed to double the performance again would just be too much. In effect, we have a long tail effect: though there are clearly easy wins, much of the work lies in the ‘tail’.

And that explain why companies do full rewrites of their code for performance: the effort needed to squeeze more performance from the existing code becomes too much and a complete rewrite is cheaper.

It also means that you should be acutely concerned about performance when you design your software if you want to avoid a rewrite.