i-use-nixos-btw

I think ignoring it completely is a viable strategy once you've already gone through the stages - when your mind is in the right place.

I have moved on a long way from the days that 12 factor was my bible, but those days completely redefined my way of developing software. I'm not exaggerating here - it completely shifted my approach.

I guess it's similar to Scrum in that way - it isn't a great end point, but if you're stuck in the old ways (i.e. the methods used before it was even a thing) then it's at least a good approach to sink your teeth into, try it out, shape your approach, and move on from there.

Basically, I'd rather see a replacement that improves on 12 factor than throwing out the book entirely.

I’m not a ML person so forgive my ignorance here.

It looks interesting, but I’m slightly confused about the way this is presented. It feels like it’s coming from the wrong angle.

Specifically, reducing a time series to a sequence of patterns and trying to predict what happens next is something that has been done for decades in some form or another. To me the unique aspect of this is that it fits the approach into a transformer.

So I’d expect to see comparisons against other approaches that do the same thing, not against other transformer approaches.

I wouldn’t be confused if the title was “Inverted Transformers are MORE EFFECTIVE THAN NORMAL TRANSFORMERS For Time Series Forecasting”.

However, if the target audience are transformer folk then it makes sense, it just seems that I’m looking at it from the other direction.

In order to eat through over 99.99% of the price, this isn’t a low-mid market volume. It’s non-existent market volume.

I’ve worked on everything from the ultra liquid equity futures markets down to the shittiest of shitcoins imaginable and these numbers just don’t make sense at all. There’s a paradox: your valuation implies an active market and your execution implies a dead market.

When shitcoin markets die, they die at small fractions of a cent, and there are lingering sell orders in from people who got caught in the pump’n’dump and live under the false hope that their superconductorcoin will be worth something later on, which then removes the possibility of any remaining large-price buy orders. So for your valuation to be that high, it can’t have been a dead market.

But for your execution to be that low, it has to have been one.

I can’t truly believe that someone who is smart enough to build a system that accidentally stays functioning in the background for that long (I’ve never seen such a thing) is silly enough to calculate valuations so naively.

I’m not sure what I’m finding harder to believe here. That one could lose more than 99.99% due to a timing fat finger (even on a quiet market - 11m over 30 minutes eating through the order book?), or that an arb bot that you forgot about managed to run for that long on a server without hitting endpoint changes, API changes, re-auth requests, etc.

So a fire in a s*t factory.

At least it is a welcome distraction from the very similar thing going on in Manchester Central this week.

I’m not a rust dev, but looking into how the Debug trait works, it’s basically what we’d need compile time reflection to get in C++.

It generates code that uses the class name and class members. In C++ we have no way of doing that (without hacky macro stuff).

(2) is a point I firmly agree with (though not everyone does), but it’s a hard one.

Here’s the way I think about it. I don’t think I’m wrong but I’m absolutely open to being told otherwise.

C++ is a language. It has a standard library. The library depends on the language, but the language shouldn’t depend on the library. This is because many applications cannot use the standard library, or parts of it.

The conceptual issue with fstrings in C++ is that the formatting is done on a library level. An fstring would be a language feature. It wouldn’t be reasonable for syntax sugar to resolve to a library call.

So what we’d need is a way of having parameterised strings that the language knows to separate out into parameters in a function call. For instance:

f(f”Hello, {planet}”);

would resolve to:

f(“Hello, {}”, planet);

such that replacing f with std::format, std::print (C++23), fmt::format, fmt::print, spdlog::info, spdlog::error, or even scn::scan (?), would do exactly what you want.

However, the expression f”Hello, {planet}” would be meaningless on its own, and care would need to be taken to avoid:

std::string x = f”Hello, {planet}”;

from resolving to:

std::string x = “Hello, {}”, planet;

Which would be equivalent to

std::string x = planet;

Thanks to C++‘s ludicrous comma operator.

OTOH, in many of the cases where “isn’t safe” IS relevant, the developer believes it isn’t.

Not until we get reflection. And reflection efforts seem to be at an impasse, so I don’t imagine we will see it for a few years at least.

I will add, though, that I’ve found copilot to be very handy when it comes to generating formatting. Last week I used it while writing fmt::formatter specialisations for a library with 50 structs, some having over 20 members. Writing all of them took about 10 minutes. I dare say the same would hold for operator<< overloads.

I always wondered the same thing. But my theory wasn’t bandwidth, it was power, cost and (perhaps) weight.

I had no idea that we still monitored these things from the ground.

A common retort to this is that companies also exist to compete (and thus make a profit), so those that use AI to augment their staff rather than replace them will be at an advantage.

Honestly, I can see it, but there are definitely SOME jobs at risk, and it will almost certainly reduce hiring in junior positions.

I am a manager in a dev team. I have a small team and too many plates spinning, and I’ve been crying out for more hires for years.

I moved to using AI a lot more. ChatGPT and Copilot for general dev stuff, and I’m experimenting with local llama-based models too. It’s not that Im getting these things to fill any one role, but to reduce the burden on the roles we have. Honestly, as things stand, I’m not crying out for more hires any more.

This stuff reminds me of the days when it was trendy to put a swingy ball that follows the cursor. It’s technically cool (as in “hmm how did they do that?”) but it adds little to the experience aside from concentrated cringe.

I absolutely do not want animations that emerge when scrolling down a page. Im scrolling because I want a linear view of things, and the silly animations take away my control of the experience.

I have yet to read it, but it looks and feels like more of a review article than anything claiming to be progressing the field.

The thing I find interesting about the idea of the paper (again, haven’t read it, so this is an assumption) is that there are philosophy academics who don’t put consciousness on a hand-wavy metaphysical pedestal. More of that please.

If you have to explain that you aren’t being sarcastic when you congratulate an effort, you know you’ve pushed too hard in the other direction.

Yeah, though that’s also kind of my point. You know and I know (having learned the hard way) that the mechanism involves storing parameters and intermediate values in an object that is referred to later. It’s obvious now I know, but the design hides that from the user - they aren’t supposed to care about that. However, the footguns are still present. There should have been language features to prevent temporaries binding to const& for coroutines, but (according to a friend) the language doesn’t distinguish coroutines and subroutines at that level (… or something?)

Same problem with ranges. The footguns are remnants of abstracting something complex with a friendly interface and failing to secure it. It’s great for people who know the implementation, and it’s obvious where memory issues appear - but if you don’t know the implementation then you end up with holes in your feet.

It is due a bit of proof reading. There are some readability issues.

That being said, it is a great article. C++ and coroutines is a story that has been going on for a long time, and the result surprised me. In a bad way.

One bit me right from the start. I copied out an example and it crashed, and it turned out (after hours of searching, reading - the compiler and sanitisers sure weren’t any help) that the problem was that I’d inadvertently made a parameter const& (force of habit) and bound a temporary to it.

My answer to this is simply that I choose not to use coroutines. If I can’t force a compilation failure when I do something dumb, that spooks me.

For a feature released in 2020 it has far too many footguns. Ranges was similar when it came to lifetime footguns. It’s just something that makes it hard to take seriously the claims that it is legacy code that is the reason C++ has a bad rap for safety. Coroutines and ranges are modern features that can shoot your foot off if you don’t know the implementation, which is kind of contrary to the point of making a friendly wrapper over it all.

(To the other comment - yes, this being fraud would be an exception to the above. I am assuming it was done in good faith. If it turns out that it was intentionally designed to be misleading, then that changes things - and would be monumentally stupid of them, because publishing a method to a groundbreaking result on a preprint server is a sure-fire way of getting caught out)

Anyone who is afraid to be wrong shouldn’t entertain the notion of becoming a scientist.

If it turns out they’re wrong, then they will likely do a follow up paper that explains what their mistakes were. No biggy. It’s just a couple of preprints, after all, and it’s widely believed that it was pushed out without all of the authors’ consent in the first place. It won’t leave them with lasting reputational damage from their peers, though it may place slightly more scrutiny on their outputs at a later point.

They may get ridicule from the people who took their paper at face value without noting the informality of the format, the incomplete studies performed on the sample, the almost-clear methodology etc. But those people aren’t scientists - all of the scientists who have discussed this have assumed from day one that it is likely an error, and perhaps toyed around in case their assumption is wrong.

To have reputational damage, they’d need to refuse to retract their work, refuse to elaborate further, claim they invented room temperature superconductors without sufficient proof, then attack anyone who questions them.

I don’t know, I think the cloth thesis looks like a good read, and Hans Einstein seemed to have had a very successful career.

I may be wrong, but I can’t imagine that any ridiculously gifted parent would care the slightest if their children fit the boots they leave behind. The hopes I have for my son is that he is happy, healthy, moral and enthusiastic. If he develops an interest in physics, electronics, programming, or any other thing we can nerd out together about, that’d be great - but if he develops a deep interest in whatever, that’s cool too. It would admittedly be very difficult for me to communicate with him if he doesn’t develop enthusiasm for anything.

At the moment he is leaning towards geology, but that’s because he’s 2 and likes collecting stones.

This is why I self-host. I don’t like the idea of buying something and having no control over how I use it, where my data goes, etc.

I strongly urge anyone with a tech interest to get a Raspberry Pi (now that they’re widely available again) and install HomeAssistant. Many of your devices will work through the many plugins available. If you can get your head around Python coroutines (… I can’t but I bodged it) you can implement your own.

Some devices will still need to send data to a central server to work, but you can often integrate their APIs until such a time that the service is discontinued. Then search out devices that are known to work with HomeAssistant.

I strongly agree.

Once upon a time, I was in condensed matter physics. I was (and remain) interested in a very specific niche within that, and I read a small handful of the papers that were published each week. I’m not actively researching or publishing anymore so I cap this to one or two per month now, and mostly scan over them to see if anything piques my interest.

I was still interested in condensed matter as a whole, at the time, and attended group seminars once a month to see what other people were currently excited about - there wasn’t any hope of me reading a cross section of all condensed matter papers because there is far more published per week than I’d be physically able to even glimpse at, and most of it is stuff I don’t understand or particularly care about.

I was likewise interested in physics as a whole, and twice a year I’d attend a departmental seminar and see what people in the entire department were interested in. Most was far over my head, but it still directed me to a small handful of papers that I’d read for the hell of it. Of course, I couldn’t do this without first hearing people review the research. There’s far more published per day in physics as a whole than I could read in a year, and most of it I’d find unrelatable and uninteresting.

I guess where I’m going with this is that anyone with a specific interest is already reading papers. It’s their job. Anyone with a general interest would find actively pursing paper hunting to be a waste of time with a ridiculously bad signal to noise ratio. Instead, they should use channels that align closely with their own interests, through which they can get recommendations to read papers from the aforementioned specialists who have already filtered out much of the noise themselves. At that point, they should actually read the resulting papers.

There is another trick, though, and that’s to find an individual who publishes two unrelated pieces of work that you find interesting, then read their work and maybe those of their coauthors. Be careful, though, because this is a slippery slope to specialising, after which you’ll find yourself back at the point where you don’t aren’t following 99.9% of the stuff you wanted to follow in the first place.

Measuring is a highly subjective and personal experience in general.

As a physics undergrad I had a fascinating discussion with a lecturer on metrology. I always used SI units, my friend always preferred natural units, and the lecturer used gaussian units frequently (which always threw me off).

My position was that SI is the only reasonable measuring system because it’s a widely accepted standard, has no silly conversions, and bears resemblance to things we experience in every day life. I can space my hands apart by a metre through guesswork and I’m generally quite close, but centimetres or inches I’m awful at (any excuse, eh?). I can judge how many kilograms something is but not grams or pounds.

“Ah,” said the lecturer. “But these are units you are familiar with because they match your everyday experiences. In mine, statVolts etc are the most natural thing in the world - I don’t have constants where I don’t need them, and my numerical results are at a comfortable order of magnitude”.

“The most natural thing in the world are the universal constants - planck’s constant, the speed of light, the charge on an electron”, countered my friend. “If I measured something in those, anyone or anything in the universe, under any physical conditions, can recreate my measurements. If civilisation ended and my calculations were discovered millions of years later by an entirely new intelligent species, they would understand it with enough legwork”.

I quickly became a proponent of natural units. But then 50mph signs being renamed to 7.46e-8 might not go down well with the highways agency.

Anyway, the point of this story is that measurements are measurements, as long as they’re consistent. It isn’t about intellect, it’s about what you’re working with, what you normally work with, culture, and all kinds of things. If you have a 17 yard thingamagig and need 2ft clearance on one side and 5in clearance in the other, then this is a perfectly reasonable task to ask a computer with a teraflop or so of computational power.

It seems like a contradiction, but is not.

Many things are measured on a scale that goes from mild, to moderate, to moderately severe, to severe.

I would love to see it too.

Papers about failed experiments are worth a lot more than no papers about failed experiments. Alas, it is rare.

Ah, yes, that makes sense! I'm thinking about framework from the wrong angle.

I can definitely see why that's a bonus. So many data pipeline tools, but so many written in Java. It's for that reason that I've always reinvented the wheel. Perhaps I'll check this out...

I run into that problem a lot, to be fair.

Though my approach is to fork and maintain the fork until my PR is accepted, merged, and in a tagged release.

Another is to apply a diff to the dependency within the build system, which is what I do a lot in Nix (mainly to solve cmake issues on hermetic builds).

Either way, it isn't unsurmountable. It doesn't really matter so much if it's used as an executable rather than as a library, though in the case of the latter it's really handy to be able to e.g. pass a custom spdlog sink for logging.

Off topic here but

> Carefully architected and written in C++ from the ground up with no dependency on any external framework, BlazingMQ provides…

What a weird selling point.

There are pros and cons to having no dependencies. Not long ago, it was a common decision for C++ projects because dependency management was a mess. But that hasn’t been the case for a long time (arguably we have the opposite problem - there are so many ways of doing it: Conan, vcpkg, bazel, spack, raw cmake, nix, etc)

So what would the pros and cons be today and why is it a selling point?

For instance, a pro is that everything is bespoke to the task at hand, no hammering square pegs into round holes designed for a slightly different use case.

A con is that the entire attack surface is managed by one team. CVEs identified and solved on another project is a pretty good thing when you depend on that project.

The main reason I’m surprised, though, is that there are some no-brainer dependencies these days. Fmt, catch2/gtest, metaprogramming libraries, etc.

Being tone policed by a bot - what a time to be alive.

Something that annoys me about AI bots is that the language is extremely American. This is no surprise. But polite in the USA is very different to the UK, where fake politeness is almost as rude as it is possible to get. Fake politeness followed by “let’s…” as the other party tries to wrestle control of the conversation from their self-proclaimed pedestal is rage-inducing.

Put simply, there should be a British mode for chatbots, where a request that it cannot comply with is responded to with profanity. “Nah, don’t be a c**, Emacs is awesome. If you want a joke, look in a mirror”. Now that’s a bot I could get along with.

I balanced a consulting job and my PhD, so thesis time was incredibly productive. When I didn’t want to do one, I’d become very productive on the other, and when I got tired of that, I’d switch and get very productive again.

This is it. This is the pinnacle of terminal experience. It’s all downhill from here.

Perhaps this is the time to quit and become a farmer, so I don’t have to witness the decline.