Toulouse, France, 28 November 2025 — Analysis of a re­cent event in­volv­ing an A320 Family air­craft has re­vealed that in­tense so­lar ra­di­a­tion may cor­rupt data crit­i­cal to the func­tion­ing of flight con­trols.

Airbus has con­se­quently iden­ti­fied a sig­nif­i­cant num­ber of A320 Family air­craft cur­rently in-ser­vice which may be im­pacted.

Airbus has worked proac­tively with the avi­a­tion au­thor­i­ties to re­quest im­me­di­ate pre­cau­tion­ary ac­tion from op­er­a­tors via an Alert Operators Transmission (AOT) in or­der to im­ple­ment the avail­able soft­ware and/​or hard­ware pro­tec­tion, and en­sure the fleet is safe to fly. This AOT will be re­flected in an Emergency Airworthiness Directive from the European Union Aviation Safety Agency (EASA).

Airbus ac­knowl­edges these rec­om­men­da­tions will lead to op­er­a­tional dis­rup­tions to pas­sen­gers and cus­tomers. We apol­o­gise for the in­con­ve­nience caused and will work closely with op­er­a­tors, while keep­ing safety as our num­ber one and over­rid­ing pri­or­ity.

OpenAI is now in­ter­nally test­ing ‘ads’ in­side ChatGPT that could re­de­fine the web econ­omy.

Up un­til now, the ChatGPT ex­pe­ri­ence has been com­pletely free.

While there are pre­mium plans and mod­els, you don’t see GPT sell you prod­ucts or show ads. On the other hand, Google Search has ads that in­flu­ence your buy­ing be­hav­iour.

As spot­ted by Tibor on X, ChatGPT Android app 1.2025.329 beta in­cludes new ref­er­ences to an “ads fea­ture” with “bazaar con­tent”, “search ad” and “search ads carousel.”

This move could dis­rupt the web econ­omy, as what most peo­ple don’t un­der­stand is that GPT likely knows more about users than Google.

For ex­am­ple, OpenAI could cre­ate per­son­alised ads on ChatGPT that pro­mote prod­ucts that you re­ally want to buy. It might also sneak in ads in the search ads, sim­i­lar to Google Search ads.

The leak sug­gests that ads will ini­tially be lim­ited to the search ex­pe­ri­ence only, but this may change in the fu­ture.

ChatGPT has roughly 800 mil­lion peo­ple us­ing it every week, up from 100 mil­lion weekly users in November 2023 and about 300 mil­lion weekly users in late 2024.

An OpenAI-backed study es­ti­mated 700 mil­lion users send­ing 18 bil­lion mes­sages per week by July 2025, which lines up with this growth, and other an­a­lysts now peg traf­fic at around 5–6 bil­lion vis­its per month.

GPT handles about 2.5 bil­lion prompts a day, and India has be­come the sin­gle biggest user base, ahead of the US.

ChatGPT has every­thing it needs for ads to suc­ceed. What do you think?

Every cou­ple of years some­body no­tices that large tech com­pa­nies some­times pro­duce sur­pris­ingly sloppy code. If you haven’t worked at a big com­pany, it might be hard to un­der­stand how this hap­pens. Big tech com­pa­nies pay well enough to at­tract many com­pe­tent en­gi­neers. They move slowly enough that it looks like they’re able to take their time and do solid work. How does bad code hap­pen?

I think the main rea­son is that big com­pa­nies are full of en­gi­neers work­ing out­side their area of ex­per­tise. The av­er­age big tech em­ployee stays for only a year or two. In fact, big tech com­pen­sa­tion pack­ages are typ­i­cally de­signed to put a four-year cap on en­gi­neer tenure: af­ter four years, the ini­tial share grant is fully vested, caus­ing en­gi­neers to take what can be a 50% pay cut. Companies do ex­tend tem­po­rary yearly re­freshes, but it ob­vi­ously in­cen­tivizes en­gi­neers to go find an­other job where they don’t have to won­der if they’re go­ing to get the other half of their com­pen­sa­tion each year.

If you count in­ter­nal mo­bil­ity, it’s even worse. The longest I have ever stayed on a sin­gle team or code­base was three years, near the start of my ca­reer. I ex­pect to be re-orged at least every year, and of­ten much more fre­quently.

However, the av­er­age tenure of a code­base in a big tech com­pany is a lot longer than that. Many of the ser­vices I work on are a decade old or more, and have had many, many dif­fer­ent own­ers over the years. That means many big tech en­gi­neers are con­stantly “figuring it out”. A pretty high per­cent­age of code changes are made by “beginners”: peo­ple who have on­boarded to the com­pany, the code­base, or even the pro­gram­ming lan­guage in the past six months.

To some ex­tent, this prob­lem is mit­i­gated by “old hands”: en­gi­neers who hap­pen to have been in the or­bit of a par­tic­u­lar sys­tem for long enough to de­velop real ex­per­tise. These en­gi­neers can give deep code re­views and re­li­ably catch ob­vi­ous prob­lems. But re­ly­ing on “old hands” has two prob­lems.

First, this process is en­tirely in­for­mal. Big tech com­pa­nies make sur­pris­ingly lit­tle ef­fort to de­velop long-term ex­per­tise in in­di­vid­ual sys­tems, and once they’ve got it they seem to barely care at all about re­tain­ing it. Often the en­gi­neers in ques­tion are moved to dif­fer­ent ser­vices, and have to ei­ther keep up their “old hand” du­ties on an ef­fec­tively vol­un­teer ba­sis, or aban­don them and be­come a rel­a­tive be­gin­ner on a brand new sys­tem.

Second, ex­pe­ri­enced en­gi­neers are al­ways over­loaded. It is a busy job be­ing one of the few en­gi­neers who has deep ex­per­tise on a par­tic­u­lar ser­vice. You don’t have enough time to per­son­ally re­view every soft­ware change, or to be ac­tively in­volved in every de­ci­sion-mak­ing process. Remember that you also have your own work to do: if you spend all your time re­view­ing changes and be­ing in­volved in dis­cus­sions, you’ll likely be pun­ished by the com­pany for not hav­ing enough in­di­vid­ual out­put.

Putting all this to­gether, what does the me­dian pro­duc­tive en­gi­neer at a big tech com­pany look like? They are usu­ally:

* com­pe­tent enough to pass the hir­ing bar and be able to do the work, but ei­ther

* work­ing on a code­base or lan­guage that is largely new to them, or

* try­ing to stay on top of a flood of code changes while also jug­gling their own work.

They are al­most cer­tainly work­ing to a dead­line, or to a se­ries of over­lap­ping dead­lines for dif­fer­ent pro­jects. In other words, they are try­ing to do their best in an en­vi­ron­ment that is not set up to pro­duce qual­ity code.

That’s how “obviously” bad code hap­pens. For in­stance, a ju­nior en­gi­neer picks up a ticket for an an­noy­ing bug in a code­base they’re barely fa­mil­iar with. They spend a few days fig­ur­ing it out and come up with a hacky so­lu­tion. One of the more se­nior “old hands” (if they’re lucky) glances over it in a spare half-hour, ve­toes it, and sug­gests some­thing slightly bet­ter that would at least work. The ju­nior en­gi­neer im­ple­ments that as best they can, tests that it works, it gets briefly re­viewed and shipped, and every­one in­volved im­me­di­ately moves on to higher-pri­or­ity work. Five years later some­body no­tices this and thinks “wow, that’s hacky - how did such bad code get writ­ten at such a big soft­ware com­pany”?

I have writ­ten a lot about the in­ter­nal tech com­pany dy­nam­ics that con­tribute to this. Most di­rectly, in Seeing like a soft­ware com­pany I ar­gue that big tech com­pa­nies con­sis­tently pri­or­i­tize in­ter­nal leg­i­bil­ity - the abil­ity to see at a glance who’s work­ing on what and to change it at will - over pro­duc­tiv­ity. Big com­pa­nies know that treat­ing en­gi­neers as fun­gi­ble and mov­ing them around de­stroys their abil­ity to de­velop long-term ex­per­tise in a sin­gle code­base. That’s a de­lib­er­ate trade­off. They’re giv­ing up some amount of ex­per­tise and soft­ware qual­ity in or­der to gain the abil­ity to rapidly de­ploy skilled en­gi­neers onto what­ever the prob­lem-of-the-month is.

I don’t know if this is a good idea or a bad idea. It cer­tainly seems to be work­ing for the big tech com­pa­nies, par­tic­u­larly now that “how fast can you pivot to some­thing AI-related” is so im­por­tant. But if you’re do­ing this, then of course you’re go­ing to pro­duce some gen­uinely bad code. That’s what hap­pens when you ask en­gi­neers to rush out work on sys­tems they’re un­fa­mil­iar with.

Individual en­gi­neers are en­tirely pow­er­less to al­ter this dy­namic. This is par­tic­u­larly true in 2025, when the bal­ance of power has tilted away from en­gi­neers and to­wards tech com­pany lead­er­ship. The most you can do as an in­di­vid­ual en­gi­neer is to try and be­come an “old hand”: to de­velop ex­per­tise in at least one area, and to use it to block the worst changes and steer peo­ple to­wards at least min­i­mally-sen­si­ble tech­ni­cal de­ci­sions. But even that is of­ten swim­ming against the cur­rent of the or­ga­ni­za­tion, and if in­ex­pertly done can cause you to get PIP-ed or worse.

I think a lot of this comes down to the dis­tinc­tion be­tween pure and im­pure soft­ware en­gi­neer­ing. To pure en­gi­neers - en­gi­neers work­ing on self-con­tained tech­ni­cal pro­jects, like a pro­gram­ming lan­guage - the only ex­pla­na­tion for bad code is in­com­pe­tence. But im­pure en­gi­neers op­er­ate more like plumbers or elec­tri­cians. They’re work­ing to dead­lines on pro­jects that are rel­a­tively new to them, and even if their tech­ni­cal fun­da­men­tals are im­pec­ca­ble, there’s al­ways some­thing about the par­tic­u­lar setup of this sit­u­a­tion that’s awk­ward or sur­pris­ing. To im­pure en­gi­neers, bad code is in­evitable. As long as the over­all sys­tem works well enough, the pro­ject is a suc­cess.

At big tech com­pa­nies, en­gi­neers don’t get to de­cide if they’re work­ing on pure or im­pure en­gi­neer­ing work. It’s not their code­base! If the com­pany wants to move you from work­ing on data­base in­fra­struc­ture to build­ing the new pay­ments sys­tem, they’re fully en­ti­tled to do that. The fact that you might make some mis­takes in an un­fa­mil­iar sys­tem - or that your old col­leagues on the data­base in­fra team might suf­fer with­out your ex­per­tise - is a de­lib­er­ate trade­off be­ing made by the com­pany, not the en­gi­neer.

It’s fine to point out ex­am­ples of bad code at big com­pa­nies. If noth­ing else, it can be an ef­fec­tive way to get those spe­cific ex­am­ples fixed, since ex­ecs usu­ally jump at the chance to turn bad PR into good PR. But I think it’s a mis­take to at­tribute pri­mary re­spon­si­bil­ity to the en­gi­neers at those com­pa­nies. If you could wave a magic wand and make every en­gi­neer twice as strong, you would still have bad code, be­cause al­most no­body can come into a brand new code­base and quickly make changes with zero mis­takes. The root cause is that most big com­pany en­gi­neers are forced to do most of their work in un­fa­mil­iar code­bases.

edit: this post got lots of com­ments on both Hacker News and lob­ste.rs.

It was sur­pris­ing to me that many com­menters find this point of view un­ple­sas­antly ni­hilis­tic. I con­sider my­self fairly op­ti­mistic about my work. In fact, I meant this post as a rous­ing de­fence of big tech soft­ware en­gi­neers from their crit­ics! Still, I found this re­sponse blog post to be an ex­cel­lent ar­tic­u­la­tion of the “this is too cyn­i­cal” po­si­tion, and will likely write a fol­lowup post about it soon. If you can’t wait, I wrote a bit on this topic at the start of 2025 in Is it cyn­i­cal to do what your man­ager wants?.

Some Hacker News com­menters had al­ter­nate the­o­ries for why bad code hap­pens: lack of mo­ti­va­tion, de­lib­er­ately de­mor­al­iz­ing en­gi­neers so they won’t union­ize, or just purely op­ti­miz­ing for speed. I don’t find these com­pelling, based on my own ex­pe­ri­ence. Many of my col­leagues are highly mo­ti­vated, and I just don’t be­lieve any tech com­pany is de­lib­er­ately try­ing to make its en­gi­neers de­mor­al­ized and un­happy.

A few read­ers dis­agreed with me about RSUs pro­vid­ing an in­cen­tive to leave, be­cause their com­pa­nies give stock re­fresh­ers. I don’t know about this. I get re­fresh­ers too, but if they’re not in the con­tract, then I don’t think it mat­ters - the com­pany can de­cide not to give you 50% of your comp at-will by just paus­ing the re­fresh­ers, which is an in­cen­tive to move jobs so it’s locked in for four more years.

Above all, thank you to every­one that made this pos­si­ble. But I wanted to em­pha­size and give spe­cial thanks to

Rairii for en­gi­neer­ing all these ROMs,

Mac84 for archiv­ing and shar­ing all the CHRP discs

, ELN for en­gi­neer­ing all the Mac mini G4 ROM com­pat­i­bil­ity scripts and cre­at­ing all the ROM and other Mac OS tool­ing, and to the Mac com­mu­nity at large every­where that as­sisted in all of this into be­com­ing re­al­ity. There’s hon­estly many, many peo­ple to thank we owe over this one way or an­other, both in small and big ways.

Run Windows ap­pli­ca­tions (including Microsoft 365 and Adobe Creative Cloud) on GNU/Linux with KDE Plasma, GNOME or XFCE, in­te­grated seam­lessly as if they were na­tive to the OS.

Creating short­cuts to se­lected Windows ap­pli­ca­tions on the host GNU/Linux OS.

Using FreeRDP as a back­end to seam­lessly ren­der Windows ap­pli­ca­tions along­side GNU/Linux ap­pli­ca­tions.

* The GNU/Linux /home di­rec­tory is ac­ces­si­ble within Windows via the \\tsclient\home mount.

* Integration with Nautilus, al­low­ing you to right-click files to open them with spe­cific Windows ap­pli­ca­tions based on the file MIME type.

* The of­fi­cial taskbar wid­get en­ables seam­less ad­min­is­tra­tion of the Windows sub­sys­tem and of­fers an easy way to launch Windows ap­pli­ca­tions.

* Microsoft Office links (e.g. ms-word://) from the host sys­tem are au­to­mat­i­cally opened in the Windows sub­sys­tem. (Note: You may need to use a User Agent Switcher browser ex­ten­sion and set the User-Agent to Windows, as the Office we­bapps typ­i­cally hide the “Open in Desktop App” op­tion for Linux users.)

WinApps sup­ports ALL Windows ap­pli­ca­tions. Support does not, how­ever, ex­tend to ker­nel-level anti-cheat sys­tems (e.g. Riot Vanguard).

Scanning Windows for any com­mu­nity tested ap­pli­ca­tions (list be­low).

Scanning Windows for any other .exe files listed within the Windows Registry.

Community tested ap­pli­ca­tions ben­e­fit from high-res­o­lu­tion icons and pre-pop­u­lated MIME types. This en­ables file man­agers to de­ter­mine which Windows ap­pli­ca­tions should open files based on file ex­ten­sions. Icons for other de­tected ap­pli­ca­tions are pulled from .exe files.

Contributing to the list of sup­ported ap­pli­ca­tions is en­cour­aged through sub­mis­sion of pull re­quests! Please help us grow the WinApps com­mu­nity.

Please note that the pro­vided list of com­mu­nity tested ap­pli­ca­tions is com­mu­nity-dri­ven. As such, some ap­pli­ca­tions may not be tested and ver­i­fied by the WinApps team.

Both Docker and Podman are rec­om­mended back­ends for run­ning the Windows vir­tual ma­chine, as they fa­cil­i­tate an au­to­mated Windows in­stal­la­tion process. WinApps is also com­pat­i­ble with lib­virt. While this method re­quires con­sid­er­ably more man­ual con­fig­u­ra­tion, it also pro­vides greater vir­tual ma­chine cus­tomi­sa­tion op­tions. All three meth­ods lever­age the KVM hy­per­vi­sor, en­sur­ing ex­cel­lent vir­tual ma­chine per­for­mance. Ultimately, the choice of back­end de­pends on your spe­cific use case.

The fol­low­ing guides are avail­able:

If you al­ready have a Windows VM or server you wish to use with WinApps, you will still have to fol­low the fi­nal steps de­scribed in the lib­virt doc­u­men­ta­tion.

WinApps re­quires FreeRDP ver­sion 3 or later. If not avail­able for your dis­tri­b­u­tion through your pack­age man­ager, you can in­stall the Flatpak:

flat­pak in­stall flathub com.freerdp. FreeRDP

sudo flat­pak over­ride –filesystem=home com.freerdp.FreeRDP # To use `+home-drive`

However, if you have weird is­sues like #233 when run­ning Flatpak, please com­pile FreeRDP from source ac­cord­ing to this guide.

Create a con­fig­u­ra­tion file at ~/.config/winapps/winapps.conf con­tain­ing the fol­low­ing:

# WINAPPS CONFIGURATION FILE #

# INSTRUCTIONS

# - Leading and trail­ing white­space are ig­nored.

# - Empty lines are ig­nored.

# - Lines start­ing with ‘#’ are ig­nored.

# - All char­ac­ters fol­low­ing a ‘#’ are ig­nored.

# [WINDOWS USERNAME]

RDP_USER=“MyWindowsUser”

# [WINDOWS PASSWORD]

# NOTES:

# - If us­ing FreeRDP v3.9.0 or greater, you *have* to set a pass­word

RDP_PASS=“MyWindowsPassword”

# [WINDOWS DOMAIN]

# DEFAULT VALUE: ‘’ (BLANK)

RDP_DOMAIN=“”

# [WINDOWS IPV4 ADDRESS]

# NOTES:

# - If us­ing ‘libvirt’, ‘RDP_IP’ will be de­ter­mined by WinApps at run­time if left un­spec­i­fied.

# DEFAULT VALUE:

# - ‘docker’: ‘127.0.0.1’

# - ‘podman’: ‘127.0.0.1’

# - ‘libvirt’: ‘’ (BLANK)

RDP_IP=“127.0.0.1”

# [VM NAME]

# NOTES:

# - Only ap­plic­a­ble when us­ing ‘libvirt’

# - The lib­virt VM name must match so that WinApps can de­ter­mine VM IP, start the VM, etc.

# DEFAULT VALUE: ‘RDPWindows’

VM_NAME=“RDPWindows”

# [WINAPPS BACKEND]

# DEFAULT VALUE: ‘docker’

# VALID VALUES:

# - ‘docker’

# - ‘podman’

# - ‘libvirt’

# - ‘manual’

WAFLAVOR=“docker”

# [DISPLAY SCALING FACTOR]

# NOTES:

# - If an un­sup­ported value is spec­i­fied, a warn­ing will be dis­played.

# - If an un­sup­ported value is spec­i­fied, WinApps will use the clos­est sup­ported value.

# DEFAULT VALUE: ‘100’

# VALID VALUES:

# - ‘100’

# - ‘140’

# - ‘180’

RDP_SCALE=“100”

# [MOUNTING REMOVABLE PATHS FOR FILES]

# NOTES:

# - By de­fault, `udisks` (which you most likely have in­stalled) uses /run/media for mount­ing re­mov­able de­vices.

# This im­proves com­pat­i­bil­ity with most desk­top en­vi­ron­ments (DEs).

# ATTENTION: The Filesystem Hierarchy Standard (FHS) rec­om­mends /media in­stead. Verify your sys­tem’s con­fig­u­ra­tion.

# - To man­u­ally mount de­vices, you may op­tion­ally use /mnt.

# REFERENCE: https://​wiki.arch­linux.org/​ti­tle/​Ud­isks#Moun­t_­to_/​me­dia

REMOVABLE_MEDIA=“/run/media”

# [ADDITIONAL FREERDP FLAGS & ARGUMENTS]

# NOTES:

# - You can try adding /network:lan to these flags in or­der to in­crease per­for­mance, how­ever, some users have faced is­sues with this.

# If this does not work or if it does not work with­out the flag, you can try adding /nsc and /gfx.

# DEFAULT VALUE: ‘/cert:tofu /sound /microphone +home-drive’

# VALID VALUES: See https://​github.com/​awake­cod­ing/​FreeRDP-Man­u­als/​blob/​mas­ter/​User/​FreeRDP-User-Man­ual.mark­down

RDP_FLAGS=“/cert:tofu /sound /microphone +home-drive”

# [DEBUG WINAPPS]

# NOTES:

# - Creates and ap­pends to ~/.local/share/winapps/winapps.log when run­ning WinApps.

# DEFAULT VALUE: ‘true’

# VALID VALUES:

# - ‘true’

# - ‘false’

DEBUG=“true”

# [AUTOMATICALLY PAUSE WINDOWS]

# NOTES:

# - This is cur­rently INCOMPATIBLE with ‘manual’.

# DEFAULT VALUE: ‘off’

# VALID VALUES:

# - ‘on’

# - ‘off’

AUTOPAUSE=“off”

# [AUTOMATICALLY PAUSE WINDOWS TIMEOUT]

Iceland has taken the rare step of treat­ing a cli­mate-linked ocean threat as a mat­ter of na­tional sur­vival, launch­ing a co­or­di­nated gov­ern­ment re­sponse to one of the most feared po­ten­tial tip­ping points in the cli­mate sys­tem.

Officials say the shift re­flects mount­ing ev­i­dence that a key Atlantic cur­rent sys­tem could be head­ing to­ward dan­ger­ous in­sta­bil­ity.

According to CNN, Iceland’s National Security Council for­mally la­belled the pos­si­ble col­lapse of the Atlantic Meridional Overturning Circulation (AMOC) a na­tional se­cu­rity risk in September — the first time the coun­try has ap­plied such a des­ig­na­tion to a cli­mate im­pact.

The move fol­lowed a gov­ern­ment brief­ing on new re­search that raised “grave con­cerns” about the sys­tem’s fu­ture sta­bil­ity.

Jóhann Páll Jóhannsson, Iceland’s min­is­ter for en­vi­ron­ment, en­ergy and cli­mate, said the risks ex­tend far be­yond weather.

“Our cli­mate, econ­omy and se­cu­rity are deeply tied to the sta­bil­ity of the ocean cur­rents around us,” he told CNN.

He later de­scribed the threat as “an ex­is­ten­tial threat,” warn­ing that a break­down could dis­rupt trans­port, dam­age in­fra­struc­ture and hit the coun­try’s fish­ing in­dus­try.

The AMOC — of­ten com­pared to a gi­ant con­veyor belt — car­ries warm wa­ter north­ward be­fore it cools and sinks, help­ing reg­u­late weather across the Atlantic basin.

CNN re­ported that sci­en­tists in­creas­ingly worry that warm­ing tem­per­a­tures and dis­rupted salin­ity lev­els are slow­ing the sys­tem.

Some stud­ies sug­gest a tip­ping point could be reached this cen­tury, though the ex­act time­line re­mains un­cer­tain.

Stefan Rahmstorf, an oceanog­ra­pher at Potsdam University, told CNN that a col­lapse “cannot be con­sid­ered a low like­li­hood risk any­more.”

The con­se­quences, he said, would be dra­matic: surg­ing sea lev­els along US and European coasts, ma­jor mon­soon dis­rup­tions across Africa and Asia, and a deep freeze across parts of Europe.

For Iceland, he said, the coun­try “would be close to the cen­ter of a se­ri­ous re­gional cool­ing,” with sea ice po­ten­tially sur­round­ing the is­land.

The se­cu­rity des­ig­na­tion means Iceland will now pur­sue a high-level, cross-gov­ern­ment ef­fort to analyse the threat and con­sider how to man­age or re­duce the con­se­quences. Jóhannsson said the de­ci­sion

“reflects the se­ri­ous­ness of the is­sue and en­sures that the mat­ter gets the at­ten­tion it de­serves.”

Rahmstorf praised Iceland’s stance, telling CNN that other na­tions should treat the risk with sim­i­lar ur­gency.

Jóhannsson said the coun­try is con­fronting a stark pos­si­bil­ity: “What we do know is that the cur­rent cli­mate might change so dras­ti­cally that it could be­come im­pos­si­ble for us to adapt… this is not just a sci­en­tific con­cern — it’s a mat­ter of na­tional sur­vival and se­cu­rity.”

Let’s rip the Band-Aid off im­me­di­ately: If your un­der­ly­ing busi­ness process is a mess, sprin­kling “AI dust” on it won’t turn it into gold. It will just speed up the rate at which you gen­er­ate garbage. In the world of Business IT, we get se­duced by the shiny new toy. Right now, that toy is Artificial Intelligence. Boardrooms are buzzing with buzz­words like LLMs, agen­tic work­flows, and gen­er­a­tive rea­son­ing. Executives are fran­ti­cally ask­ing, “What is our AI strat­egy?“Like every ma­jor tech­no­log­i­cal shift be­fore it—from the steam en­gine to the spread­sheet—AI does not in­her­ently make an or­ga­ni­za­tion smarter. AI, like any other tool, only makes faster.If you au­to­mate a stu­pid de­ci­sion, you just make stu­pid de­ci­sions at light speed. If you ap­ply an agen­tic AI work­flow to a bu­reau­cratic night­mare of an ap­proval chain, you haven’t fixed the bu­reau­cracy; you’ve just built a ro­bot that hates its job as much as your em­ploy­ees do.For decades, tra­di­tional soft­ware de­manded struc­ture. Rows, columns, booleans, and fixed fields. If data did­n’t fit the box, the com­puter could­n’t read it.Be­cause com­put­ers could­n’t han­dle the mess, hu­mans han­dled it (before AI). And hu­mans don’t al­ways fol­low a flow chart. These processes—like “handling a com­plex cus­tomer com­plaint” or “brainstorming a mar­ket­ing cam­paign”—are of­ten ad-hoc, in­tu­itive, and com­pletely un­doc­u­mented. They live in the heads of your se­nior staff, not in your SOPs.If you want to use AI to process un­struc­tured data, you must first bring struc­ture to the work­flow it­self. You need to im­prove your process de­sign to ac­count for the am­bi­gu­ity that AI han­dles.What is the trans­for­ma­tion? (What ex­actly is the hu­man—or now the AI—supposed to ex­tract or de­duce from that mess?)The Old Way: An an­a­lyst reads 50 con­tracts (unstructured), high­lights risks based on gut feel­ing (unstructured process), and sum­ma­rizes them in 3 days.The AI Way: An AI scans 50 con­tracts and ex­tracts spe­cific risk clauses based on de­fined pa­ra­me­ters in 3 min­utes.The process (Review Contracts -> Identify Risk -> Summarize) has­n’t changed, but it had to be rig­or­ously de­fined for the AI to work. The in­tel­li­gence (knowing what a “risk” ac­tu­ally means) still re­quires hu­man gov­er­nance. What has changed is the ve­loc­ity.Go back to the white­board. Map out your value chain—es­pe­cially the messy, hu­man-cen­tric parts in­volv­ing un­struc­tured data that you pre­vi­ously ig­nored. Find the bot­tle­necks. Identify the waste.Tech­nol­ogy changes.

The rules of busi­ness ef­fi­ciency do not.

It’s al­ways the process, stu­pid!

And that’s where ac­tual AI Tools are miss­ing that point, be­cause they weren’t build for that

Von der Idee zur App ohne eine Zeile Code zu schreiben

Vom Datengrab zur Goldmine - KI Einsatz mit schnellem ROI (Promptcast)

Wie man KI am schnell­sten gewinnbrin­gend ein­set­zen kann (Diesmal nur als Prompcast)

Vom Datengrab zur Goldmine - KI Einsatz mit schnellem ROI0:00/894.6184131×

Live long and pros­per 😉🖖

Silicon Valleys KI-Burggraben hat ein Leck — es heißt Open Source

Der Mythos der un­ein­nehm­baren Festung

In den Strategie-Etagen des Silicon Valley erzählt man sich gerne die Geschichte von den un­ein­nehm­baren Burggräben. Der KI-Wettlauf, so die Legende, sei ein Spiel für Giganten mit Budgets so groß wie Kleinstaaten. Nur eine Handvoll US Tech-Konzerne könne hier mit­spie­len, der Rest der Welt schaut

Was, wenn der lauteste Teilnehmer im Raum nicht zwangsläu­fig der führende ist?

From a physi­cist point of view I want to men­tion this trick and its gen­er­al­iza­tion for op­er­a­tors:

“Two com­mut­ing ma­tri­ces are si­mul­ta­ne­ously di­ag­o­nal­iz­able”

(for physi­cists all ma­tri­ces are di­ag­o­nal­iz­able). Of course the idea is that if you know the eigen­vec­tors of one ma­trix/​op­er­a­tor then di­ag­o­nal­iz­ing the other one is much eas­ier. Here are some ap­pli­ca­tions.

1)The sys­tem is trans­la­tion in­vari­ant : Because the eigen­vec­tors of the trans­la­tion op­er­a­tor are $e^{ik.x}$, then one should use the Fourier trans­form. It solves all the wave equa­tions for light, acoustics, of free quan­tum elec­trons or the heat equa­tion in ho­mo­ge­neous me­dia.

2)The sys­tem has a dis­crete trans­la­tion sym­me­try: The typ­i­cal sys­tem is the atoms in a solid state that form a crys­tal. We have a dis­crete trans­la­tion op­er­a­tor $T_a\phi(x)=\phi(x+a)$ with $a$ the size of the lat­tice and then we should try $\phi_k(x+a)=e^{ik.a}\phi_k(x)$ as it is an eigen­vec­tor of $T_a$. This gives the Bloch-Floquet the­ory where the spec­trum is di­vided into band struc­ture. It is one of the most fa­mous model of con­densed mat­ter as it ex­plains the dif­fer­ent be­tween con­duc­tors or in­su­la­tors.

3)The sys­tem is ro­ta­tional in­vari­ant: One should then use and di­ag­o­nal­ize the ro­ta­tion op­er­a­tor first. This will al­low us to find the eigen­value/​eigen­vec­tors of the Hydrogen atom. By the way we no­tice the eigen­space of the Hydrogen are sta­ble by ro­ta­tion and are there­fore fi­nite di­men­sion rep­re­sen­ta­tions of $SO(3)$. The ir­re­ducible rep­re­sen­ta­tions of $SO(3)$ have di­men­sion 1,3,5,… and they ap­pears, con­sid­er­ing also the spin of the elec­tron, as the columns of the pe­ri­odic table of the el­e­ments (2,6,10,14,…).

4)$SU(3)$ sym­me­try: Particle physics is ex­tremely com­pli­cated. However physi­cists have dis­cov­ered that there is an un­der­ly­ing $SU(3)$ sym­me­try. Then con­sid­er­ing the rep­re­sen­ta­tions of $SU(3)$ the zo­ol­ogy of par­ti­cles seems much more or­ga­nized (A, B).

Former Qantas cap­tain Dr Ian Getley, who holds a PHD in cos­mic and so­lar ra­di­a­tion in avi­a­tion, says flights can be af­fected by coro­nal mass ejec­tions (CME), which is when plasma is ejected from the sun into space.

The higher the sever­ity of the CME, the more likely it is that is­sues could arise with satel­lites and air­craft elec­tron­ics above 28,000 ft (8.5 km), he tell us.

A CME re­leases heav­ily charged par­ti­cles that shoot into the Earth’s at­mos­phere.

These cre­ate more charged par­ti­cles in the up­per at­mos­phere, which in turn can in­ter­fere with air­craft elec­tron­ics.

The for­mer pi­lot says his re­search be­gan af­ter a 2003 flight be­tween LA and New York, where he ex­pe­ri­enced this phe­nom­e­non first hand.