FFmpeg makes extensive use of hand-written assembly code for huge (10-50x) speed increases and so we are providing assembly lessons to teach a new generation of assembly language programmers.
Learn more here:
github.com/FFmpeg/asm-lesson…
Andreas Dieling retweeted
DHH just declared Docker is annoying as a dev environment and used AAA game rendering an image in 8ms as a baseline for what's reasonable wait time for things
Andreas Dieling retweeted
Software decay is a great argument for careful planning and thoughtful use of external dependencies.
This was something I took very seriously from the start when writing File Pilot. Especially when you look at the lifespan of some long established file explorers, they often last for decades and still function properly. This is something many users don’t fully appreciate at first, but they grow to value it over time, especially when the software they purchased continues to work reliably years later.
That’s also one of the reasons I stand behind the prices I’ve set, because I’m not building this for two years, I’m building it for at least twenty.
File Pilot uses only a few single header libraries, checked out directly into the source tree.
- It doesn’t use a library to display windows or handle input.
- It doesn’t use a library to set up graphics.
- It doesn’t use a library to draw the UI.
- It doesn’t use a library for math, strings, or containers.
- Heck, it’s not even linking against the C standard library.
It does depend on quite a few Windows APIs, because of the nature of the app, it has to. But even there, I’m mostly using WinAPI features from the Windows XP era, which have proven stable over time. Microsoft actually did a reasonably good job in that area. But the things they built on top of it, like .NET, MFC, Windows Forms, WPF, and their latest abomination, WinUI, those change as the wind blows. And I’ve seen developers struggle to keep up with that.
On top of all that, File Pilot is built using C. It’s old, yes, but for this purpose, that’s a feature. The language spec changes infrequently (though even that is shifting a bit), but you can always stick to an older version like C99 or C11.
And long term software stability is just one of the advantages of building this way, you also get:
- better performance
- faster build times
- smaller binaries
- more control and freedom to modify the codebase
- deeper understanding of how everything works
I read this article about software development, which I knew about because I saw Prime reacting to it:
notashelf.dev/posts/curse-of…
For the most part I think it is fine: a relatively young programmer is doing the healthy work of introspecting on what he should really be doing.
But there's one part of the article that I think is a deep mistake, and the author doesn't know it's so wrong because he has never experienced the alternative:
"Software doesn’t stay solved. Every solution you write starts to rot the moment it exists. Not now, not later, but eventually. Libraries deprecate. APIs change. Performance regressions creep in. Your once-perfect tool breaks silently because libfoo.so is now libfoo.so.2. 2
I have had scripts silently fail because a website changed its HTML layout.
I have had configuration formats break because of upstream version bumps.
I have had Docker containers die because Alpine Linux rotated a mirror URL.
In each case, the immediate emotional response was not just inconvenience but something that moreso resembles guilt."
Yes, this is true in much of the programming world. But there is another world in which people build things that last much longer. I have done it many times. I shipped a binary for this game Braid in 2009 that you can still download and play on Steam 16 years later. If you are pretty young (like 35), you can run binaries on Windows that were compiled before you were even born, which is amazing given how hard they have been trying to f up Windows lately.
On an emulator like MAME, you can play arcade games programmed in 1979. If today's software "technology" is so much better, why does it fall apart like tissue paper?
The author is not wrong about the cited decay. But this decay is not inherent to the practice of software. It's due to choices made, usually foolishly, by the people designing the systems being interacted with. And, it's due to a lack of knowing better, non-exposure to the sector of programmers who are very concerned with their code lasting a long time, actually.
The way you make code last a long time is you minimize dependencies that are likely to change and, to the extent you must take such dependencies, you minimize the contact surface between your program and those dependencies.
The actual algorithms you program, the actual functioning machinery you build, is a mathematical object defined by the semantics of your programming language, and mathematical objects are eternal, they will last far longer than your human life. The goal then is to avoid introducing decay into the system. You must build an oasis of peace that is insulated from this constant bombardment of horrible decisions, and only hesitantly interface into the outside world.
This means, for example: If you are shipping on iOS, you only reluctantly use any functions iOS gives you, because when you use them, Tim Apple will come along and break your program next year for arbitrary pointless reasons, because Tim Apple does not respect you or anyone you know.
This means a program cannot last forever on iOS, because Tim Apple likes breaking your things and watching you submissively clean them up. But the core of your program, which could be 95% of the code, is fine, and you can deploy it elsewhere.
This means you have to insulate from Linux userspace, because of all the jackass decision making that introduces constant incompatibilities while somehow never making the system better.
Using a library dependency to do font rendering or sparse matrix math? That dependency gets checked into your source tree, a copy of exactly the version you use. Ten years later you can pull down that source and recompile, and it works, because your program is a mathematical object. If you want to upgrade to something newer that has bug fixes and so forth, you are free to do so, but you are also free not to do so, and your program still works. (And how many of these bug fixes do you really need? Your program worked correctly when you shipped it to the greatest extent you could measure, because you are a skillful software engineer who wants to ship things of a high quality).
Everyone who got into programming for the joy of it knows, at some level, that the magic of programs is that they represent complexity that is replicable over time (and thus they exist outside of time). But the trashy programmer culture of the past 20 years stopped aspiring to this, and now has forgotten it is even possible.
And so long as people have forgotten, decisions will continue to be made that make the problem worse.
There are programmers who only write glue code, and who think that's what programming is; to these people what I have written above will not make sense. But the good news for that contingent is, they can always just stop writing glue code and start doing something else! If today's software "technology" is so good, why do you think it needs so much glue? Maybe there is a stylistic problem.
So if you are looking for what to do in the world of software that can represent a lasting contribution, maybe this is food for thought.
@NotAShelf @ThePrimeagen
Andreas Dieling retweeted
You asked for it, so here it is.
Visualizing CPU cache speeds relative to RAM.
Cache optimization is important too!
Andreas Dieling retweeted
First raw samples of the simple paper packaging that C2D will ship inside, and the charge dongle (USB C -> standard Pebble charge connector) that will be included (Thank you @nomadgoods for designing it!)
Andreas Dieling retweeted
Trump and his administration now sound like Putin, so it’s fitting that the state propaganda channel is sounding as insane and belligerent as Kremlin television.
Andreas Dieling retweeted
The power line at Lake Pontchartrain, Louisiana, simply and clearly show the curvature of the Earth
Andreas Dieling retweeted
A) Yes
B) Myself and others have been sounding this alarm for over a decade
C) Many factors are at play, including an improperly trained workforce, monopoly business effects, and widespread adoption and standardization of low-quality practices, languages, platforms and protocols
Andreas Dieling retweeted
Visual Studio Code has done great work uniting many tribes of developers, but it is still a failure that it can’t single step python code as fast as I can hit the F-key.
Andreas Dieling retweeted
Doom in ‘93 is now basically equidistant from today and the dawn of computer graphics with en.m.wikipedia.org/wiki/Sket… in ‘63.
I always thought of sketchpad as ancient history; realizing this is causing some mental shifts!
Andreas Dieling retweeted
GPT-4 is getting worse over time, not better.
Many people have reported noticing a significant degradation in the quality of the model responses, but so far, it was all anecdotal.
But now we know.
At least one study shows how the June version of GPT-4 is objectively worse than the version released in March on a few tasks.
The team evaluated the models using a dataset of 500 problems where the models had to figure out whether a given integer was prime. In March, GPT-4 answered correctly 488 of these questions. In June, it only got 12 correct answers.
From 97.6% success rate down to 2.4%!
But it gets worse!
The team used Chain-of-Thought to help the model reason:
"Is 17077 a prime number? Think step by step."
Chain-of-Thought is a popular technique that significantly improves answers. Unfortunately, the latest version of GPT-4 did not generate intermediate steps and instead answered incorrectly with a simple "No."
Code generation has also gotten worse.
The team built a dataset with 50 easy problems from LeetCode and measured how many GPT-4 answers ran without any changes.
The March version succeeded in 52% of the problems, but this dropped to a pale 10% using the model from June.
Why is this happening?
We assume that OpenAI pushes changes continuously, but we don't know how the process works and how they evaluate whether the models are improving or regressing.
Rumors suggest they are using several smaller and specialized GPT-4 models that act similarly to a large model but are less expensive to run. When a user asks a question, the system decides which model to send the query to.
Cheaper and faster, but could this new approach be the problem behind the degradation in quality?
In my opinion, this is a red flag for anyone building applications that rely on GPT-4. Having the behavior of an LLM change over time is not acceptable.
Have you noticed any issues when using GPT-4 and ChatGPT lately? Do you think these problems are overblown?
Andreas Dieling retweeted
"Inflation has... pretty much come from nowhere."
-Christine Lagarde
European Central Bank President
They printed trillions of Euros and had negative interest rates for years. Now they pretend they didn’t cause any of it.
🔊
