Consulting / part-time/retainer AI, devops work, and cloud cost optimization via my consultancy:
https://hokstadconsulting.com
Engineering management/leadership; AI; devops; software development, architecture; Ruby, C, JavaScript, C++, PHP, Java, Go, Python (roughly in descending order of commercial experience)
E-mail: [email protected] (job opportunities, contracts, and questions about my comments or projects are all good, but please be to the point and I can be slow to reply to unsolicited e-mail)
The last place I lived, the nearest data centre was a few hundred meters from the local swimming pool, in a business park. Most people would never have known the data centre was there.
Elsewhere, e.g. in London, Docklands is both full of high density data centres and high-end residential buildings and offices that could certain use the waste heat in winter at least.
Most of the data centres there just looks like office buildings on the outside, and most residents won't know they are there.
More generally, the problem is that to prevent this using restrictions in privileges, the privilege assigned must be the intersection of the permissions you'd be willing to give to the sources of any items of data you compose the context from.
You can mitigate that by composing pipelines when/where you can extract information that can be constrained to a safer set.
For your "widget" example, you can't stop a data sheet from lying, but if the document collection is separate per widget, you can stop it from prompt injecting the evaluation of them to e.g. change the evaluation of other widgets by first summarising each data sheet separately into a table of constrained attributes, and then evaluating them against each other.
This is obviously not a panacea - you're absolutely right this is a challenging problem - a lot of the time you may not have a clear delineation of sources etc., but whenever you can decompose a task this way you have a stab at limiting the blast radius of any prompt injection.
I agree not everyone, but it has changed dramatically in at least France as well in the last 30 years. First time I went to France, most people would not switch to English even in the middle of Paris, often even if they knew English unless they saw no other way out.
More recently, with much better French, I've had people impatiently switching to English the moment I was struggled to find the right word.
There certainly is a shift, though, when you get outside the tourist areas.
E.g. in Nice, you can pinpoint it almost by street. Cross under the railway in the city centre and move into Liberation, for example, and you will immediately find some staff that are unable or unwilling to speak English, and many who at least won't switch unless you ask. But it's also not surprising given how abrupt the number of tourists fall off...
Claude has made my Ruby compiler pass 8k more rubyspecs tests over the last two weeks, and that includes solving crashing bugs in hours that I'd failed to fix for weeks in the past.
Compilers for existing languages is if anything one of the lower bars for LLMs, given existing implementations or test suites provides an oracle to test against.
It's not lack of ability that is stopping this, but that it's a space where very few people are experimenting and willing to burn enough tokens.
I have done work for other providers in that space. The pay rates vary massively, and on the high end (providers requiring MSc's or PhD's and doing testing) they are high enough that if you're a freelancer and have dead time it can be worth picking up an hour here and there. The most lucrative project I picked up was actually worth putting aside contract work for, as I was able to negotiate a rate and they paid per task and I was far faster than their benchmark and the end result was it beat my reasonably high day rate by a good margin.
But, sure, I suspect a good number of the people doing this work has either lost a job or are in low cost countries.
The 65xx series outsold the 68k by several magnitudes. One might argue about how complex OS's it could run, but e.g. GEOS shows 65xx based designs could go quite far.
I actually started my first compiler my allowing (only) inline assembler first, and then starting to wrap higher level constructs around it.
It adds a little bit of complexity (you need to be very clear on how you handle registers) but it worked surprisingly well, and it makes it easy to built up the complexity step by step.
It also meant I could bootstrap the compiler itself with just an assembler.
Sadly I lost the source decades ago.
(Making assembler an integral construct of a higher-level language is also not a unique approach - there's Randall Hyde's High-Level Assembly[1] and others.)
Yeah, I take the same approach, and as much as I'm generally very pro AI use, to the point I wouldn't really mind AI comments if they added value (but it's fine it'll remain against the rules here), it really has become necessary to read the comments history before vouching, sadly, given they all seem to be low quality noise.
How we got from competition to assuming subsidies is beyond me.
There are a whole lot of commodity businesses that flourishes and that are profitable. It's true, that, yes, they will not have huge margins.
Grocery stores are like that - some of their suppliers might be subsidised but they are not, and many places they operate with typical margins in the 2% range. Discount supermarkets in the UK are operating on around 0.7% margins.
They are still huge, profitable businesses.
And they are examples of what happens when markets work.
I just had Fable run overnight in a loop, and it fixed ~150 compiler crashing bugs that Opus had kept deferring.
I wouldn't start with Fable - when I use burndown loops I tend to include instructions to document progress and set aside anything that turns out to be harder than expected, and solve the easy stuff first. When a model runs out of easy stuff and start struggling to make progress on what is left, I can let it keep churning on that - they get there eventually - or I can bump it up to a smarter model if one is available.
Opus had churned a week driving down spec failures, and did a great job. The 150 Fable took overnight were the ones Opus had kept putting aside.
#2 has been fiction for all but 0.1% or less of authors for many years.
As of a few years ago - before AI writing was an issue - the average full time author in the UK would have earned more flipping burgers (but their household incomes are above average - it's a middle class hobby for most).
And only a miniscule proportion of authors are full time.
Indeed, and that is perhaps the most important lesson of Hitlers rise - dangerous people will always exist, and so it is critical to have systems that are resilient to them, and not allow them to be hollowed out just because the current crop of leaders looks like they can be trusted with more power and less oversight, because who knows what kind of madman will get power next.
Personally I use 5 different model families, 3 of which are open weights with 3rd party inference providers (GLM, DeepSeek, Kimi), so if the frontier labs were to shut down it'd be a nuisance, nothing more.
Because I like Ruby and it's compact, and most of my stack, including my terminal, wm, font renderer and X11 bindings are already in Ruby (the latter two are reused directly).
Also because I was curious if it'd be viable, and turns out its fast enough (for a low level backend I might end up pulling in Mesa and some optimized blitting code, but otherwise pure Ruby is all you need)
To me an X12 implies significant protocol changes, or it's just another X11 implementation - X11 is the protocol, not a specific implementation.
And it turns out significant protocol changes might just not be particularly worthwhile given you can run most X11 clients with a few thousand lines (including XRender, Xinerama, and other key extensions)
Instead you certainly can make savings by ditching old hardware, and not bothering to make legacy drawing modes fast. I'm not going to commit to full compatibility, so maybe the x12 label might still make sense, but gtk + qt compatibility + about a dozen simple extra drawing calls gives you most X11 clients.
https://hokstadconsulting.com
Engineering management/leadership; AI; devops; software development, architecture; Ruby, C, JavaScript, C++, PHP, Java, Go, Python (roughly in descending order of commercial experience)
E-mail: [email protected] (job opportunities, contracts, and questions about my comments or projects are all good, but please be to the point and I can be slow to reply to unsolicited e-mail)
Mastodon: @[email protected] / https://m.galaxybound.com/@vidar
LinkedIn: https://www.linkedin.com/in/vhokstad/
Personal site: http://www.hokstad.com and http://www.hokstad.com/blog
My (not regularly updated) Ruby compiler project: http://www.hokstad.com/compiler
Github: https://github.com/vidarh
One of my favourite recent projects is this ~500 line TrueType font renderer in Ruby: https://github.com/vidarh/skrift
Site for my science fiction book series: https://galaxybound.com