Hey programmers – is AI making us dumber? I don't want to sound like an aging boomer, yet when I see junior programmers relying on AI tools like Copilot, Claude, or GPT for simple coding tasks, I wonder if they're doing themselves more harm than good. It's made doing simple jobs much easier, but it's only by learning the skills you need for minor tasks that you can …
Current LLMs are junior team members who work quickly but all their work needs checking over.
You can't rely on one to do a task you don't understand yourself, because their work needs checking over.
You also need to have done your reps without the LLM to get the fundamentals internalised - how else will you learn about the edge cases which are going to bite you in the arse?
Assuming you're using them appropriately above, it lets you spend more time working on the knotty problems and how the whole thing will fit together in the complicated system that you're putting together - something that I don't think current LLMs are up to internalising.
(My favourite thing about getting an LLM to do the legwork on a task for me is that it's then capable of banging out reasonable documentation for the process, that gives me something to work from. Writing documentation from scratch on a given process is incredibly painful for me, so getting something close generated that I can tweak is a huge time saver)
Ah, but surely the act of taking a first draft of the documentation then editing issues with it is a very similar process to double-checking the thought process?
As mentioned above, writing documentation is one of my weakest areas. I need the whole concept to crystallise in my mind (along with how to explain it without the use of a conversation) before I can get the words to paper - and that crystallisation will not be rushed, much to my frustration. Using an LLM to give me that first draft then working through it and editing it to be more accurate will still lead me to think through each aspect of the process.
Jumpin' Jupiter, Alistair, Asimov's rules absolutely worked - the short stories in I, Robot eventually resulted in the Robots running everything, and everything was better for it.
The stories in I, Robot came from the funky interactions between the rules in new & interesting situations. Usually at the expense of Powell and Donovan's sanity.
The Elijah Baley stories came from how the Robots were too good at their jobs, and it screwed up the Spacer societies.
100% agree.
If you don't learn how to think through problems because 'AI' does it for you then you are totally 'owned' by whoever provides the 'AI'
This is NOT just to do with coding BUT all areas where 'AI' is being aimed.
A deliberate 'enfeeblement' of peoples ability to think.
After it becomes the norm and is depended upon you cannot go backwards because the 'skills' have been lost.
Question:
What happens when 'AI' goes off-line as all these things will do as 100% uptime is never reached for 'Global' systems ?
[Think ... Hacks, ransomware attacks, Human error etc etc (as 'AI' will never be able to maintain 'AI' although they will try :)]
:)
> I don't know if "deliberate enfeeblement" is accurate but...
How about "Learned Helplessness"?
How about "Learned Helplessness"?
This, in spades. As the article says-
Don't treat AI as a magic answer box. Trust, but verify its answers. Use AI results as a starting point. For programming, work out how it's solving your problem.
Which was also something pointed out in my proto-ChatGPT-
https://en.wikipedia.org/wiki/Numerical_Recipes
The declared premise of the NR authors is that you will come to grief one way or the other if you use numerical routines you do not understand. They attempt to give you enough mathematical detail that you understand the routines they present, in enough depth that you can diagnose problems when they occur, and make more sophisticated choices about replacements when the NR routines run out of steam
Which I think were great books because they were kind of coding cookbooks, but explained the algorithms first, then showed example implementations. AIs might spew out the implementations, but don't seem to provide the explanation, or the knowledge necessary to validate or diagnose/debug the routine if it behaves unexpectedly. Plus there's the GIGO or 'ask a stupid question' issue where if the request is wrong, the answer is going to be wrong.
One of my favorite examples of this problem is here-
https://climateaudit.org/2009/07/03/the-secret-of-the-rahmstorf-non-linear-trend/
At the end of the day, the secret of Rahm-smoothing is that it’s a triangular filter with linear padding. All the high-falutin’ talk about “embedding dimension” and “nonlinear … lines” is simply fluff. All the claims about doing something “new” are untrue, as are Rahmstorf’s claims that he did not use “padding”. Rahmstorf’s shift from M=11 to M=15 is merely a shift from one triangular filter to a wider triangular filter
Where an 'influential' climate paper got thoroughly fisked, and the claims of a 'novel' new approach to time series analysis turned out to be a triangle filter implementation that Rahmstorf either didn't understand and misapplied, or understood but it gave the desired result, so confirmation bias. But that discussion and others also prompted me to learn R.
But the 'AI' explosion promotes learned helplessness and is a wider social problem, especially when combined with the rise in censorship and enforcing only official misinformation. Wiki says it, so it must be true. ChatGPT says it, so it must be true.. Unless that information is biased, or untrue. Which is something that can easily be abused, eg as wiki says for learned helplessness-
...learned helplessness is characterized as "apathy" which may result from prolonged use of coercive techniques which result in a "debility-dependency-dread" state in the subject, "If the debility-dependency-dread state is unduly prolonged, however, the arrestee may sink into a defensive apathy from which it is hard to arouse him.
That 'debilitity-dependency-dread' state might be desireable by politicians seeking a passive, compliant, apathetic population that will do, or believe in whatever the government tells them. One of the biggest experiments to test this was the Panicdemic, with things like masking or social distancing rules, with the coercive techniques including prolonged media campaigns, backed by threats of fines or home detention. The apathetic went along with it, because there was a heavily promoted dread element, ie comply or die, or face punishment. Some years later, we're discovering that the official misinformation was just propaganda and psyops.
Which I think is the big danger. In software developement, don't question, just accept the code. In the wider enviroment, don't question, just obey, citizen. Especially if critical thinking isn't taught, and can actively be discouraged.
I retired a few years ago after 30 years of development. In my experience, there is a spectrum of coders from those who can do simple tasks to those who can create complex solutions. I don't think AI has changed anything; perhaps it is exposing what was there all along. Hopefully, AI code checkers will catch the worst abuses and force those who overly rely on AI to think for themselves without wasting the time of stronger developers on unnecessary reviews.
Of course you have. You number the postcards in the order they are supposed to be, i.e. card "15 of 40". If one is missing you send one back to ask for the one missing. It is just a question of definition. Like those famous letters arriving 50 years after the recipients death... But it arrived! Or a lost DHL package fro a "Monin syrup mint" Amazon order, which unexpectedly arrived seven month later - intact, not broken.
This has been an ever increasing problem in education for a very long time.
Learning is a struggle, a real hard struggle and only gives delayed gratification. You learn by failing and are considered educated when you have reduced your failure rate to acceptable levels (for an appropriate level of acceptable).
When people can or have to choose between delayed gratification or instant gratification, then most will choose instant gratification. It is simply the quick dopamine fix. Modern computer technology and the applications it runs is the drug system. Purposely designed to push the boundaries of quick and constant drug delivery. We are modern junkies.
And it will only get worse as long as we remain junkies.
"Gilligan!"
(For those who didn't get that reference, in my childhood it was common for parents restrict the number hours and type of television programs viewed by their childeren. This was due to the belief that watching television tended to make the viewers stupid. A slang phrase for a television set was, 'boob tube'. And a particularly-mindless American TV comedy was titled, "Gilligan's Island".)
(fake) AI seems like more of the same, as is anything which turns people into passive receivers, vs active thinkers.
I've seen posts from Comp Sci professors who are running into real problems with students failing themselves with AI-based code generators - they use them for the first part of the course and feel very clever because they've done no work and they still got good marks, then as the material gets more complex GPT can't solve the problems any more, but they haven't learnt to program so they can't do it themselves either. They either end up needing a vast amount of catch-up or they fail the course, and it's an entirely self-created problem. God knows when I was that age I was lazy and dumb enough I could absolutely imagine myself in that situation.
The fundamental misapprehension that a lot of students have around using AI is that their teachers want the answers to their questions, whereas the teachers want their students to have gone through the process of answering the question for themselves.
Unfortunately certainly in the UK our school system has got so obsessed with making kids do tests that they have been trained to think that answering test questions is the thing that matters, rather than understanding the topic. This politically-motivated approach has done the last few generations no favours and made life harder for teachers who want to prepare their students for life rather than just for exams.
We have seen this process here in our BSc Computer Science programme, where quite a few students do well in their homework exercises, but fail dismally at the mid-term and final exams, where they cannot get access to AI tools. We warn them of this, and some do listen, but too many don't. I feel that most, if not all homework should really not contribute to a final grade, and just be offered as a formative test, allowing students to learn how well they are doing (and lecturers to learn where there may be problems). If they use AI tools, the only people they are really cheating is themselves.
This is not to say AI tools are only a bad thing. If you want to focus on the knotty parts of a problem and can use an AI tool to solve some simpler components, little harm is done, although you still have to check and understand the AI solution. That does involve reading and understanding code written by someone else. That can be a real pain, even when the someone else is your few years (or even months) younger self.
Recent history would suggest we'll be JUST fine, and PROBABLY better off, with AI doing the menial "monkey motion" stuff.
After hand-held calculators were invented in the 1970's, people did NOT stop learning how to do basic math. Instead we went past doing hours and hours of arithmetic on paper and using slide rules for the complicated stuff, by using hand-held calculators, and then personal computers.
etc.
Yes. But not just AI. Speaking to interns and university lecturers, computer architecture isn’t taught anymore. They don’t know their Harvard from their Von Neumann, their ALU from their FPU, their address bus from their data bus… They don’t know how to manage memory themselves. Note, I’m not saying that they should have to in their careers, if they end up coding in Java or Rust or something else then that’s fine. But they should know how to. They should know how to be sympathetic to the architecture they’re developing for.
Hmm.... not sure, really.
Computer architecture has got much, much more complicated now than it was when I studied. I reckon things have to be a lot less detailed than before. Really, I don't think they need to know about ALUs and FPUs -- at the end of the day, there isn't much need to know more than the simple fact that integer arithmetic is quicker than floating point. The ALU is misleading, because the A stands for "arithmetic", and FPUs do arithmetic too....
The most complicated things I've asked AI to write for me are bits of code to illustrate how concurrency is done or simple REST clients and servers in a new (to me) language. In this respect, I've found the LLMs I've used to be a kind of useful teacher that helps me get to a point faster than with traditional methods. With rare exceptions, I write the code that solves the problem! The exceptions? I occasionally need to automate something in MS Office and have zero interest in learning a dying macro language. And let's face it, some work (e.g. writing a resignation letter) is grunt work and might as well be done via AI.
This is a fairly reasonable use case. But imagine now you don't know anything about how to code in any language. You give AI a prompt and it spews out some code that sort-of works when you do the one test you can think of. What have you learnt in that situation? Do you understand the code? Do you know what the LLM did? Do you know that it works in all cases or how you would validate that? If it doesn't work in some circumstances do you know how to fix it?
I expect most of us have done a bit of monkeycoding down the years where we copied something and poked it until it worked, but even that needed a degree of understanding before we could get anywhere with it. For people starting out AI seems to be a tool to avoid having to understand anything.
It's a fair tool for showing you how to do something you already know how to do using a different language or platform, but if you want to learn from scratch, learn to actually understand what programming is and how to do it, it's between no help and worse than nothing.
Seeing it here: There's even a push for it to be used more in the business.
I'm not impressed as the code produced isn't that good. Mostly it fails for stupid reasons, but when it's 'fixed', it's still not efficient.
Okay, I'm speaking mostly of SQL as that's the stuff that gets pushed my way to check. And I fix it to make it run a lot faster by rewriting a good chunk. So it's clear that these 'AI' models don't understand data and how Databases work. Yet MS want to imbed AI in the next edition of SQL Server...
Yes, understanding how things work makes it easier to make things work, and build on that. If AI takes that away, then people will lack the understanding on how to fix the issues AI introduces and we might as well turn off all the computers 'cause the mistakes being introduced will only get worse until you could ask the 'computer' what colour an Elephant is, to be told 'Nelly'.
The problem is not merely "young" devs using AI. It's senior (and 'boomer') devs.
The common claim is "well, it can't do everything but it's great for refactoring function names or as an advanced search and replace".
This is the sort of tedious grunt work you used to give to junior devs, and in the process they would learn the code base and in time become a senior dev.
Now I don't want to be a gatekeeper and say people have to "do their turn" because that's usually a euphemism for "I got treated like shit as a junior so I'm going to treat my juniors like shit" but there's obviously value to that tedious work in having a deeper understanding of the code or even language, which means when you do actual feature dev, you'll spend less time chasing bugs.
Junior devs using AI is an issue because it impedes their professional development. Senior devs using AI is a problem because it replaces a junior. Which means in about 10 years time your whole succession planning is going to fall apart when there's a lack of good senior devs on offer.
Of course, that's a lot of doom and gloom, and similar criticism could be levied at autocomplete and linting tools - which could be argued make devs lazy - they should be able to get it right first time, right (and build in assembly!).
It is the nature of the world that specialisation drives innovation - where once Woz could talk you through an Apple end-to-end, there's noone at Apple today who could tell you how to build an entire iPhone, from designing the chip to firmware, to radio engineering to the OS stack, to developing Safari. So some level of abstraction is inevitable in some roles. And there is no need for a web developer (or designer) to be a computer scientist or understand systems engineering. There is nothing wrong with being a subject expert in CSS - few web devs have ever read the spec or can write stylesheets correctly on the first (ozen) attempts! And there are plenty of soft skills like UI and UX expertise which are just as important in building useful and usable services.
But I wonder where the line is that developers become too abstracted form what they're actually building? I guess this is particularly the case when it comes to application development. Software that is more closely tied to the OS stack. But even then, AI is late to the party - we have already replaced actual desktop applications with abominations like Electron, packaging an entire "application" inside a complete Chromium runtime with all the overheads that entails.
All very good points.
Back in the day. A looooong time ago, as part of my degree in electrical and electronics engineering, we had to do programming.
Machine code was the order of the day because the kit we were using back then didn't have anything else. We were using 6502 and Z80 evaluation boards that you had to type in via a hex keypad.
We didn't have compilers or IDE's for these things (though I did eventually write something along those lines for a project).
One of our lecturers was something else. And I mean that in a positive light. His background was R&D and designing subsystems for mainframes for the likes of ICL back in the day. His knowledge was utterly phenomenal but he also had a teaching methodology that, at the time was frustrating as all hell, but boy am I fortunate - and eternally grateful - to have had him teaching me.
He would never give us what we wanted - a straight answer. Well, actually a solution.
"What you need is in the blue/black book" <- these were the books from the CPU and board manufacturers that had all of the hex in them. Wanna JuMP? Hex xxxx - you get the idea. He might, if he was feeling particularly sorry for us, point us into the right general area of said books. But not often. It helped you find and digest the right information and sift out the irrelevant. Critical thinking skills, right there.
But also on top of that he taught us a logical approach, starting with the algorithm. If you can't get that right the rest falls short.
From the algorithm we went into flow charts. Again, he was an absolute stickler for them being accurate and flowing properly. And matching the algorithm. If it didn't one or the other (or possibly both) were wrong and needed to be revisited.
And then we got into the actual program itself. And by now, it was usually the simpler part.
So we had to learn the basic building blocks - from hexadecimal, to how the CPU's we were programming for worked, to how they did things like address the memory on the boards etc.
We had to learn how to turn a requirement into an algorithm and how to turn that into a program.
We had to learn how to debug them.
And fundamentally it taught us how to understand what we were doing, so that next time it was a bit easier and we were a bit better at it. Slow, steady, progress.
I won't say I left programming behind as it was more I never used it in anger outside of studying - the hardware got me.
But I wonder... if we could have simply used a search engine, we likely would. If we could pass it to AI we probably would.
And then we would have learned fuck all. We would have got to an answer without the journey of discovery and understanding.
If you abregate your learning to AI, don't be surprised when it uses what you're inputting as yet more of its own training data to become even better - all the while, leaving you stood on the bottom rung of the ladder with no way to make the steps upwards because you've never built a firm knowledge base of your own and the gap is widening.
Stop. Being. Lazy.
Spot on.
First I learnt to program in Algol 60, which was OK because that was a well-organised language and, within its expected use (writing programs to solve scientific and mathematical problems) it was easy to use. I also tried to self teach myself how to program the machine (an Eliott 503 scientific system) but failed miserably.
Post Uni, I joined ICL and was immediately taught to write ICL 1900 assembler (to say nothing of the joys of punching the program I'd just written using a 12 key card punch and using same punch to correct the program after the compiler had reported my errors: to be repeated until it clean compiled and the process of finding and fixing run-time errors could be added to the cycle.
The above basic training was what made me first a programmer and eventually a developer and then a systems analyst, to say nothing of providing a solid basis for writing and testing code in a variety of languages (COBOL, PL/1, Pascal, Java, SQL,...).
There's value in older, simpler computers, at the machine-language/assembly-language level, because they can be easily-understood. I haven't known diddley over squat about x86 internals and ML beyond the 8086, and haven't cared to.
With early microcomputers, and some of the minicomputers made before them, there is a joyous simplicity in their architectures and instruction sets. You can sit down with a slim volume, and start programming in machine language with a pen and notepad, punch the code in via hex pad or front-panel switches, and single-step through it, seeing it work (or not).
I absolutely love that stuff. A friend and I spent a summer vacation playing with his COSMAC ELF (RCA CPD-1802 CPU) dev board, which had all of 256 byres of RAM.
There are some excellent, free, software-based emulators available; some even replicate the emulated system's front panel lights and switches on your PC screen.
I'm an old programmer. I've never used a LLM to do my coding work for me and I don't plan to start either.
There's something almost therapeutic about cranking out all the simple support methods that I need in a database class. It's simple, but satisfying.
If I get an LLM to write this stuff and then have to spend as long checking the LLM's suggestions as I would have taken to write the code myself in the first place, I fail to see the attraction.
I started with a new Intel 8080 microprocessor, having to wire it up and digitally creating a eprom to make it do my work. Then I moved to FORTRAN on new computers, BASIC and C ... languages kept changing to new ones so these days I expect that AI will be replaced in a few years too. That's how our programming environment has evolved for years now with "new" languages ... the older languages were not bad, they just got frequently replaced.
It is however turning dumber people into programmers. The question is whether you're willing to employ them or not. Look at some application they've created and see whether it shows signs of coherent and logical design as well as ability to hack out code, and you'll find the best people. When poor programmers just cobbled together Frankenstein apps from code found on the internet it was just as easy to spot as AI slop, as it looked remarkably similar and had been arrived at in much the same way.
There's no denying that AI code assistants can quickly churn out code for you. However, it's still new and there is certainly no evidence yet of how well applications produced using them will fare over the longer term when the problem turns from writing new code to maintaining and building on existing code. This is the point where good design and coherence of systems really start to pay off, and having a code base consisting of a mishmash of AI generated stuff will be found to be inferior.
I can’t see how I could transplant a piece of code from ChatGPT or whatever into my wider project without understanding how it works so I can embed it to operate with the correct hooks and variables.
I have used it to address some real headscratchers and it came up with good solutions, but a suggested chunk of code from a reply on stackoverflow or output from LLM are the same coding crutch result. So this is nothing new.
I've managed a reasonably successful career by architecting and implementing fast systems, based on a few things:
1 -- Cache line misses count. Or more generally, it's useful to understand the structure of your multiprocessor memory system, at least in terms of cross-processor references and synchronization. Interprocessor synchronization is *expensive*, so figure out how to minimize it.
2 -- The formula: ops-per-second = number-concurrent-requests / latency. Very useful no matter which two you know.
3 -- Pay attention to where your data is going -- what buses it crosses, what devices it goes through and their speeds.
4 -- Find your latency bottlenecks.
with the exception of #2, which is covered in queueing theory classes, but rarely in systems programming courses, I've never seen this covered in a CS curriculum. I've certainly never seen these things referenced by a Chat GPT response.
But Chat GPT only makes these problems worse. There were lots of programmers pre-generative AI who had no idea whether their applications would run fast or slowly, or why.
As an aging boomer (71 going on 72).,.. YES , YES and thrice YES.
I don't know about the UK but over the pond in the USA, the average level of education if 5th Grade!
They are dumb and dumber personified. AI is a blessing for them but for the rest of us the current crop of AI systems are shite.
As has been said, their work has to be checked, checked and rechecked.
Now, I must get back to finishing my MA Thesis. Yes, I'm still learning stuff and enjoying it. No AI in sight apart from a few generated images.
You icon says "old", but your post says "so young thinking dumber is not possible". A contradiction. Reality should teach you: Dumber is always possible, there is no lower limit. It is like Dunning-Kruger: Recognize the "lowest" level of dumb enables you to recognize and even lower level of dumb.
I don't know if this is at all related....but I could swear products are just getting "worse"
aside from all the crap sold on ebay, supposedly recent products just aren't as well designed, and sometimes it's not a cost thing
I bought a soundbar + sub woofer (£90). on about 1 of every 10 switch ons, it goes pop and switches off. whether or not it's missing a £2 cap(acitor) which would.....stop it doing that
I've also recently bought an Acer monitor. occasionally, when the central heating switches, the monitor goes dark for 2 seconds. again whether it's missing a £2 cap which would regulate things
I have another cheap peripheral. it's got the right number of LED's, but they do the wrong thing. rather than indicate what function is active, they do....."something else"
I've also bought some cheap bluetooth speakers. they MAKE NOISES when you switch them on. they shouldn't make noises. the manufacturers seem to be thinking "this is cheap crap so we have to put on some unwantde gimmick to make you htink you're getting more"
To me this reads like an "you get what you pay for". Your bluetooth speaker probably has AI generated analogue part generating more noise than needed.
But regarding noise: I still have not once had an USB headset, let alone one with noise cancelling, which did not have a basic noise level. I swapped my Sennheiser 280 € headset twice, and in the end I opened it, soldered 1.5kO resistors right at those tiny speakers to reduce the minimum volume to a level where i could not hear the noise any more. It limited the maximum volume of that headset too, but it can still be louder than I ever need.
Arguably one of the most appallingly mis-coded 'systems' of recent times (and still in use today). The coding included a 'subroutine' which changed the sign of a number - by subtracting twice the number from itself. And all this before AI coding was 'a thing'.
Moral of the story - you don't need AI to be a crap programmer.
*Look up 'Paula Vennells' in the Register archive A start is https://www.theregister.com/2024/10/15/post_office_horizon_dc_support/ and
https://www.theregister.com/2024/12/18/we_told_post_office_about/
I started out in Z80 assembly. so got to know the ins and outs of basic computer hardware fairly quickly, before moving onto interupt driven multi-tasking programing (well if you want the animation to play, the sound to play, and the inputs to be monitered all at the same time) before sadly ending up with industrial control gear (to which the theorys of multi-tasking are very much applicable) and a stint with the Open University learning concurrent and distributed systems theory(amonst other things... but Prof. Jean Bacon's masterwork has a way of displacing all the other knowledge )
I cannot see an advantage to using AI to generate programming, and yes we have tried.
ok so it takes the leg work out of generating code and coming up with simple snippets I can paste into programs, but those code snips have to be checked, its no good if I'm moving the robot in the Y Axis and the AI spat out prefectly acceptable code only its telling the robot to move in the Z axis, thats not an advantage for me or anyone else.
What this AI generated code will be doing is far more subtle, it will be telling the managers of tommorrow "we dont need to hire junior devs" thus saving megacorp1 money... until the supply of senior devs dries up too , well thats ok because AI will be able to spit out better code ... until the point where your banking app sends your money by default to North Korea, the bank forecloses your mortgage, and the robot at work does a 180 degree turn and hits you over the head with a 25mm torque wrench.
Beer............ because its time for some more
Drivers these days, the don't know how to keep in lane or reverse into a parking space because AI does it for them. I meet drivers who don't know how to clean the plugs or how far to pull out the choke.
Airline pilots these days, they have GPS and collision avoidance radar and autopilots bringing them everywhere. Some of them don't know how to hand prop their engine and refuse to fly with their head out in the open air.
And you try and tell the young people of today that, and they won't believe you
> Drivers these days, the don't know how to keep in lane or reverse into a parking space
Depends. You don't get a drivers license in Germany if you cannot prove to be able to exactly do that. Probably the reason why Germany, the no-speed-limit-country, has only 1/3rd to 1/4th of deaths per 100000 people compared to US (and only 1/8th to 1/10th to Singapore or Malaysia). If you compare youtube dashcam channels between how bad German drivers are and how bad US or Russian drivers are you see the difference.
> Airline pilots these days
Head over to "74 gear" and a few other channels. You speak utter nonsense. They all started small, and they all have to handle failures. Expecting them to fly an old WW2 plane without closed cockpit is a crappy expectation. Those systems help a lot, and they take load off the pilots, but those systems are tested and designed on a completely different level compared to what is driving around in cars. When I see those many phantom brakes, false collision warnings, computer failure to recognize what the right lane es (especially at construction sites or as night) I know that too many of those systems, which are allowed in cars, are crap. (The good systems are: ESP/ABS and some implementations of radar/lidar based collision-emergency brake systems)
> Airline pilots these days, they have GPS and collision avoidance radar and autopilots bringing them everywhere. Some of them don't know how to hand prop their engine and refuse to fly with their head out in the open air.
Funny you should mention pilots, because there's a lesson there that society should have learned.
When autopilot came in, the company bigwigs said "switch on the autopilot, then only do something if the autopilot can't". The pilots (and their unions) kicked back with "if we don't pilot the plane under normal conditions, how the hell are we going to be safe to pilot them in adverse conditions that the autopilot can't handle?!?"
So now pilots fly the plane even where an autopilot would do a perfectly good job, specifically to ensure that they have the piloting skill to take over if and when an autopilot can't handle it, and so that they're confident to say "oh fuck no!" and take the controls back when the autopilot is about to do something rather stupid.
Pilots were able to push back against this sort of short-sighted thinking, but computer programmers can't really do the same.
Unfortunately, not all pilots did push back.
The amount of technology in a modern airliner is astounding and I have designed some of it.
Autopilot, fly by wire[1], auto-landing capability [2] and more.
The worst case of over reliance on technology was AF447 which crashed into the Atlantic some years ago. After it went missing, I looked at the telemetry the aircraft had sent (that was satellite based IIRC). The pieces I remember very clearly were:
Airspeed disagree. This means that the 3 computers, each with their own pitot tube, did not all agree on the airspeed. Not usually a major issue but it was a major contributing factor here.
Alternate laws. Flight control computers have what is known as 'control laws'; under ordinary circumstances these are time, but when the system goes from triplex to duplex those won't do the job, so we have alternate laws for that situation.
After all this, apparently all 3 pitot tubes iced up (they were in the middle of a massive thunderstorm which is a prime location for icing).
Without any reliable information on airspeed, the flight control system disengaged. Then the worst part happened - the pilots in the cockpit did not know how to manually fly the aircraft. They kept pulling the stick back which eventually led to an aerodynamic stall. The captain (who was on a scheduled rest break) arrived back in the cockpit but was unable to recover from this. Flat spins are one of the worst situations to be in.
Over reliance on technology is never a good thing.
Note 1. Fly by wire uses (as mentioned) flight control computers. The person at the controls inputs what they want the aircraft to do, but the electronics and various motors and actuators does the task. For civil aviation, these are triple redundant with some interesting requirements such as the processors in each 'lane' must be different architectures and each lane must be galvanically isolated. We also have FADECs =- Full Authority Digital Engine Controller. These are what actually adjust engine thrust.
Note 2. I have experienced this going into Salt Lake City almost 30 years ago. Smoothest landing (grease job) I have ever had.
1- I have been programming for over 40 years. What still drives my developer career is the satisfaction/pleasure to solve problems by myself. That's why I rarely use an LLM model for my daily job. When do I use them? When I need a conceptual explanation about some domain topics I am not familiar with. I have never used them to generate code for copy/paste.
2- I don't understand why junior developers have the necesity to deliver a bunch of tasks at burning rates. They are still learning, they must enjoy the journey of developing software. The abuse of LLM without no brain behind is really sad, it has/will have negative consequences for an industry that already has a bad reputation (bad quality code, more bugs in production, burnout of young minion-engineers, etc, etc). Faster and cheaper is not always good (maybe for company owners/CEOs, but not for common people).
We (all people, not only sofware engineers) are doomed, this increasing dependency on AI for everything is not Ok :-(
It affects more than just programming. C-Suite are redeploying technicians once something is automated. No junior staff are being trained in those skills - it's all just "the monkey flips the switch" mentality.
I interviewed a SENIOR tech support person for a job, asked how he would patch a system and all he could say was "I press a button". No idea of how it worked under the covers, and no idea how to look into any issue in the event automation failed. And this is only going to get worse once the AI/Automation bubble bursts.
The thing about IT is that it evolves continuously. Systems change as new versions/capabilities are released. BUT the people who are left have no idea what that means for automation, nor how to fix it or the systems that have issues.
I fear we are being led down a path where technicians in the true sense of the word are becoming rarer and rarer. Like a lot of the contributors on this topic, I learned IT through blood, sweat, and tears, not being spoon-fed questionable solutions.
I suppose to illustrate a point, I was looking into a problem and searched for similar posts - and I clicked on a post generated by AI without realising it. It was buggy, but I was able to almost immediately see what the issue was and was able to correct it. I only realised it was a generated response when I looked at the article with a view to adding a correction.....
(Current CS student) We have a mandatory inclusion of AI in my coursework by the state and have to use ChatGPT for a few assignments. I have no clue what it's supposed to add to my schooling but thankfully the instructors have siloed it to "soft" stuff not related to documentation or coding.
It surprises me when reading these types of threads and in relation to old buggers like me that have been coding for decades that someone like me would use AI.
If you are an old bugger then surely like me you have a large set of standard routines/templates etc that you have developed over the years that you reuse/rework as needed...you should seldom come across a new thing you have never seen before?
And if you do get something newish, you surely have some routine/template that is close enough to be reworked.
The advantages are numerous:
- the code routine/template is in a style you know
- the code routine/template is proven to work
If you are an old bugger and don't leverage what you have done in the past then.......
And I cant think of anything more jarring then cutting and pasting in some 3rd party code in a coding style that doesn't fit yours.....I have a very strong style that suits me and would hate to compromise that with some AI BS.
Bluck
The reality is that the younger coders are teaching the AI, not the other way around.... I've been coding for about 25 years now, started using AI in the last half year, and it's blown me away at how much I've been able to churn through working on solo projects.... both in being able to learn new languages/concepts (the AI explains a lot of stuff if you bother to read), as well as letting me modify/add a lot of stuff to old code/projects in languages I've never touched before.
You do have to have some mental capabilities to make sure the AI code works, its not just copy/paste without a lot of prompting/correcting/etc, but it is amazing what it can do, and scary what it WILL do in a couple years... I'm glad I'm retiring sooner than later...
> [b]is AI making us dumber?[/b]
This experiment was done long-long ago. In my lifetime, hand calculation was disrupted first by slide-rules then by electronic pocket calculators. Teachers banned them for a while, but later had to allow them. Results were gotten either way, but the manual/mental methods got too painful.
I know when sliderules came in, the same objections were observed.
Have you noticed your handwriting lately? Not everybody takes e-money. My heating-gas guy clings to checks.
IMHO, if you "want to understand the computer", you start with switches and lightbulbs. Relay Logic is still a cornerstone of industry. Move on to Diode Arrays. Then you can start to peep into the IBM 704 manuals (the 360 is a long way out).
Yes, but as I eluded to elsewhere on this thread, having calculators and using calculators isn't an all or nothing thing.
In my schooling, there were times we were allowed to use calculators and times we weren't. At primary school, we used calculators to specifically learn calculators.
At high school, in maths we used calculators when the arithmetic was slow and labourous and would distract us from the bit of the maths that was the point of the lesson, and we'd use them in science if the numbers were big because it wasn't a maths lesson. But we did enough mental arithmetic to learn mental arithmetic.
I was stunned when I went to university and studied computer science --a highly numerate discipline-- and my classmates would pull out calculators for simple additions and multiplications. I could work out the answer before they'd switched the calculator on....
I mostly use powershell. Three time I asked AI, two times ChatGPT, and the third time with it new marketing name. Every time it utterly failed.
The first time was a issue calling ffmpeg.exe to decode a video stream and pipe it into rav1e-ch.exe or SvtAv1EncApp.exe, However Powershell stores the whole object before piping, and in case of a video this means the whole uncompressed video stream into RAM (until Windows nukes the shell away). In the end the solution was to go backwards with $env:ComSpec /C "$using:ffmpegcommand $using:ffmpegoptions | $using:rav1ecommand $using:rav1eoptions", 'cause cmd.exe does real binary-stream-piping. (Unless someone here knows how to achieve that with powershell AND with the same performance...)
Second time was something with Windows I forgot, i only remember it hallucinated registry keys which never existed and could not be confirmed. In the end there was no solution.
The third time was: I use $error | export-clixml to get whatever errors the script throws when running from a regular task. But that gets try/catch block errors too, even though I don't want them. Copilot utterly failed to grasp, suggested using trap other nonsense which cannot work by design or things which effectively disable try/catch. The simple $error.RemoveAt(0), here to use in the catch block, was never suggested.
ChatGPT/Copilot for programming, it might help me when I have to switch the language so I don't have to deal with the "what idiot came up with that crappy syntax logic" right from the start, but then I still have to debug and do a Sir-Check-A-Lot run since I don't trust it the slightest after those first experiences.
I don't feel dumber, I feel smarter. But I'm worried
1. Learning and mastery of a new topic is quicker.
2. Quality of code is higher.
3. Connecting desparte software domains is possible
4. Problems are overcome with less persistence.
However I am quite worried.
1. We are going too fast, 10x in a generation when a 25% increase use to be significant
2. English is the new programming language which may be too easy.
3. Agents will turns us into managers at best
4. As evidence in the comments here there is a lot of heads in the silicon who will be left behind.
5.Synthetic reinforcement learning answers the question "where will the models get new 'data' "
> 2. English is the new programming language which may be too easy.
I've never used or even seen a non-english programming language since 1985, when I got my C16... Both Basic or the ROM-built-in are english based. Only if you enter machine code as Hex you have "no" language.
> 5.Synthetic reinforcement learning answers the question "where will the models get new 'data' "
Already proven to fail. The results turn from "Numbers and letters" to "Something" to "grey boxes". Like what happens if you enlarge and shrink a picture 1000 times, all data gets lost.
I've never used or even seen a non-english language
For most computer languages the grammar is quite a small set of key words, and could be trivially changed to an equivalent set in another language. For example.
while checkfile
do
sleep 10
done
Would be a simple lexical translation to Bulgarian as
докато checkfile
правя
Сън 10
Направи
To go as far as translating grammatical structure would be more problematic, but few real programming languages allow for freeform text as input. What is problematic is when trying to understand someone else's code when all the comments and all the variables are in a foreign languages - "checkfile" would become Проверетефайла. The keywords may be in English, the comments may be copious, and the variable and function names very descriptive but it takes twice as long to figure out what is going on.
I disagree. It's not by learning simple skills that we get better at complex skills at all.
Knowing how to call an API has nothing at all to do with the ability to model a multithreaded interaction, or design a scalable architecture for a program, or choose an appropriate database, or debug a stack corruption, or profile and optimize an algorithm by precaching some auxiliary data. That is why AI will make programmers smarter, because it cuts away the dross and lets the learning focus on the hard parts.
What's changed is it's no longer as easy to tell the skill level of a programmer by looking at their outputs. Naive neophytes can now produce programs that used to be reserved to bloodied journeymen. But that doesn't mean that the actual journeymen are dumber than before.
(Also, the main thing you learnt with StackOverflow was to recognize when StackOverflow was smoking crack and you should find another source. This skill is alive and well in the age of LLMs.)
As somebody who's been writing code both with and without LLMs, in my experience the ability to call them on their bullshit makes them much more useful for development. All these newcomers writing code with AIs without understanding it will learn this skill through pain, as we all have.
AI can be useful like any other search engine.
It can be a quick way to make a starting point, but that is why there are a ton of processes that can help you understand what you've written and how to test that they do what you expect.
Copy and Pasting anything and just creating a PR will lead to madness (and getting fired)
"Every junior dev I talk to has Copilot or Claude or GPT running 24/7. "
They are really bad devs, then, if their IA for coding choice is chat gpt or similar general model.
A clever dev would pick up Amazon Q or another *coding* IA !
But yes, generally speaking, IAs are making people write dumb and not thought of things. But guess what ? That is normal since an IA is not a thinking machine but a statistics model ...
No wonder it produces generalities.
This article reminded me of an aviation accident for a jet that was landing at San Francisco airport some years ago. The airport, known for strong runway crosswinds from the San Francisco Bay, forced the pilots to suddenly switch off autopilot at the last minute. This resulted in the pilot landing the jet too low and clipping the landing gear at the edge of the runway. The FAA report found the pilots had used autopilot so much, they were "inexperienced" at manually landing the jet, resulting in landing too low. This led to damaging the jet's landing gear, causing a crash.
That must have been MANY years ago, i.e. 25+. Airline pilots have that mandatory manual hours, and today they can always initiate a go-around. Many decades ago there was a change: When something feels strange during a landing make a go-around. One go-around is ALWAYS free, even in perfect weather. Controller asks "reason" and you can say "I felt unsure" and no one will ask any question. Sometimes there are some funny responses like "yeah, one guy felt like he had to go to the toilet to throw up" which end up on VASAviation :D. If it is gusty crwossind, changing direction of wind even two go-arounds are not questioned. And then it is sometimes better, before you go-around a third time, to get another runway (longer) or simply let the ATC redirect you to a different airport with better weather.
The "I've got to prove I can land" thing is long gone. To cite Kelsey Hughes from 74 gear "Those fighter pilots, they need balls flying into a war zone. Arline pilots, zero balls needed."
Oh, BTW: Maybe you have a 74 gear / mentor pilot / VASAviation link of the case you mention? I love to hear from those who understand the profession...
When I was at school, we weren't allowed to use calculators most of the time. Why? Because we needed to learn how to do mental arithmetic so we would know how to do it if the calculator broke, and also that even if we did use a calculator, we'd recognise when the calculator was saying something ridiculous and stop to look for our mistake.
I was pretty stunned when studying Computer Science at university that classmates would keep going to pull out calculators and I'd end up working out the correct answer before they'd even switched it on. And for a long time they didn't trust me on it and still checked.
So then along comes the notion of an "information age" and us not needing to remember anything, because we can always just google the information, and this actually being believed in schools, so they were already training people to trust google unconditionally, and then along comes AI -- a tech designed to imitate human failings and suddenly everyone's trusting it, and because it's on the front page of google, it can do immense harm.
>sigh<
"I was pretty stunned when studying Computer Science at university that classmates would keep going to pull out calculators and I'd end up working out the correct answer before they'd even switched it on. And for a long time they didn't trust me on it and still checked."
About a dozen years ago, one colleague pulled a calculator to calculate how much 7 X 10 would make.
I was like ... speechless. Maybe not everyone is a king in mental calculus, but come on, the trick to perform any number times 10 is really not difficult to remember, eh ?
I've had a number of people telling me that chatGPT can generate code that can be at least a starting point.
So I thought I would give it a go. We have a function that takes a date and applies an algorithm and returns
a date - either the same or one in the near future. The existing code was a bit clunky and unclear so I thought
this would be a good challenge. The code it produced *looked* like it would do the job. On closer inspection
it had an obvious flaw. And on actually being run it produced "1970-01-01" - regardless of input value.
> but as Blashki noted: "It's the difference between climbing a mountain and taking a helicopter to the top. Sure, you get the view either way, but one experience builds strength, resilience, and pride – the other is just a free ride."
Especially because we're not talking about smooth mountains with large flat surfaces suitable for landing.
No.
As soon as we go beyond the simplest of tasks, we're talking storm/cloud/lightning covered hellholes, that will smash any chopper getting to close to bits. These are mountains where the heli cannot help you, where you have only yourself, a sherpa, and your prayers to get you through.
God help you and whoever financed your expedition when you try to climb one of those when all your prior experience on easier mountains was to board a helicopter.
If you gentlement will now excuse me, I'm gonna set up camp for the night and cook some tea, for tomorrow I am going after an especially elusive yeti-variant called "sudden-inexplicable-packet-loss".
Having read all the comments, I'm surprised that no one linked to XKCD comic "Writing skills". That would've been a good start for a discussion.
On a more general note, I've been having similar thoughts about automation in general - Ansible, Puppet, Chef etc.
In my homelab I like to build things from the ground up, to understand how each component interacts with the others. Don't get me wrong, I'm not writing databases by hand, but I do want to know that there is a database which the web server references from here and the content it grabs goes there and then is served through that reverse proxy to the client on this port.
Nowadays people would just download an Ansible Galaxy role or a Chef cookbook, fill in the variables, and bam! They have a fully functional server, but they don't know what components are in it or how they interoperate.
This generally leads to me writing my own Ansible modules so that I can repeat the thing automatically next time, but I understand how it works, what's in it, and more importantly, how to fix it if it goes wrong.
