phaedrus

This is timely for me, since a web forum I care about went offline, and I simultaneously discovered the Wayback Machine for whatever reason never crawled most of it. I asked Claude to try to put together a static site of what could be salvaged from various archives and other sources, but as miraculous as what AI can do these days, it can't restore data that is truly gone - so what it was able to salvage is better than nothing but still missing a lot.

There was this persistent meme in bodybuilding discussions - I don't know if it's still a thing - to say about steroids "well they're just a shortcut". The justification that it just got you faster to where you could have gotten slower naturally was used by former steroid users to justify themselves, as an accusation of cheating, as an accusation of laziness, and as hope for dreamers who go to the gym but do not see those extreme results. In reality, steroids do allow some to achieve a body that would not be possible under a natural/genetic with any amount of time due to how anabolism and catabolism balance and scale.

I think there's a lot of parallel with experienced programmers using LLMs and that idea about steroids that it just gets you there faster. I'm pretty sure I could eventually program most of the things I've used AI to write, and what it produces at the top end I/you can't really prove that I wouldn't have thought of it. But is that really true?

Someone should make a parody site asking whether shades of yellow are red or violet.

If we had super-smart AI with low latency and fast enough speed, would the perceived need for / usefulness of running multiple agents evaporate? Sure you might want to start working on the prompt or user story for something else while the agent is working on the first thing, but - in my thought experiment here there wouldn't be a "while" because it'd already be done while you're moving your hand off the enter key.

Mindstorms and the original RCX were a huge part of my college memories; I had a professor who used them for one of our classes. I built a substantially large "dragon" robot where the head + neck were actually a robot arm that could grip things, and it moved on treads. It took three RCX's "networked" together to get enough inputs and outputs for all the motors and functions. I accomplished the 3-way communication by making a parabolic reflector for the IR out of white cardstock; the three RCX's sat side by side and all aimed at the same reflector. The one in the middle controlled the outer two; each knew to only reply based on the first part of the message, so there was no contention.

I left that model with university which they kept as a display; I felt a little guilty having used up most of three Mindstorms sets for my project. Later I bought my own Mindstorms set, and then one of my then-wife's coworkers - whom we didn't know, and I don't know how she knew of me - randomly gave her a 2nd Mindstorms set to give to me. I keep meaning to re-create this dragon robot someday, leaner so it only takes two RCX. I have a lighter design now for the gripper + wrist section which, like the rocket equation, would allow the whole rest to be smaller if the last stage is smaller.

I once attended a talk by someone who is or was big in the node.js world. He opened with the premise, "a static type check is just a stand-in for a unit test."

I wanted to throw a shoe at him. A static type check doesn't stand in for "a" unit test; static typing stands in for an unbounded number of unit tests.

Put another way, this common misconception by users of languages like Javascript and Python that unit testing is just as good as type checking (plus more flexible) is a confusion between the "exists" and "for all" logical operators.

When I was trying to improve compile time for my game engine, I ended up using compiled size as a proxy measure. Although it is an imperfect correlation, the fact that compiled size is deterministic across build runs and even across builds on different machines makes it easier to work with than wall clock time.

This framework is a good example of something I call, "there's plenty of room in the middle." (In analogy to Feynman's "plenty of room at the bottom" about nanotechnology.)

Much like how Cosmic Inflation in the early universe left the imprint of microwave background radiation written exponentially large across the sky, I believe the exponential expansion of computing during the era of Moore's law left whole sections of scale in software not-fully-explored.

Specifically, as "average app sizes" went from 1K - 10K - 100K - 1M - 10M - 100M+, you could imagine the 1K-10K got fully explored because the space wasn't that big to begin with, and the 1M - 10M range got, if not explored at least inhabited, but it could be that that middle range of "neat applications that weigh in ~100K+ but less than 1M" didn't get completely explored because we didn't spend enough time in that era of computing.

A similar thing may be playing out in AI scaling, where we went from tiny to medium to huge model sizes, but now some new participants are going back and doing neat things with medium sized models.

See also: https://github.com/nucleic/kiwi

I want so much to be in the business of selling my own traditional downloadable software, that I've thought about (in the absence of an idea) just putting together a do-nothing application with payment, installer, configuration dialogs, bug feedback - everything but a raison d'etre.

The irony is in my day job I am developing a traditional downloadable Windows application which will come with an immediate user base. But although I have considerable discretion over the project, it isn't mine (in an intellectual property sense), and I'm not getting rich off it.

Four companies. The doctor's office which may be controlled by profit-optimizing administration, the big profit pharma corporation, the for-profit medical insurance company, and the company the insured works for who picks the available insurance plan(s).

Not every case of reflux is caused by the same things. Some people's esophageal sphincter (such as mine does) just... decides to let go at random times. For me, that I can tell, the frequency of that happening isn't really affected +/- by the PH of my stomach acid, but the PH sure has an effect on the consequences.

I am assuming the best thing I can do for it is lose weight, but that's easier said than done.

50K context is an interesting number because I think there's a lot to explore with software within an order of magnitude that size. With apologies to Richard Feynman, I call it, "There's plenty of room in the middle." My idea there is the rapid expansion of computing power during the reign of Moore's law left the design space of "medium sized" programs under-explored. These would be programs in the range of 100's of kilobytes to low megabytes.

But the G in AGI stands for General. I think the hope is that there is some as-yet-undiscovered algorithm for general intelligence. While I agree that deferring to a subsystem that is an expert in that type of problem is the best way to handle problems, I would hope that it is possible that that central coordinator not just be able to delegate but design new subsystems as needed. Otherwise what happens when you run out of types of expert problem solvers to use (and still haven't solved the problem well)?

One might argue maybe a mixture of experts is just the best that can be done - and that it's unlikely the AGI be able to design new experts itself. However where do the limited existing expert problem solvers come from? Well - we invented them. Human intelligences. So to argue that an AGI could NOT come up with its own novel expert problem solvers implies there is something ineffable about human general intelligence that can't be replicated by machine intelligence (which I don't agree with).

It's not hearsay; I have a few engineer coworkers whose original job and training wasn't in tower climbing who now climb a couple times a year as installations require. I have seen their Powerpoint presentations, with pictures. Two of them are older and experienced in RF/telecom, but I have one younger coworker who went to a site and was asked to climb a tower and just - did it.

One older coworker is quite enthusiastic about it (as a mechanical engineer, he designed some of the custom rigging), so perhaps this is a case where he does it because he wants to & demonstrated aptitude so they let him. He actually decided to on his own to stop when a recent near miss made him question "why the hell" he isn't leaving this to professional riggers.

I don't know how/why my younger engineer coworker ended up doing it. Both her parents are in this same field and I know she feels a lot of pressure to excel and not say no to things. And when we come out to help a site there's a lot of pressure to restore service. So she may have agreed or even volunteered but not for the right reasons.

It may though be a case where no one thought to mention to me that this isn't a required thing, that some are doing it because they want to, etc. My coworkers aren't always good at realizing what new employees don't know, and I'm not good at picking up nuance.

But I definitely was "voluntold" to go out to a site and cut cables, which is a specialty technique I'm not properly trained in and would've taken place outside in the elements. (Did I mention I'm a programmer, a profession I chose in part because it takes place indoors? I also have undiagnosed/self-diagnosed dyspraxia; it would have been a disaster.) Thankfully the trip got canceled for other reasons, but my point is I wasn't asked; I was just told we need to send someone so you're going.

From the article: "Some broadcast engineering tasks are a bit too daunting for me to consider. Climbing the massive towers that power radio and TV stations is one of them!"

I work for a team in a government agency that does engineering support for RF based navigational aids. Because we're short staffed (Congress underfunds us), everyone fulfills more jobs than their official title. (There's an elastic clause in government worker job descriptions, "and other duties as assigned.")

Anyway. I live in fear of the day I'm called upon to climb a tower because they need me to do that. My regular job is software development! Obviously I'm not going to do it, but I'm unsure what my rights are / what will happen if and when I refuse. Unfortunately my position isn't union protected because my older peers didn't sign on when the (non-computer science) engineers did.

When I was still in school I scored over 900 on a reading speed test. For those skeptical how this is possible, I don't read linearly my eyes make saccades and groups of words come piling into my brain like someone dumped a bucket of Scrabble tiles. There seems to be a long "pipeline" wherein the words from different lines and different order in the sentences get reassembled into meaning. After reading something very quickly if I look away the information is sort of still "digesting" for some time.

(I seem to have a good size memory buffer for this which no doubt has to do with enabling the speed reading. I remember in typing class classmates were amazed that the way I transcribed assigned text was to read a half a page or more and type it all out verbatim before going back for another chunk. Until they pointed it out I didn't think that was anything special.)

I will admit that at 900 WPM I wasn't getting 100% of the material (albeit enough to get 90% on the comprehension test - which is less than 90% of the source material, just enough source material to reconstruct 90% of the gist). I was really trying to see how fast I could go, since it was computer graded and I could gamify it. (I did get a different text to read and questions to answer about it each time; I wasn't re-reading the same text.) Through this same exercise I learned my comfortable reading speed was 200 - 300 WPM and speed reading without loss of comprehension (just requiring effortful concentration and/or impatience) was around 500.

As an adult I'm certain my reading speed is NOT that fast anymore, and I often find myself re-reading text I just read.

In context I assumed GP comment meant gut feeling is a lagging indicator rather than predictive.

Orbiting has more to do with velocity than altitude.

Can confirm female tortiseshell cats are, yes- lunatic is the best way to describe their personality. My family had several and they were all a combination of smart and crazy, mostly the latter. As a teenager I found it amusing to teach one of them to ride on my shoulder like a pirate's parrot. An unintended consequence is that she would also do that to house guests, who weren't expecting it, making a five foot vertical leap from ground level from behind to perch on their shoulder.

I recently learned of this new-design PC XT clone motherboard, which comes with a VGA card. I imagine this software is perfect for that system.

https://monotech.fwscart.com/product/nuxt-v2-0---microatx-tu...

Does mind wandering in this context refer to daydreaming or does it refer to blanking out? As someone with late-diagnosed ADHD and likely also on the spectrum, I find myself struggling with both of these. I engage in a lot of Walter Mitty-esque hyper realistic daydreams, but I also have random periods of minutes of completely blank mind. Both result in a lot of "lost time" for me throughout the day. It runs in my family such we refer to it as "the our-surname fog".

Skimming this paper it's unclear to me whether the author is referring to one or the other, or both.

Interestingly I'm not sure that the mind wandering is separable from my creativity and problem solving. Often I'll come out of a blank period with the answer to something without consciously having been thinking about it. I think of these periods of "lost time" in my day as background processing - it's just my misfortune I live in a world where it's not socially or economically acceptable to space out for long periods throughout the day.

Iain M Banks: (spoilers) the narrator is secretly an AI

I recently wrote an ANTLR4 parser for RC files, as part of software archeology on a legacy codebase I support. Considering how many programs over the last 30 (35?) years exist that use the Windows resource compiler, it's surprising how little in-depth information and how few open source alternative tools exist for it. So I'm really glad to see both the information and the project in this post.

Instead of an Overton window imagine an Overton amoeba. Microsoft, as a monopolist, has for two decades been pushing out pseudopods in all directions against the boundaries of acceptable behavior for an operating system. ("All" directions, but overall in the direction of more corporate surveillance and less control and visibility for users, as well as profligate resource use.) So it's not that the bar was higher or lower in the past, just that the amorphous shape of the effontery is pushing out a new lobe.

(With the caveat I haven't read OP article yet) I was enamored of using relational programming for a games engine for many years. Ultimately I concluded it would be better to code such an engine in C++ and write custom solvers for just the aspects you want to be relational, rather than do the whole game in a general purpose relational language.

The resolution algorithm(s) implemented by a general purpose logic programming or relational language are not the only ones possible, and being more general may not be efficient for the type of problem you want the game engine to solve efficiently. Conversely extending a logic programming language to natively include these features may invalidate simplifying assumptions or require a change in evaluation order that makes the language impossible to implement as simply or efficiently.

A concrete example (of extending logic programming with game specific features):

I wanted to both use logic programming relations and also linear constraints, so that you could say something like "A <= (B-10.0) .OR. B <= (A-10.0)" which you could picture as constraining the position of the centers of two width=10.0 game objects so that their boundaries do not overlap, but you don't care which is in front of the other. (Statements like this would be used to build up a scene or more complex game object qualitatively, without pinning down exact coordinates rather letting the linear constraint solver pick them.)

Since running the linear constraint solver to resolve something like "f(A) <= g(B)" actually (potentially) updates all of the interrelated variables (A or B might also have constraints against C,D,E,F), running it as soon as you pick the LHS or RHS of the logic expression "prop(X) .OR. prop(Y)" could potentially invalidate propositions elsewhere previously committed to. So what you probably want to do is, rather than interpreting the "<=" on linear variables as a test with a boolean result, interpret it as a command to add "f(A) <= g(B)" to the global store of linear constraints, and then at some later time run the solver on the complete matrix of linear variables.

That leads to design questions like how does the language know when it's done adding constraints and time to solve, what if we really do need a logic clause to depend on testing a value not constraining it, etc. But all of that's just a distraction from the real issue, which is that for the case of BOTH the linear constraint solving and the logic programming, in the context of a game engine we really need to have more control over both when lengthy computation is run and how long it runs.

That is, even if we design a good way for the extension features to run from the POV of the logic language, from the POV of the outer system we still have the problem of sometimes the search time to resolve part of a logic program blows up and it's difficult for the programmer to always predict when/where that will happen. In this sense it's not even required that hand-rolled imperative code be faster, it can be slower - as long as it's predictable.

And in reality you wouldn't even necessarily be hand-rolling it; what I'm talking about is whether the rules engine is a solver that is externally driven (and pre-emptible) by imperative game code, or the whole game runs within the "solver" (i.e. relational language). As tempting as it is to imagine what could be done if literally "the whole" game were relational, the fact is using that technology for a whole game implies a magic relation solver that doesn't actually exist.

I wonder if this could be used in a build step to bring a Sqlite DB in a project's "bin/" folder up to date with a source-controlled copy without just overwriting the whole file. Size of the DB file is one issue, but also I'm thinking there could be cases (like having a connection open in Sqlite Studio, or a running instance of the project executable) where a simple copy would fail the build step. (This sqlite3-rsync specifically supports working while other connections are open.)

If so, it solves a real problem I've been having for eight years.

"Concurrency != parallelism" is an important distinction in this context. The base C++ coroutines feature is not about threads or parallel processing, but rather is a generalization of the concept of "subroutine" with respect to control flow and stack usage. An example using coroutines to service many tasks (if not otherwise involving threading features) is not much different (at the level of what the CPU sees) from a single threaded implementation using a loop or continuation passing to process concurrent tasks. Performance should be identical between both the language-supported coroutines code and the manually implemented single threaded loop if the work is batched the same.

That's good, then. Honestly an integer rect for the viewport is, "not wrong."

Does SDL3 still use integers for coordinates? I got annoyed enough by coordinates not being floating point in SDL2 that I started learning WebGPU, instead. This was even though the game I was working on was 2D.

The issue is, if you want complete decoupling (in the sense of orthogonality) among all four of:

- screen (window) size & resolution (especially if game doesn't control)

- sprite/tile image quantization into pixels (scaling, resolution)

- sprite display position, with or without subpixel accuracy

- and physics engine that uses floating point natively (BulletPhysics)

then to achieve this with integer drawing coordinates requires carefully calculating ratios while understanding where you do and do not want to drop the fractional part. Even then you can still run into problem such as, accidentally having a gap (one pixel wide blank column) between every 10th and 11th level tile because your zoom factor has a tenth of a pixel overflow, or jaggy movement with wiggly sprites when the player is moving at a shallow diagonal at the same time as the NPC sprites are at different floating point or subpixel integer coords.

A lot of these problems could be (are) because I think of things from bottom up (even as my list above is ordered) where a physics engine, based on floating point math, is the source of Truth, and everything above each layer is just a viewport abstracting something from the layer beneath. I get the impression SDL was written by and for people with the opposite point of view, that the pixels are important and primary.

And all (most) of these have solutions in terms of pre-scaling, tracking remainders, etc. but I have also written an (unfinished) 3D engine and didn't have to do any of that because 3D graphics is floating point native. After getting the 2D engine 90% done with SDL2 (leaving 90% more to go, as we all know), I had a sort of WTF am I even doing moment looking at the pile of work-arounds for a problem that shouldn't exist.

And I say shouldn't exist because I know the final output is actually using floating point in the hardware and the driver; the SDL1/2 API is just applying this fiction that it's integers. (Neither simple, nor direct.) It gets steam coming out my ears knowing I'm being forced to do something stupid to maintain someone else's fiction, so as nice as SDL otherwise is, I ultimately decided to just bite the bullet and learn to program WebGPU directly.