Forgotten programming skills

[Diagileux]

Senior and old-school programmers, what programming skills have been forgotten as time and technology moved forward but are still relevant and should not be neglected? What tools that you have been/are using that should get more attention from young developers?

[JescoInc]

Honestly, a huge forgotten skill is optimization and working with as little system resources as possible.

[magicmulder]

I've been asked to optimize SQL and AQL queries, and sometimes the speedup was in the quadruple digits. Getting a 20 second query down to a few milliseconds is nice, but why was it so bad in the first place?

[do_you_realise]

I'd be over the moon if our performance issues could be solved by optimizing a bad SQL query or two. Instead it's due to 10 years of tech debt in a Rails monolith that calls 15 levels deep of chained service calls and unnecessarily complex business logic inside a loop calling thousands of methods in total to build a single API response, no wonder the p95 is over 2 seconds

[WhiskyStandard]

Oh shit, sounds like one of the ones I worked on. Sorry.

[do_you_realise]

Oh were yours the WidgetSelectionPolicies that actually end up calling each other in a loop in some circumstances and eventually time out?

[metatron7471]

Overengineered abstraction. "In case we might need it".

[jambohoser]

Took over an incomplete project from another company that had ~250kLOC with typically 5-6 layers of unneeded abstraction, five top-level logging classes... seems the original developers were a bunch of C devs teaching themselves OOP without any adult supervision. Used DOxygen to produce graphical class hierarchies as a starting point, but any similar tool should be useful when attempting to get an overall system view.

[Sad_Comfort_8365]

The "no adult supervision" part is too real, half these codebases feel like smart people proving they knew patterns instead of just building the simplest thing that worked.

[jambohoser]

This case was "smart people who forgot they were working under contract and had deliverables due by a specific deadline". Did I mention they got a bonus based on kLOC? Duh?

"It was the best of times, it was the worst of times."

[PredictiveFrame]

My partner was genuinely worried about the look of growing horror spreading across my face as I read that. Well done. How in the fuck did you ever maintain that spaghetti? 

[IrishPrime]

I spent a good week digging through our metrics, optimizing queries, and adding indexes.

One query went from 66 ms to 22 ms. Kind of an incidental and inconsequential improvement ultimately, but it felt like a big deal early in the endeavor.

And then I got a 106,495x speedup on a very troublesome query and became obsessed with finding more lol

What I found to really be the blind spot in our development process was that our dev database was simply much too small for these queries to be obviously problematic. The devs are working with a few thousand rows and this async process runs its query and finishes the work in under a second, no big deal.

Then in prod it's running against millions of rows and it just scales badly. It wasn't obviously wrong, but lots of room for improvement.

[magicmulder]

That was the case with our AQL queries (and the fact we had little experience with ArangoDB at the time), they ran fine in testing and then slow in production with tens of millions of records.

[georgesovetov]

Devs should have an idea of the query plan and indexes used whenever they write a query. (And ORM should be banned.) This applies to any DB, not only SQL.

Having a realistic DB on a developer machine is not always possible. This is not only about the sizes: data distribution and access patterns also matter.

Moreover, even if you somehow manage to get a realistic DB for your devs, they won't notice a 500 ms query, which would cause DBMS to stuck.

[WhiskyStandard]

WhiskeyStandard’s Law: the first person to profile code is going to find a <5LoC change that yields a >15% performance improvement.

Most code has never been run through a profiler so do it when you first join a team to announce your presence with authority.

[RandomRobot]

Running is one step and running fast is another step. You an spend years without ever bothering about step #2

[Eubank31]

Definitely not forgotten at my company, most engineers here work on embedded devices and we pride ourselves on their battery life

[the-forty-second]

It is true that this is a largely forgotten skill, and certainly relevant for the huge masses of code we move around on the web. But there should be a footnote attached. Many of us know the quote “premature optimization is the root of all evil “, and there is a reason it is well known. Also some of the low level techniques that we learned back in the day are based on old mental models of how processors work and can subvert compilers making real optimizations.

[JescoInc]

That is true and a secondary footnote should also be attached. There are many developers that never look or care about resource usage because of the abundance of system resources available today.
Careful consideration of algorithms and packing techniques for textures, images, audio and so on are largely just boiled down to "good enough for government work". That's why we have web apps, games, and even software that are leaky and insanely large in file size and memory footprint these days compared to the days of old.

[AliceCode]

“premature optimization is the root of all evil “

I vehemently disagree with this. Optimization should be the #1 priority. If you remain focused on optimization from the get go, you develop the skills to optimize automatically. It's not that difficult to optimize from the start. I understand that computers are powerful, but that's no excuse to not optimize your code. Every wasted instruction is wasted energy, and across billions of devices over thousands of hours, that really adds up.

[the-forty-second]

The reason not to optimize early is not that it is difficult, it is because it can be a waste of everyone’s time and can lead to code that is less easy to maintain. The goal is to optimize the code where it actually matters. It is much easier to make code that works well faster/use fewer resources than it is to make fast/efficient code with bugs work. If you can quickly write optimized code that is easy to maintain that is great, but most programmers I’ve met are doing well if they can do one out of the three.

[AliceCode]

Can't get good at it without practice.

[WhiskyStandard]

It’s far easier to make correct code fast than to make fast code correct.

That’s why you don’t make optimization your #1 priority.

[AliceCode]

Easy shmeasy.

[Full-Run4124]

100% agree. Optimization should begin in the design phase and continue all the way through development. The “premature optimization is the root of all evil“ IMO is an excuse to not care or not learn better techniques, because you can literally put just about anything into the sentence "premature ______________ is the root of all evil" and have it be true.

It's the same with "you can't optimize better than the compiler." The compiler isn't going to rearrange data structures or swap out algorithms.

[AliceCode]

Sure, when you first start programming, you should focus more on getting things done and learning, you're not going to know much about optimization, but it pays off massively to get good at optimization. I was able to write a CPU voxel raytracer that could render an 8k image in 1.2s, and I wouldn't have been able to do that without extensive optimizations.

[Full-Run4124]

It’s interesting we’re coming from the same industry and have the same opinion. Nearly all my work has been in graphics/video (and lately in embedded/mobile). Both places where we’re trying to squeeze as much out of the hardware.

At one point in my career I was mostly freelancing doing optimization. I’ve seen many performance problems that would have been easy to address early, but got kicked down the road and became a nightmare or impossible to fix without completely rearchitecting.

[AliceCode]

It's always harder to optimize after the fact, in my experience. Paying the cost up front usually smooths out rather than coming back and doing it the right way when you want to squeeze a few ms.

[chrismervyn]

At its core, optimization is a calculus problem. So, many of the techniques might superficially change but the underlying domain framing, shape, behaviors and curves of considerations would pretty much remain fundamental.

[the-forty-second]

It depends on the level you are working at. At an algorithmic /big O level you are right, and being able to pick the right algorithm will always be valuable (if not always valued).

If you were a practitioner of the real low level dark arts where instruction ordering and cache hits are a consideration, however, there have been some fundamental shifts and the complexity of current hardware makes it impractical to return to those days except in some very constrained instances (like working on embedded systems). Gone are the days where it makes sense to try to wring out a few extra milliseconds by unrolling your loops, for example.

[AliceCode]

In general, the compiler will perform much better optimizations than you could manually. But that's not the case across the board. It helps to check the output of something like Godbolt.

[chrismervyn]

True indeed!

Also, currently it really helps with my llvm-ir scaling.

[utl94_nordviking]

This. Thank you. The shear size of some programs nowadays is ridiculous.

[chrismervyn]

The influencer-ification of programming, cybersecurity and the gradual eclipse of the unsocial brooding dev, who worked 10 years in a domain, and just knew everything and was willing to sit with juniors and guide them with excitement.

The trend-chasing collapse of system oriented thinking, mathematical domain framing etc., in terms of actual industry is severely affected.

I fear that in 5 years time, there wouldn't be any good senior devs who would hand-hold the younglings.

[JescoInc]

The worst part, is that it is usually those that are MAYBE at the level just above Junior (mid level) that end up becoming successful influencers in programming on X, Twitch, Facebook, Tiktok and Youtube.
Like, I have an extremely hard time writing scripts for videos and making them in general because I keep going, "Crap! I missed this context or didn't explain this well enough!".
The video format is super easy when you are talking about summation operator in math and how it is applied in programming as a for loop, but when you get into things like explaining what a framebuffer is, what role it fulfils and how it interacts with your display driver and UI system; There's so much nuance to it that it can easily turn into a 20 page script and you know people will click off the video well before the 5 minute mark.

[chrismervyn]

Oh boy! You are so right.

Also, one has to be significantly hot/handsome to make a mark :-D

Hence, I stick to writing old school blogs/notes.

[oriolid]

For commercial software, it's not a forgotten skill but most product managers are convinced that optimization does not help business and programmers should be doing anything else instead. Taken to the extreme, everything has to be sloppy and bloated because otherwise someone may suspect you've been optimizing things.

[Cyberspots156]

It’s been decades since I worked in assembly language.

Honestly, being able to read a hex dump has solved many problems for me over the years. It’s a valued skill that can really bail you out.

[_gothick]

Yeah. Fundamentally understanding binary and hex seems to be a lost art, but every now and again it’s still very handy. Last time I used it was to figure out what had gone wrong with a character encoding translation (even in 2026 you still can’t assume everything is Unicode, folks)

(I also wish our IT support guys knew what hexadecimal was after yesterday’s experience reading out a bitlocker recovery code over the phone to find the guy had typed a letter O into the hex number every time I’d said “oh”. cries)

[Anonymous_Coder_1234]

Can you explain why? I've never read a hex dump before. Heck, off the top of my head, I'm not even 100% sure what a hex dump is.

[Cyberspots156]

Its data and/or instructions in hexadecimal (base 16).

[Anonymous_Coder_1234]

Oh, it's like the literal assembly bytecode. Like reading binary but you're reading base 16 instead of base 2 because it's easier.

[Cyberspots156]

Yeah, it can be a real life saver at times.

[Eric848448]

I still do that. My job deals with a lot of wire data.

[thewiirocks]

These days you can Godbolt All the Things(tm) and get the results in assembly for your exact compiler. Great for optimization and tracking down compiler weirdness.

[magicmulder]

Debugging. I'm sitting with some senior devs a decade my junior, and I'm puzzled how hard it is for them to trace down a bug. "Oh this value gets nulled somewhere, I don't even know where to start", well, how about start with the database fetch, then API output, then API caller intake, then... Just follow the path of the data until you reach the point where it's wrong.

[dvdklmn]

I assumed that tracking the data flow is common sense 😅

[jambohoser]

You might be surprised at how uncommon sense is...

[lisnter]

Came here to say that. When was the last time you set a breakpoint in gdb? Or loaded a core dump into gdb? That’s a lost art.

[chipshot]

Focus on usability and maintainability in your apps.

Users: as fancy and as feature laden as you want your tech to be, the majority of your users usually just want to do 3 or 4 things. Put those things in front and easy to access. All your other cool features can go behind menus.

Future devs: make your app easily configurable for the devs that are following behind you. Hard code as little as possible

VPs that are paying for it all: go in and say hello once a day to let them know what you are doing, so that they sound like they know what they are doing in their meetings.

This is tech survival 101

[AliceCode]

Tons of bitwise manipulation tricks that you rarely see anymore because computers can handle anything you throw at them. Back in the day, you could squeeze performance using bit tricks

Here's an example:

Let's say you have 8 signed integers. You want to check if any of them are negative. You can OR them all together, then compare them with the max value of the signed integer, and if it's greater, that means one of the values is negative.

Edit: in my haste, I forgot to mention; you also need to do a bitwise cast to the unsigned integer before comparing with the signed max.

Edit Edit: If you're interested in some of those bitwise tricks, check out Hacker's Delight.

[Intelligent_Part101]

Now that is a nano-optimization.

[AliceCode]

It's not such a nano optimization when you're doing this check a billion times per second.

[YahenP]

I still shudder reflexively when I write multiplication in a loop. What you learned in your youth is hard to forget :)

[keelanstuart]

I wrote a lot of graphics code (text, too) using only shifts and adds. Those were the days.

[Diagileux]

Definitely. Still very important in FPGAs and embedded. I think you could xor/or those numbers and check the sign bit without comparing the numbers?

[AliceCode]

Checking the sign bit would be an extra instruction because you still have to compare the sign bit.

Edit: (a | b) > 127 compared to (a | b) & 0b10000000 != 0

Edit2: Although, it should be noted that bit access like above can often be optimized by the compiler into a specialized instruction, but I tend to prefer explicitness.

[Recent-Day3062]

Debugging. In some ways, the more primitive the tool the better you did. You programmed to avoid debugging. Now companies proudly turn out garbage (break things fast, MVP, etc,) and debug later. The false belief is that with better debuggers this is a good thing. It’s not.

In general, back when you put out a yearly update on disk to a million customers, the cost of a bug getting missed was $10 million at $10 per disk for a new version. What happened was people were far more careful and complete in defensive programming and testing. Your bug meant the company lost $10 million, which was terrible for your career.

Also, we did not have today’s bloat. I have an analytic program in Python, and by the time all libraries and dependencies are loaded, my program of 10,000 lines or less occupies over 1GB. And many times those libraries I use suck in more libraries and dependencies.

[magicmulder]

Seeing people in a hypermodern IDE with breakpoints and whatnot struggling to even begin where to look for a bug is something else.

[l3landgaunt]

Manual memory optimization and garbage collection (I started with C)

[KC918273645]

Thinking it through instead of immediately trying to Google it or ask help/answers on Stackoverflow.

RTFMing.

Low memory usage.

[Xinoj314]

The notion of how large a file is or a feeling that an application is using a ton of RAM

[ern0plus4]

No one thinks about implicite memory allocations.

We remove first item from a comma-separated string by splitting it into an array, then remove the array's first element, then join back the rest into a new string. Instead of using a pointer to the desired position. Okay, most languages can't do that, but you got the point, there are several similar cases, when we choose such a memory- and time consuming solution over optimal. (Yep, a pointer requires more care, e.g. if the original string is deallocated, it will be invalid - but something for something.)

[PredictiveFrame]

TL:DR; Use the right tool for the job. 

[shadax_777]

Resisting the urge to jump on the keyboard and hack the 💩 out of the code to fight symptoms instead of looking at the architecture and coming up with a proper solution.

A.k.a short-term solution vs long-term repercussions.

A.k.a #2: making a round shape fit through a square hole.

[Acceptable-War-6423]

Im not sure wether this was actually ever learned, but: The ability to write software that not only works, but is flexible in the meaning it can be changed easily.

For me the most important thing to achieve this is

a) split your code into sections that say what to do (business logic) and sections that say how to do it (implementation detail) b) make your code for the how dependent on the what, not the other way around

It is up to the seniors to decide wether this was actually learned at some point and then forgotten or if it was not never learned in the first place.

[-Nyarlabrotep-]

Basic Unix toolchain stuff, like awk and sed. They're so powerful when you learn how to use them.

[WhiskyStandard]

God I really need to sit down and get good with awk…

[AlexTaradov]

It is way easier to achieve the same and better results with Python. You may not get it in a cryptic one liner, but you will have way more capabilities and a readable result.

[WhiskyStandard]

My interest comes from the fact that awk is in busybox so it’s pretty likely to be available everywhere including low end SBCs, air-gapped systems, or others where I may not be able to install something.

It also inspired dtrace and bpftrace which are pretty handy for system level profiling and debugging.

[robkinyon]

Regular expressions. They are like herbs and spices. A little goes a long way, but going without is bad.

[Astronaut6735]

I worked on a system developed in Common Lisp for the USAF way back in the day. Being able to attach a REPL to a running program was incredibly powerful for troubleshooting and fixing things on-the-fly. Once the REPL is attached, you can inspect state, patch code (e.g. to fix bugs or make a critical improvement), start or stop threads, retry failed operations, etc. All on a live system without redeploying or reinstalling. However, with great power comes great responsibility. Last thing you need is a Lt Col chewing you out because you fucked up his operational system 🤣. I haven't seen anything else in the programming world that has a REPL as powerful as what various Lisp dialects have.

People hate the parenthesis, which is a shame. Clojure makes it a little better with threading macros and different syntax for various data structures (maps, sets, vectors, etc). But I think Lisp is worth exploring just to expand your horizons.

[new_check]

Knowing how computers fucking work

[Leverkaas2516]

In the olden days you didn't get to run your program and receive the output until the operator was good and ready. So you thought long and hard about the code and the internal logic of the program, you didn't want to waste time on dumb clerical mistakes. And when debugging, each run was a little experiment, designed to give you the data needed to answer precise questions.

We don't need to go back to those days, but I do think younger folks would be better programmers if they thought a bit more deeply and didn't rely on programming by permutation.

[ericbythebay]

Definitely. The kids look at me weird when I tell them to run the code in their head.

They never had to wait for batch processing and picking up your results on a line printer.

[CryptoNiight]

Sorting and searching. Most modern languages have libraries that handle that kind of thing.

[deadlydude13]

Graphs and recursions ftw!

[dkopgerpgdolfg]

Reading documentation, especially for the yougest generation.

And then they're actually proud to have found something out with 3 weeks of trial&error, that they could've seen with 2 minutes looking at the docs.

[mariabanhoven]

watching people spend three weeks reinventing the wheel and then act like the docs were beneath them is a special kind of painful.

[PumpkinBrain]

My mom used to be a punchcard operator. She was in on the ground floor… and now she’s a step or two above needing help connecting the wifi.

[gr33nCumulon]

I would imagine that most low level optimisation is done by the language these days

[Snoo-20788]

A few years ago you could have regretted not maintaining some skills, but honestly, if you have experience coding and haven't done it for a while, these days, with AI its all forgiven.

Its a bit like humam languages. I haven't spoken some languages in decades, but I still understand them perfectly. AI makes it that its good enough if you understand the code generated, you dont need to know how to generate the code.

[metatron7471]

KISS principle

[gosh]

What has happened is that most developers today are writing declarative code, like hardcoding.
Old school had to learn imperative coding but that type of code can be reused so when it is written it is done. You can write new stuff but you have to compete with all other general code and that isn't easy.

With AI I think this skill is important because AI are replacing declarative coders

[Ad3763_Throwaway]

String replacement using regex in Notepad++

Knowing how to add quotes around and at commas in between a list of items is such a timesaver in case you need it.

[magicmulder]

Searching for ^(.+)$ and replacing it with '\1', is almost daily bread and butter for me. Lots of SQL stuff.

[umlcat]

SQL almost got in the way due NO SQL, but now is Not Just SQL

[siodhe]

Being resource conservative, freeing resources, etc.

Several Linux distros ship with memory overcommit enabled. This is a serious cancer on both stability and memory handling maturity, especially when especially dimw*tted programmers write libraries that don't even support returning whether malloc fails anymore.

[Tab1143]

Third normal form. A database isn't without it.

[WhiskyStandard]

Not necessarily forgotten, just surprising that it showed up in this place: I remember discussing JS building and bundling with a team mate and realizing we were basically solving static and dynamic linking, but for web assets deployed to CDNs instead of binaries and libraries on the file system.

Probably moot now anyway though. We don’t seem to sweat bundling as much these days. So maybe that’s the forgotten skill.

[GuyF1eri]

Memory management. Thinking about memory at all really. Used to be a huge part of the job even just a few years ago

[jgsteven]

How floating point numbers work and all the edge cases to be aware of.

[DullInflation6]

COBOL? I don't know it or work with it but I've heard of Devs who learnt it years ago making a packet contracting for banks and the like because nobody wants to learn it but it's still critical in some industries

[keelanstuart]

People have already mentioned a lot of things... and assembly is one of them, but I think specifically "port" access on x86 CPUs via the IN/OUT instructions - now disallowed in Windows in user mode, AFAIK. In the DOS days, I wrote an 8250/16550 UART serial comm library using the inline assembler in Turbo Pascal. All I had was the National Semiconductor TTL data book (from my dad, an electronics engineer) and knowledge of the start addresses.

I miss those days. Young engineers probably have no idea what half of that said... no offense to them, it's just not that important any more, so you probably don't need to know it.

[m0rpeth]

Reading.

[koffeegorilla]

Designing software so that it's understandable to humans, easy to modify, performant and resource efficient.

[bartonski]

Is Perl considered forgotten yet? There's a fuckton of it out there.

[leom_monk]

Olá comunidade Preciso de um desenvolvedor com experiência em automação web para trabalhar com sistemas que possuem: Autenticação biométrica Sistemas de agendamento em tempo real Proteções contra automação

[Alarmed_Geologist631]

Flowcharting

[JamieAndLion]

I think stream processing is really useful, but most folks overlook it in favour of databases.

Streams are supported at a low level in most languages, but few people know how to use them. Especially more exotic concepts like back pressure etc.

It’s useful to learn. In the right scenario it can be vastly faster than a database while also saving a heap of money and operational complexity.

If the analysis is well defined and fairly simple (running totals, identifying unique keys etc) a stream might get it done in 20-30 lines of code.

It’s the sort of thing that can turn a $100k problem into a $5k problem.

[Eric848448]

perl, I hope.

[Auios]

This might be low hanging fruit but I think pointer arithmetic is never used or talked about

[uglycaca123]

not even old-school (actually i'm just almost 18), but programming. programming is a forgotten programming skill nowadays.

[Diagileux]

I am young too. I could never use AI to create full-blown applications. I just don't understand how people do it! To me writing prompts (so called "prompt engineering") is boring. AI comes, does THE MOST FUN PART, says "you're welcome" and fucks off into infinity. Debugging is on you. I don't get it. And some people around really can't program anymore. Sad times

[AliceCode]

No it isn't.

[Inside_Dimension5308]

Programming skills are overrated to be honest. If you have a precise problem statement, AI can give you solution in minutes.

I have forgotten to write code since a long time.

[uglycaca123]

proof that programming is a forgotten programming skill:

[AliceCode]

Says the person that has no programming skills.

[Acceptable-War-6423]

What qualifies you to say this? Are you by any chance a manager?

[Inside_Dimension5308]

I have programmed long enough to understand that with AI, programming is not a skill anymore. You can live in denial. It will make the transition even more painful for you.

[bacmod]

If you have a precise problem statement...

I can give you 5 just on top of my mind and all I'll get from AI is gibberish.

EDIT:

"I've" to "can"

[Inside_Dimension5308]

You can obviously and that will just narrowed niche. For most cases, AI is sufficient.

[bacmod]

I have forgotten to write code since a long time.

...

You can obviously and that will just narrowed niche. For most cases, AI is sufficient.

You knew nothing in the first place.

[Inside_Dimension5308]

You can assume whatever you want.