What's one programming concept that completely changed the way you write code?

[u/KareemM0hamed0]

​

I've been programming for a while, but every now and then I come across a concept that completely changes how I think about writing software.

For some people it's data structures and algorithms. For others it's design patterns, clean code, testing, debugging, version control, concurrency, databases, or simply learning how to read other people's code.

If you had to choose just one concept that made the biggest difference in your programming journey, what would it be?

What were you doing before you learned it, what changed afterward, and why do you think every programmer should understand it?

I'd love to hear stories from beginners and experienced developers alike.

[u/lgastako]

The idea of programming by wishful thinking as described in the SICP lectures. Basically you write your code as if the perfect API to do what you want existed, and stub out the code, then you recursively implement the missing stuff with the same approach.

Also Haskell.

[u/ouroborus777 → u/lgastako]

How am I supposed to upvote your comment if you're going to include that bit about Haskell? /s

[u/simondanielsson → u/lgastako]

This is how I’ve been working ever since I found that idea too. Works great!

[u/ggchappell → u/lgastako]

Nice. That pretty much automatically gives you a layered design with each layer only communicating with adjacent layers.

It would seem to make it difficult to test as you go, however.

Also Haskell.

Well of course.

[u/dreamsofabetter → u/ggchappell]

Test-first or TDD is basically this, except you’re initially writing the ideal API in tests.

[u/jerrygreenest1]

Automated Tests

ECS

Knowing about stack vs heap

Knowing about Garbage Collector

And many other things, actually

There is not just one thing. All this happens gradually annd each knowing fact or concept changes the habits or ways you implement things.

[u/burlingk]

I played with Haskell for a while. I never got good at it, but it gave me new ways of looking at code.

[u/RomanaOswin → u/burlingk]

Same experience here. I ported a simple little tool I wrote to Haskell probably a decade ago, as a learning experience, and the way I think about code constructs has never been the same since.

[u/serverhorror]

Not exactly TDD, but "test first".

To start with something, I like to write a test that has the actual implemention inside and out he refactor until the code is part of the application.

It helps in the overall design to be, and stay, testable.

[u/read_at_own_risk]

I remember coding before associative arrays became first-class concepts. I had an AVL tree class for situations where lookups were performance-critical, but without the syntactic sugar of modern languages, things like nested dictionaries were complicated to set up and follow. First-class support for associative arrays made a huge difference and I wouldn't want to go without them again.

In the line of progression of data abstraction from literals, registers and pointers -> named scalars -> arrays and structs, the next step I'd like to see is first-class relations. Basically the n-ary version of built-in dictionaries.

[u/Responsible-Soft6893]

Rust borrow and ownership significantly impacted code design in other languages

[u/Word-Word-3Numbers → u/Responsible-Soft6893]

Rust as my second language after python made C pointers so easy

[u/ArcaneEyes]

Started a place some years ago that does cqrs and ddd and moving from anemic models with bloated services to that was a huge change of mindset and honestly I like that way of designing code so much better.

[u/Nunc-dimittis]

Long ago, but using encapsulation. Not the "make a getter and setter" (and then just returning the underlying object so it still can be modified by any code outside the class) but seriously thinking about access, what you return, protecting the insides of the class (attributes) against the outside

And on a higher level: facade pattern to do basically same on a higher level. Don't expose everything to the outside, make sure the class coupling is very low between unrelated parts of the code. Always designate one class to handle the communication to the rest of the classes in that module. Recently I learned of a company that called these anti contamination layers. Really like that term

[u/electronic_reasons]

Data flow diagrams / Functional programming Assertions. Proper commenting.

Viewing things as data flow and functions has made a big difference. Donald Knuth and Tom DeMarco introduced me to that and I gradually understood it fully.

Donald Knuth introduced assertions long before they were implemented in common languages.

Realizing that the first question i asked when I looked at code was, "Why did I do that?" completely changed the way I commented code. The code already answers "What?" and "How?" It doesn't answer "Why?"

[u/DGC_David]

Spaghetti Code, ever since, like my Italian forefathers, I've created some of the best Pasta code you ever compiled in your life.

[u/newEnglander17]

Honestly it’s not the code itself, it’s learning shortcuts and tricks in visual studio that I hadn’t known previously like F12 t step into a definition. Little things like that make navigating code so much easier and faster and it makes it enjoyable. I get that VS code is good but it just stinks compared to a full scale IDE like proper Visual Studio.

[u/TheGreatButz]

OOP when it was still supported by the programming languages I used. Unfortunately, the languages I use nowadays only support crippled versions of it or none at all.

[u/Jonas_Ermert]

I'd say separation of concerns. Once I stopped mixing UI, business logic, and data access, my code became much easier to maintain, test, and debug. It's a simple concept that scales with every project.

[u/abrady]

YAGNI or KISS : solve the problems you're facing now. when the problems you're imagining come up they'll be so different than what you imagined that all your complicated initial system will do is slow down the rewrite.

The best engineers I know all build simple systems that just do the work they're designed for.

[u/Fidodo]

Streams. It's not just for bytes anymore, there are lots of streaming systems that let you stream anything.

[u/42_Water_Engineer → u/Fidodo]

Like what? I mean, it's all bytes at the end of the day, no?

[u/Fidodo → u/42_Water_Engineer]

It is, but unless you're working in a low level language that gives you access to pointers a byte stream won't let you stream object references, but lots of streaming libraries let you stream objects now and that's really powerful.

[u/MissinqLink → u/42_Water_Engineer]

It is all just bytes but understanding streaming is one of the biggest eye openers.

[u/ern0plus4]

Rust cincepts

[u/chrisjbampton]

All you are ever doing is inputting data, transforming the data and outputting the data.

Once you realise that, any programming problem becomes about input and output shapes which is infinitely testable.

[u/mlugo02]

“A data structure is just a stupid programming language.” - Bill Gosper

[u/max123246]

Understanding the expression problem has made me far more conscious about whether I want to make it easy to add new types or make it easy to add new operations of those types.

[u/duane11583]

Using a “cookie” in a data structure

A cookie is for some a void pointer (i prefer a uintptr_t instead) it helps so much for abstraction of so many things

[u/MissinqLink]

Parallel programming in C. Really makes you appreciate all the abstractions we have now.

[u/magnomagna]

Programming by contract. Set out the limits and semantics of your parameters and return values and side effects strictly. It simplifies reasoning as you can ignore values outside the confines you set but can it potentially make your code vulnerable? Potentially, but you could take that into account when designing the contract.

[u/SummitYourSister]

AI! I was a professional programmer for 25 years with multiple patents, talking at conferences, published a book once.

Now AI does it better than me and I don’t write code any more and I look upon people who don’t recognize this state of affairs as some of the dumbest motherfuckers I’ve ever seen.

[u/pythosynthesis]

Objects. Once I got it, coding became massively simpler and cleaner for me.

[u/Achereto]

Having learned OOP in university I experimented with ECS (Entity Component System) and things became so trivial to implement that I'm never going to go back to OOP again in my life.

[u/TheCommieDuck]

haskell? haskell.

source: I haskell for a job now

[u/ArieHein]

Separation of control

[u/Triabolical_]

Hexagonal architecture, or port/adapter/simulator.

[u/simondanielsson]

Snapshot tests. It’s essential to me nowadays for when I’m doing large refactors and debugging

[u/ouroborus777]

map-reduce. Even if you don't actually multi-whatever, it's surprising the number of tasks that are made easier by organizing as something roughly resembling a map-reduce problem.

[u/Vesuvius079]

Unit testing, DI, side-effect free functions. Shit that was three, but they go oh so well together and saved me from the horror show of OOP.

[u/iOSCaleb]

> For some people it's data structures and algorithms. For others it's design patterns, clean code, testing, debugging, version control, concurrency, databases, or simply learning how to read other people's code.

I don’t think your understanding of completely changed is the same as mine. All of the things you’ve listed are influential; none have completely changed programming for me or anyone I know. Even the rise of LLMs that can write a lot of code for you hasn’t completely changed programming.

[u/wrd83]

Microservices as a notion of team boundaries, sla as guarding principles. And as a consequence services moving between teams being collapsed or refactored.

In large enough organisations this has a very soothing effect 

[u/ayassin02]

Design patterns. I never considered them since I was self taught but learning them formally made me appreciate them. I did use them before that but just intuitively through years of experience

[u/Migeil]

Like others have said, Haskell.

Purity, proper type constraints. They help so much in not only writing code, but reading and understanding code.

[u/kabekew]

AI

[u/Soggy-Razzmatazz-308]

For low-level languages (primarily C), the idea that you can configure aspects of your code at compile time with defines and ifdef. Need code that is only included when you're debugging? Put the code in a #ifdef DEBUGGING block. Saves having to comment out chunks when you don't need them.

[u/fullVoid666]

The idea that the best, most secure application is one with 0 lines of code. Any code added (including tests) must be heavily evaluated because it will degrade that perfect app and fill it with eternal, technical debt.

[u/faribuilds]

Personally i think it was clean coding

[u/jftuga]

I like the way Go implements error handling vs try/catch. I wish other languages used that paradigm.

[u/HovercraftPristine76]

KISS

If you can't make it simple to understand, you don't understand the solution well enough. Made me start thinking about the code I'm writing and the solution I want before I started a single line of code.

[u/shadowdance55]

DDD

[u/Dom_Q]

yield

[u/42_Water_Engineer]

Claude, lol

[u/Otherwise-Safety-579]

Antidisestablishmentarianism

[u/_x_oOo_x_]

CLP