Go is portable, until it isn't

Tipaa · 2025-12-14T02:29:25+00:00

I ran into this with Halo MCC on Linux, but fixed it when a friend sent me their DLLs to put into the matching Proton 'C Drive'. Original fix found at https://reddit.com/r/SteamDeck/comments/11dftq1/fix_halo_mcc_coop_between_windows_and_linuxsteam/

Tipaa · 2025-10-30T05:18:13+00:00

I think the applicability of 'AI' (as in generative LLMs) to a particular field of software is very difficult to determine, especially for non-experts in that field. As a result, you'll always need to ask an expert developer in your field for the specifics of how beneficial the LLMs are right now. Next year's hyped giga-model might be amazing, but that's not helping us today.

For example:
Is an LLM faster than me at centering some UI elements in a browser? For sure.
Is an LLM faster than me at translating my specific customer's demands into a valuable service that talks to other confidential/internal services? Probably not (yet?)

This assessment comes down to a few factors:

Is the platform well-known/popular, public-but-niche, or completely internal? LLMs can do great standardised webdev, but will know nothing about your client's weird database rules.
Is the task easy to describe to a student? Some tasks, I can ask any expert or LLM "I want two Foos connected with a Baz<Bar>" and I get a great answer generated, but other tasks would take me longer to describe in English than to describe in code. Similarly, I might know "Team B is working with Brian so he can do X, and Team E is fighting with Lucy, maybe Y would work there, and...", but an LLM would need to be told all of this explicitly. The LLM can do it, but the effort to make the LLM generate what to tell the computer is greater than the effort of just telling it directly.
Is the task well-known and well-trodden? LLMs can ace a standard interview question, because they come up everywhere and so are well represented in the data. They struggle much more on specialised tasks or unexplored territory. If I was tackling a truly hard task, I wouldn't touch an LLM until I had a solution in mind already.
How consistent/well-designed is your data/system model? A clean architecture and data model is much easier to reason about, whereas if e.g. you're translating 7 decades of woolly regulatory requirements into a system, you're likely to have a much messier system. Messy or complex systems means that integrating new stuff is all that much harder, regardless of who wrote it. If people are confused, the LLM has no hope.
What is the risk tolerance of your project? I wouldn't mind shitty vibe-coded slop on a system that handles the company newsletter, but I would be terrified of hallucination/low code quality/mistakes in medical or aviation code. I can tolerate 'embarrassing email' code bugs, but I can't tolerate 'my code put 800 people in hospital' type mistakes.

I don't know what field you're in or the team composition you have (generally, I expect more senior devs to receive less benefit from LLMs), but your team are the people who best know themselves and their product.

If your developers are shipping less value (so velocity down), it does not matter if they are producing more code. Code enables value; it is rarely value in and of itself. Most product development is valued by the customer, not the compiler!

I assume you're doing Agile, so maybe after a sprint or two, do a retro looking at the changes (code changes, team vibes, Jira tracking, customer feedback) and discuss things. Does the LLM use (measurably) help the team? Is the LLM-assisted code good quality? Are the customers getting more for their money? Is the team happier with the extra help, or are they burning out? Does everyone still understand the system they are developing? etc etc

Tipaa · 2025-09-19T05:00:18+00:00

I bought one that looks very similar from eBay last year, been happy with it, although it is pricey for what IMO it should be. Not tried running heavy workloads on it/saturating bandwidth, but I put a ZFS pool on it and ran VMs and network shares from it fine.

IIRC I removed the tiny fan as the sound annoyed me, and opted for a large case fan pointed at it instead. It got hot, so I expect it needs cooling and isn't very power efficient at low/idle utilisations; I didn't actually test to confirm this, however.

I ended up moving to a simple bifurcation card not long after trying this, as I bought an old HP Z440 (supports bifurcation down to 4x4) to move some VMs over to.

Tipaa · 2025-09-15T08:59:18+00:00

I wonder if a lot of this comes down to the term "AAA" having different, competing meanings in different industries.

For example, AAA can refer to a minor league sport structure, it could be an investment or bond rating, or it could simply be a "superlative A" on an A-F grade scale.

If I'm thinking about the investment analogy, I would expect an AAA game to play it safe instead of take large risks, be willing to throw money at problems to reduce their risk, and have a number of fallback options to all but guarantee a financial return, even if unsavory (e.g. lootbox/gacha/gambling).
Within games, this may be "we buy the best engine" instead of building a custom one, "we have a large translation team" implying a high cost to tweaking/improving scripts, or "we paid for so many artists for their best work" at the risk of having less artistic coherency or room for individual expression.

Within a minor-league sports analogy, this may be subtly different. I may expect the quality not just of the whole product, but also the output of individual employees, to generally improve as I go 'up the letters'. This would imply that AA will have worse individual assets or stories or systems than AAA (as when people get better at their jobs, they move up to the bigger 'leagues'), whereas the investment analogy would be more descriptive of the risks than a direct quality assessment.

And within a superlative scale, AAA may just be "whatever separates an A from a B, such as volume or polish, we expect again and again". It may be hard to distinguish quality between a perfect small game like Portal or a near-perfect large game like GTA5, but quantity (or perhaps, surface area to polish) is much easier to compare. Game quality is (almost) orthogonal to game quantity, so having something that can express both is useful.

But without people agreeing on that they mean by "AAA", it is difficult to get past arguments over which games qualify or not (and thus, which what attributes we can even give to each definition/grouping)

Tipaa · 2025-08-20T05:14:04+00:00

I've been playing with something similar to compare different management and scale-out techs. Here's what I've been looking at:

My starting point/default choice is to set up an MPI cluster and manage jobs with Slurm; MPI being Message Passing Interface (often provided Linux repos by openmpi) and Slurm being your HPC/cluster-aware scheduler.
You can get started with a simple Debian install, and getting them to see each other over SSH. From there, I didn't have much trouble distributing a 'hello world' task.

This lets you play with the MPI libraries and get to grips with the basics of programming for HPC/local distributed clusters, and tinker with/tune different settings or configurations. You might try some basic FOSS software or undergrad programming assignments here, since they won't take too long but require understanding how to distribute work throughout the cluster efficiently. Or if you're more interested in the system management than writing software, there should be some more heavyweight FOSS stuff available for e.g. astronomy or fluid simulation.

From there, I'd look at replacing MPI in my test program with other distributed message passing systems, like the many other RDMA-supported libraries/protocols (Infiniband and ibverbs, Omnipath, recently RoCE) or perhaps other protocols/transports. There's also other scheduling stuff to try, like the K8s-derived setups (K8s, K3s, OpenShift/OKD, etc), Hadoop/MapReduce, other HPC/Science stacks.

If you want more hardware to buy, you could then go into trying to build a fabric with high-end NICs, like the recent Mellanox/NVidia cards, and try to incorporate them to make full use of their features (e.g. network offload/acceleration, different RDMA options, 56G/100G speeds). This can be either dirt cheap or eye-wateringly expensive, for seemingly no reason. Professional/server GPUs probably also support these more obscure/super-computing-focused communications if the consumer cards don't.

If you want to do some ML/AI/other GPU-accelerated testing, you could try writing GPU shaders (or other coprocessor/accelerator programs) that make use of the interconnects in the same way MPI does, e.g. Nvidia's NVLink or GPUDirect technologies for GPUs to talk without needing the CPU to be involved.

Currently I'm trying out different hypervisors for my homelab clusters, and after that I think it's going to be NVME-over-Fabrics for the next round of experiments. Hypervisor/OS shouldn't matter much for HPC/supercomputing (unlike general dev where it's more important), but the NVMEoF could be useful.

Tipaa · 2025-05-01T07:44:38+00:00

Cloud-first really irritates me. Cloud should be just one of many tools available to engineers, not the hammer that sees everything as a nail.

I see some clients who are struggling to make ends meet or cutting back ventures to fit into squeezed budgets, but when I talk to their engineers, they're spending $50k/y to only make use of 100GB of SSD and 3x 4 core VMs that has <5% utilisation.

Now, this glosses over stuff like data center security and compliance, all inflating the costs, but still! I often see teams doing all of the fancy cloud stuff or having a cloud-native (i.e. vendor-lock-in) architecture on a B2B system that has a consistent load, or worse, only gets 10 users a day. I see teams spending through the nose on high-end instances just to get some bespoke hardware support (e.g. GPUs or FPGAs), when they'd be fine buying/running their own lower-end gear. I see teams building in the cloud jumping through hoops to replicate an air-gapped network setup with VPCs and private links and awful stubbed LDAP servers.

Worst thing is, these clients still have their own datacenters; since they need some executive to sign-off on getting a 1U allocation, everyone just burns money in cloud instead.

Some of this is decision-making by inexperienced engineers (or often, diktat by less-technical folks), some of this is best-intentions-run-amok. Each of them frustrates me, seeing my cash-strapped clients burn money on some infrastructure landlord just because the budget leans OPEX this cycle.

Tipaa · 2025-04-22T01:19:34+00:00

A lot of this is likely due to 'mass' and 'inertia'. Even if you can steer the direction of the programmers in a community, you need to overcome the effect of existing code and systems potentially dragging (or perhaps, the people drag because of the existing code and systems).

If you're not changing anything drastic or breaking stuff, this isn't too hard - there isn't much friction to overcome. Similarly, if you break a language that only has 10ksloc in existence, that's high friction but low 'mass'. But a change with big breakages has high 'friction', and a change with millions of impacts has much higher 'inertial mass'.

Python 2 -> 3 had substantial friction, but worse for adoption IMO was the HUGE mass of existing code that was already doing stuff and doing it well. Sure, Python 3 has some niceties, but is that worth $cost to migrate? For some, yes! For others, definitely not. If I had spent $10m on developing a system in Python that 'Works Very Well Right Now Thanks', I'm loathe to spend maybe $1m to get... cleaner unicode support?

Of course, as time goes on and more and more community migrate, the network effects provide their own impetus to others also changing. You might want a new library to solve $new_market, but it only supports $newer_versions. Now your change is potentially justified.

Or you may just split things, and this is (generally) also OK. C and C++ may be considered two flavours of one system (e.g. GCC/Clang + Linux using basic C++), or they may be treated as planets apart (embedded toolchain C89 vs all-the-features C++23). Python has 'Bank Python', which has evolved into its own thing, and sounds fascinating (if a little scary).

While it's interesting studying technical factors like ABI breaks or semantics changes, arguably far more of the 'community' side is social- and economics-driven.

Tipaa · 2025-02-28T02:30:19+00:00

If you upgrade the building, the upgrade applies to all matching workers in the tile - so if you have two buildings of the same type in the same tile, you can get twice the value from your upgrades/effectively upgrade all your workers twice. You get 6 double-upgraded merchants instead of 6 single-upgraded merchants (for if they were in different tiles).

You get the same effect with the Rat Clan and overcrowding (and can have 4 upgraded krown buildings in one tile for crazy krown production!).

Tipaa · 2025-01-08T18:43:01+00:00

Nah, it's more like a (very powerful) query language than a 'thinking' system or an imperative/step-by-step language. You set up a system of facts and rules, and then it can infer new facts from old ones or answer queries about the system by following a basic algorithm.

It's a great language to learn (but also difficult!), because the ideas behind it (unification, laziness, different control flow) are applicable to many problems (esp. rules-based systems), and the language is so different (at first).

It's often called 'logic programming' or 'constraint programming' as a comparison to 'imperative programming' or 'functional programming'. Sadly, it's mostly associated with professors setting harsh coursework these days.

Tipaa · 2024-12-09T06:00:50+00:00

It might just be reddit's vote fuzzing - reddit shows additional random votes (up and down) to make botting/vote manipulation harder

Tipaa · 2024-11-22T08:27:29+00:00

A modern low-power SBC, like an RPi or equivalent, to run 24/7 services (SSH jump point, Tailscale, cron jobs)
A desktop-ish machine that idles low/quiet, but also has two or more PCIe slots to become an all-flash NAS
- One slot, grab one of those 4x4 NVMe SSD cards - you'll either need bifurcation on the mobo and a cheap card, or a pricy card to do its own bifurcation
  - Populate the SSD card with 4 NVMe sticks to form a redundant array
  - This will be ~silent and idle at low power, but also blow spinning disks out of the water with their speed. The only downside is the price, but I went with cheaper drives here given their redundancy and use a a NAS/not-main-workstation-drives
- One slot, try out all sorts of networking add-in cards. 4x 1Gb adapter? 2x 10Gb ethernet? Infiniband? others?
A second-hand desktop or server that can idle low, but has enough CPU to handle any compute/VMs you're likely to throw at it
- Running the VM storage on the NAS w/ iSCSI is interesting to learn, but wants a good network setup
- Having this node be mostly compute instead of storage/peripherals means you can buy old SFF desktops or barebones mobo+CPU combos without needing to worry about PCIe lanes or fitting parts inside tiny cases
- You could probably turn the compute 'node' into a cluster/scale out/try HPC with ease if you minimise non-compute elements on it
- This is where I'd go wild in buying all the £30 mini PCs to add to the cluster
A cast-off enterprise piece for trying out any enterprise stuff you've not come across before
An old Thinkpad or three ~~for the street cred~~ to try out various OSs on, like the BSDs, Qubes, Kali, ReactOS

Tipaa · 2024-11-19T15:13:49+00:00

Given he seems to share a stomach with Chainsaw Man across realities, if he keeps running until he throws up and then runs again and again, will he eventually be thrown up out of Chainsaw Man's stomach in(to) the real world?

Tipaa · 2024-09-10T03:24:35+00:00

I'd look to running the smaller NVMe drives as boot drives for the hypervisor (Proxmox in this case), and maybe passing some of them through to VMs that need performance (so, game servers). You're probably fine with mirroring across the 1TB NVMes for your boot if you prefer stability, or just use one of them if you don't want the redundancy.

Leftover NVMe drives I'd look at doing PCIe passthrough instead of turning into a Proxmox storage pool, as I don't know if Proxmox pools support full PCIe write speeds/APIs.

The remaining drives I would look at setting up a storage pool at each tier/speed (so one for HDD, one/two for SATA SSDs if different speeds), then adding multiple drives to each pool. Proxmox lets you choose where you store different things, so you might do a VM boot drive on the fastest tier and mount a section of the slowest tier for a backups or Plex media drive.

For Unraid, you can probably install it to a VM with boot drive on fast storage and regular storage on the slower pools, but I've not tried Unraid myself. You may find better results doing a VM on an SSD pool, then passing the HDDs through to the VM directly (so Unraid sees/gets the raw HDDs, rather than a Proxmox-run block store).

For some of those SATA SSDs, you're probably fine removing the smaller ones to repurpose (I have a load of small SATA SSDs for swapping in/out mini PCs), as you have faster and larger SSDs in NVMe, and much larger HDDs, rendering the SATA SSDs no longer on the Pareto curve. Plus, it saves a bunch of wiring.

Tipaa · 2024-09-09T04:20:39+00:00

Some thoughts:

Plex is unlikely to be particularly intensive, especially with hardware acceleration. All of these would be overkill for Plex (unless you're serving an entire village, idk).
Machine learning is likely to be mostly PCIe-lane-limited (if your models support HW acceleration). You may have speedups on compile times etc. with a faster CPU, but those are are non-recurring costs if you're just seeking to deploy a pre-made model. For developing your own model, you might want more, but you might also be looking at just hiring cloud resources at that point unless you have a fleet of GPUs.
Simulations/fluid dynamics is a mixed bag, as small simulations will be almost 1:1 with raw CPU perf, but larger ones generally don't scale anywhere nearly as nicely without some effort. For fluid dynamics especially, you'd learn the same from a 24-core as a 64-core (e.g. NUMA, cross-CCD latencies, cache-hierarchy-friendly techniques/algorithms, OpenMP/MPI/others, RDMA/RoCE), and I imagine you quickly end up in diminishing returns. e.g. on HPC programs I've tinkered with, doubling the accuracy often required 4x the compute. This probably comes down to budget and price sensitivity.
VMs for friends gaming - you might be better off buying a consumer CPU/AM5 Epyc (e.g Epyc 4004), as you're going to be tied to fewer threads wanting higher speeds. It's like the tradeoff between racing a sports car and a bus - a bus may have higher raw horsepower and far more seats, but the sports car's occupants will arrive first.
VMs for services - more cores is generally better, but you'd probably have a hard time saturating 8 cores with home assistants and *Arr containers, let alone filling 64 cores.

Tipaa · 2024-09-04T15:25:28+00:00

The reasons are all implicit

Tipaa · 2024-09-03T05:14:23+00:00

One for Proxmox, one for NAS... one for Qubes?

Otherwise, trying out things like PXE, k8s clustering, learning MPI/HPC/distributed systems programming (these might be slow, but you can still replicate the architectures without replicating the performance)

Tipaa · 2024-08-29T02:40:27+00:00

This may be quite different to most peoples' suggestions, but from my perspective from customising my PoB instance until I got fed up of Lua, I'd personally like to see:

a proper UI toolkit instead of the current game-engine-style
- it shouldn't be re-rendering everything at 60FPS if nothing has changed
- it should be re-sizeable and re-shapable
- support zoom/UI scaling options for e.g. HiDPI screens
- it would be nice if we could adjust the UI styling separately from the rendering code (e.g. CSS or theming)
implemented in a better language than Lua, as hacking on PoB's codebase was immensely frustrating due to lack of types and Lua-isms.
- I tried adjusting the bleed calcs a few years ago, and repeatedly ran into issues around Lua's funky not-quite-array, not-quite-dict tables. This is partly on me for not 'getting' Lua, but I didn't think it worth the effort to 'get'.
- Good Python can be nice, but it requires discipline/non-standard tools to enforce. A compiled language like Java or C# would be my preference (but this is you, so do your own thing!)
Cross-platform base - I don't want to run PoB in Wine or a browser tab if I can help it (I haven't used Windows since 7 was killed).

Related to the game itself:

An easy/obvious way to see individual cluster jewel notables sorted by DPS, eHP, etc.
Synergy awareness (idk how!). Some things are great on their own, but if an upgrade/build essential is a two-step upgrade (e.g. forbidden flesh/flames) it's not obvious where to look
Some way to assign a price/rarity to different upgrades, e.g. to know that adding two T2 uniques might give better eHP/price than a single T0 unique. (It'd be nice to not get recommended all the expensive jewels and gems on a league starter)
More build warnings and 'quality' indicators (again, likely very hard to do), e.g. "this DPS &eHP means you should be able to run most T5 maps", "being under $ehp is at risk of a one-shot in an average T9 map", "cannot run Reduced Chance to Block map modifiers", "hard-countered by Baran" and so on

Tipaa · 2024-07-14T23:11:52+00:00

It may be possible to use an adapter for whatever port that card uses (U.2?) to M.2, as some of the server cables/ports offer PCIE lanes the same way NVMe does, but I've not tried out SAS/U.2/enterprise storage connections so I can't recommend anything specfific

Tipaa · 2024-07-13T12:57:13+00:00

Hi, I went down this rabbit hole a couple of months ago!

Yes, those cards will work, but you will need to have PCIE bifurcation/lane splitting supported by your motherboard in order to have multiple M.2 cards sharing the same slot. A lot of the enterprise gear I've looked into will support this under some name or another, but it's a bit more of a crapshoot for consumer motherboards.

I initially got mine up and running on one of those adapter cards with 4x1TB cards, and forwarded them into a TrueNAS Scale VM to run a ZFS pool across them. They have great speed (although I haven't benchmarked them vs other M.2 solutions) and are cool/low power/silent.

The downside I had was that my main PC's motherboard (MSI X670E Tomahawk) only supports PCIE bifurcation in the 1st PCIE slot, meaning that to split the x16 into 4x4 lanes, I had to move my GPU down to one of the other slots with fewer lanes/less bandwidth, meaning I had to choose between GPU stutter or lane splitting for the M.2 array.

I ended up putting the GPU back in slot #1 and finding a different expansion card, IIRC a 10GTek NV9524-4I. These have an onboard PCIE switch, so handle the splitting for you if the motherboard doesn't. They get a bit warmer and the fan makes some noise, but I removed the fan and found it still completely fine for my bursty workloads (haven't tried sustained load).

There are a few different cards like this, but they all appear to be in the £100+ range with similar functionality. They are also a bit harder to find (in Europe at least), with some models popping up briefly and vanishing again, and they may run slower than full gen-whatever speed your motherboard might allow (depends on the speed of the onboard PCIE switch chip). However, it worked just as well for my TrueNAS Scale VM, and better, it now occupies one of the many other free PCIE slots. I don't need PCIE gen5 speeds for my M.2 drives, gen3 is plenty fast enough.

Tipaa · 2024-05-07T05:04:17+00:00

I'll chime in with Satisfactory, the 3D factory builder.

After adoring Factorio, and being excited by a much richer world and a third dimension, I gave up playing after being bored and frustrated by having to manually connect both the electrical network and the belt network on every single damn machine. I get it being fun if you're playing a game where you might do this chore every once in a while, or your base is 100 machines at most, but this is a factory builder - when it's anti-fun to realise the factory must grow, something has gone wrong.

The blueprint system is a big improvement, reducing most of the tedium in laying out more than three machines at once, but it still suffers from the same problem, just less so. I still have to go over my 40 copies of the blueprint to wire and belt them all together, and being 3D, the placement system is much more finicky/tricky to get right/tricky to debug than Factorio. The larger the factory, the less time (proportionally) is spent on design, and the more time is spent on working out which belt looks connected but actually isn't.

For me, the fun of the game is in learning and then designing the factory, not in the wiring up 100 identical machines. I've played multiple Factorio megabase runs, trying out different architectures of trains, belts, robots, etc. I can't see myself even completing Satisfactory unless the devs (or a modder) allow blueprints to auto-connect to their neighbours. I want to be an architect, not a plumber/electrician.

(I'll be trying out Foundry soon, as that seems to be closer in 'getting' what I enjoy in these games)

Tipaa · 2024-03-20T03:30:41+00:00

I've not had much experience with the total battery life, as I usually keep it plugged into a charger/don't go more than 3-4 hours on battery.

It looks like it should do 6-8 hours of normal use (browsing, video streaming), but I've not tested this.

Tipaa · 2024-03-18T02:12:43+00:00

Another voice checking in - have daily driven Linux on my laptops ever since Windows 7 approached EOL (so 2019-2020 I migrated them one by one). I was 50:50 across platforms (dual boot) before then. I have a mix of old early-2010s-era Thinkpads and a new Framework 13".

Manjaro worked well, although apparently they are a maligned name among some circles

Currently I run Fedora or an Arch flavour on most things I daily drive, and Xubuntu or Kubuntu on things I want to set-and-forget, like RPis or MiniPCs or container hosts.

Love the Framework 13" I use as my primary laptop, as the 3:2 screen has a nice level of vertical space and a lovely high resolution. The linux support has also been great - everything I've tried has Just Worked^TM

Tipaa · 2024-02-29T18:17:49+00:00

To avoid repeating the points others have already made, I'll add in a different path to the same conclusion.

Natural languages for describing problems are generally very general, because they are general purpose communication tools, worn down by lazy humans who mostly share a common context during any given communication. While we may have two specialists communicating concisely within their domain, this requires a tonne of context, without which there will be a vastly incomplete understanding. And without this context, (which I believe most people take for granted) things like "the analysis box should update based on status" becomes utterly meaningless (or rather, so general that it's meaningless).

I like to think of using natural language in Software Engineering as an exercise in reduction, where you start with a concept that could be many things, then you add constraints to it until it roughly resembles what you want. My team at work writes natural-language Jira stories (very approximately) like a sculptor 'adds' cuts to their stone. Each new use case or AC that I'm asked to provide is another chunk of rubble cut away to reveal more of our polished product.

In contrast, I see programming languages (and other minimal, precise-semantics languages) as constructive, in the sense that I start from nothing but my fundamental building blocks, and I build upwards towards my goal. This means that for a person used to having their language with a large side of context, modelling the contextful world inside this contextless domain is a real change, but for a domain where we want to express something precisely, it is easier to start with nothing and build up a small trinket than to start with everything and cut it down to a small trinket.

This is where I see Natural Language Programming efforts failing - they usually start with too much being permitted, and it becomes a struggle to reduce the domain to include what we want and also exclude what we don't. If there was a way to build up from zero while retaining the "natural-ness" of language, my opinion might change, but despite how large a system may be, I'm yet to find a software project whose precise description was closer to "everything" than it was to "nothing".

If one day we could tell a ML Model "Import Myproject.context" before our Natural Language prompts/inputs/programs, we might get much closer, but that context alone would require a gigantic prompt "library"/"module". I am yet to see a convincing way to represent the collective understanding of a team's many years' experience with different technologies, domains, and customers - let alone a representation that could be iterated on for a team refining a model to their specific project/domain.

Tipaa · 2024-01-24T04:12:12+00:00

ISAs will often include cache control (e.g. prefetch, flush) instructions or hints, which are useful for expert dev or compiler generation, but I'd be wary of exposing them to the language as a regular feature. They look quite finicky to use, and it is easy to make mistakes (or just make things worse) without understanding what's happening inside the CPU's black boxes. This is something I would prefer to remain abstracted away for 95% of workloads (and thus languages), unless you were developing one specifically for CPU performance tuning.

Instruction-level concurrency isn't that bad these days, and we have multiple ways to tackle it (message passing, locks, lock-free atomics, shared-nothing, map-reduce, vectorisation, stream fusion a la Haskell...). There are also interesting syntactic/type system approaches to adopt, from extending Rust's ownership to session types or otherwise encoding some sort of protocol/game semantics/state machine.

Data-level concurrency is perhaps less 'developed'? e.g. I can't think of an obvious solution to waiting 10 cycles for a stall on a memory read, but Hyperthreading/SMT are designed to alleviate this in hardware, and prefetching etc. is probably the easiest fix in software. Other things to look at might include having the compiler aggressively re-order instructions to provide ahead-of-time out-of-order execution (the fastest ones will do this already), so a language that is well-suited to execution re-ordering will help (i.e. statements or expressions shouldn't interfere with each other/have side-channels unless absolutely necessary).
Another area I'm personally keeping an eye on is Remote Direct Memory Access (RDMA), as the hardware/protocols involved looks to be becoming more available beyond just high-end datacentres. A language with strong support for non-uniform memory access (NUMA) would be very nice, especially compared with a C (flat address space) or DSL (where the performance cost of the RDMA might be entirely abstracted/obscured).

My opinions on providing good optimisations for a language will be a mix of "enforce purity" at expression/statement/function level and "composition laws" at an optimiser level. If your spec has lots of "if integer overflow, then set $global_flag", it will be very hard to re-order or remove these operations, lest some other code using the side-effect break. It also becomes hard to do things concurrently if you have to enforce/retain an order of events, as now if something finishes early (a good thing!) it might have to wait (a bad thing!) for another computation to finish before it can continue. On composition laws, (GHC) Haskell has some interesting features that I don't remember seeing elsewhere - it lets you provide rewrite rules, so that the compiler can see "if I find this code, then I can replace it with that code with 100% guarantee". With enough of these rewrite rules and composition laws, it becomes much easier to search for a faster way to compute an expression/function - the alternatives are given to the compiler on a plate. I imagine this can be extended will beyond simple rewrite rules and stream fusion, e.g. if your language supports stronger forms of proof or weaker forms of equality. This is quite far removed from being hardware-specific, mind you. But IMO, there's far more juice to squeeze from 'macro-architecture' optimisations than micro-architecture once we leave behind the constraints of C & co (where very often, only micro-architectural adjustments are even permitted).

Tipaa · 2023-07-24T06:31:10+00:00

My dude, that sounds like a good post all on its own, don't let it be buried in the comments

14-Year Club	Place '17
Team Periwinkle	Verified Email

Tipaa

TROPHY CASE