More from Ralph Ammer
A large part of our civilisation rests on the shoulders of one medieval monk: Thomas Aquinas. Amid the turmoil of life, riddled with wickedness and pain, he would insist that our world is good. And all our success is built on this belief. Note: Before we start, let’s get one thing out of the way: Thomas Aquinas is clearly a Christian thinker, a Saint even. Yet he was also a brilliant philosopher. So even if you consider yourself agnostic or an atheist, stay with me, you will still enjoy his ideas. What is good? Thomas’ argument is rooted in Aristotle’s concept of goodness: Something is good if it fulfills its function. Aristotle had illustrated this idea with a knife. A knife is good to the extent that it cuts well. He made a distinction between an actual knife and its ideal function. That actual thing in your drawer is the existence of a knife. And its ideal function is its essence—what it means to be a knife: to cut well. So everything is separated into its existence and its ideal essence. And this is also true for humans: We have an ideal conception of what the essence of a human […] The post Thomas Aquinas — The world is divine! appeared first on Ralph Ammer.
Should we just live in the moment? In “Matter and Memory” the French philosopher Henri Bergson claims that this is not even possible. 1. Perception is physical First of all: How do we perceive the “current moment” anyway? Bergson suggests that the whole point of perception is action. For example, when some single-cell organism touches an obstacle, it moves away. That is the whole point of perception: to move in the right direction, to find food, to not be food—to survive. Perception serves future action, not insight. Accordingly, our brain is fully embedded in the material world and responds to the movements around it. Bergson refers to such a purely physical reaction as pure perception. Yet he acknowledges that we are more complicated than single-celled organisms. The movements of our environment have to make their way through our complex sensory system with all its twists and turns. And this leaves us more options on how to act. So we don’t just react like a single-celled organism, we can choose from a range of potential movements. But how? We remember. 2. Memory is temporal Bergson distinguishes two kinds of memories: Some memories have become part of our body, they are a […] The post Bergson — Why we live in the past appeared first on Ralph Ammer.
To “animate” means to breathe life into things. In these 5 exercises we make stones come alive. Preparation To get started I suggest this simple setup for you to try at home: Ready? Let’s go! Thinking in time Stop-motion is simple: Take a picture, move the object, take the next picture, move the object, etc. Once you are done, you can play back all those images as a little movie. Tip: You can do the following exercises exactly as shown here or play around with them. Just make sure to have fun! Exercise 1: Timing Turn a stone into a bouncing ball. Start with a stone above the middle of the page and hit the record button. Then move it down a little, take the next frame, move it again, and so on. Once it has reached the bottom, gradually move it up again until it is back to its starting position. Tip: At first you will notice that our steps are too big. As a result the animation plays way too fast! Just start over and make the steps smaller. Another tip: You can make the movement more natural by varying the distances. And you can make the “ball” […] The post A quick beginner’s guide to animation appeared first on Ralph Ammer.
You are awake. You think and you feel. But what is it that is doing all this thinking and feeling? We call it “consciousness” and over 100 years ago the philosopher Edmund Husserl made a bold attempt to uncover its secrets. Subjective experience is private The thing is: Consciousness is not “out there”, it is “in here“. It is personal and subjective. When I say that I like squirrels or that my foot hurts, then you will have to take my word for it. You can’t know what it is like to be me, and I cannot know what it is like to be you. Consciousness can only be observed from the inside, not from the outside. Since we can’t see the world through other peoples’ eyes, their experience remains deeply mysterious to us. Thus we all see the world differently. And this can lead to bitter conflict. Science is based on objective insight One way to overcome such conflict is to take an objective position. We take a neutral view from outside and focus on the things that we can all agree upon. We have learned to see ourselves “from the outside”. In fact, we can build a whole […] The post Edmund Husserl — Consciousness appeared first on Ralph Ammer.
More in programming
The use of std::string should be banned in C++ code bases. I’m sure this statement sounds like heresy and you want to burn me at stake. But is it really controversial? Java, C#, Go, JavaScript, Python, Ruby, PHP: they all have immutable strings that are basically 2 machine words: a pointer to string data and size of the string. If they have an equivalent of std:string it’s something like StringBuilder. C++ should also use immutable strings in 97% of situations. The problem is gravity: the existing code, the culture. They all pull you strongly towards std::string and going against the current is the hardest thing there is. There isn’t a standard type for that. You can use newish std::span<char*> but there really should be std::str (or some such). I did that in SumatraPDF where I mostly pass char* but I don’t expect many other C++ code bases to switch away from std::string.
This article was originally commissioned by Luca Rossi (paywalled) for refactoring.fm, on February 11th, 2025. Luca edited a version of it that emphasized the importance of building “10x engineering teams” . It was later picked up by IEEE Spectrum (!!!), who scrapped most of the teams content and published a different, shorter piece on March […]
Go team wrote golang.org/x/sys/windows package to call functions in a Windows DLL. Their way is inefficient and this article describes a better way. The sys/windows way To call a function in a DLL, let’s say kernel32.dll, we must: load the dll into memory with LoadLibrary get the address of a function in the dll call the function at that address Here’s how it looks when you use sys/windows library: var ( libole32 *windows.LazyDLL coCreateInstance *windows.LazyProc ) func init() { libole32 = windows.NewLazySystemDLL("ole32.dll") coCreateInstance = libole32.NewProc("CoCreateInstance") } func CoCreateInstance(rclsid *GUID, pUnkOuter *IUnknown, dwClsContext uint32, riid *GUID, ppv *unsafe.Pointer) HRESULT { ret, _, _ := syscall.SyscallN(coCreateInstance.Addr(), 5, uintptr(unsafe.Pointer(rclsid)), uintptr(unsafe.Pointer(pUnkOuter)), uintptr(dwClsContext), uintptr(unsafe.Pointer(riid)), uintptr(unsafe.Pointer(ppv)), 0, ) return HRESULT(ret) } The problem The problem is that this is memory inefficient. For every function all we need is: name of the function to get its address in a dll. That is a string so its 8 bytes (address of the string) + 8 bytes (size of the string) + the content of the string. address of a function, which is 8 bytes on a 64-bit CPU Unfortunately in sys/windows each function requires this: type LazyProc struct { Name string mu sync.Mutex l *LazyDLL proc *Proc } type Proc struct { Dll *DLL Name string addr uintptr } // sync.Mutex type Mutex struct { _ noCopy mu isync.Mutex } // isync.Mutex type Mutex struct { state int32 sema uint32 } Let’s eyeball the size of all those structures: LazyProc : 16 + sizeof(Mutex) + 8 + 8 = 32 + sizeof(Mutex) Proc : 8 + 16 + 8 = 32 Mutex : 8 Total: 32 + 32 + 8 = 72 and that’s not counting possible memory padding for allocations. Windows has a lot of functions so this adds up. Additionally, at startup we call NewProcfor every function, even if they are not used by the program. This increases startup time. The better way What we ultimately need is uintptr for the address of the function. It’ll be lazily looked up. Let’s say we use 8 functions from ole32.dll. We can use a single array of uintptr values for storing function pointers: var oleFuncPtrs = [8]uintptr var oleFuncNames = []string{"CoCreateInstance", "CoGetClassObject", ... } const kCoCreateInstance = 0 const kCoGetClassObject = 1 // etc. const kFuncMissing = 1 func funcAddrInDLL(dll *windows.LazyDLL, funcPtrs []uintptr, funcIdx int, funcNames []string) uintptr { addr := funcPtrs[funcIdx]; if addr == kFuncMissing { // we already tried to look it up and didn't find it // this can happen becuse older version of Windows might not implement this function return 0 } if addr != 0 { return addr } // lookup the funcion by name in dll name := funcNames[funcIdx] /// ... return addr } In real life this would need multi-threading protection with e.g. a mutex. Saving on strings The following is not efficient: var oleFuncNames = []string{"CoCreateInstance", "CoGetClassObject", ... } In addition to the text of the string Go needs 16 bytes: 8 for a pointer to the string and 8 for the size of the string. We can be more efficient by storing all names as a single string: var oleFuncNames ` CoCreateInstance CoGetClassObject ` Only when we’re looking up the function by name we need to construct temporary string that is a slice of oleFuncNames. We need to know the offset and size inside oleFuncNames which we can cleverly encode as a single number: // Auto-generated shell procedure identifier: cache index | str start | str past-end. const ( _PROC_SHCreateItemFromIDList _PROC_SHELL = 0 | (9 << 16) | (31 << 32) _PROC_SHCreateItemFromParsingName _PROC_SHELL = 1 | (32 << 16) | (59 << 32) // ... ) We pack the info into a single number: bits 0-15 : index of function in array of function pointers bits 16-31: start of function name in multi-name string bits 32-47: end of function name in multi-name string This technique requires code generation. It would be too difficult to write those numbers manually. References This technique is used in https://github.com/rodrigocfd/windigo win32 bindings Go library. See e.g. https://github.com/rodrigocfd/windigo/blob/master/internal/dll/dll_gdi.go
How a wild side-quest became the source of many of the articles you’ve read—and have come to expect—in this publication
Watch now | Privilege levels, syscall conventions, and how assembly code talks to the Linux kernel