The Developer's Journey: A Graph of Code Complexity vs. Experience

Description

A hand-drawn graph plots 'code complexity' on the y-axis against 'years of programming' on the x-axis, illustrating the evolution of a developer's coding style. The graph starts at 'super simple code,' then ascends steeply through phases labeled 'oop everywhere' and 'design patterns.' It peaks at maximum complexity with annotations like 'abstractions,' 'interfaces,' '"i might need this later,"' and 'this is what the experts do.' Finally, the curve descends back to the baseline, ending at 'super simple code' again. This chart is a classic representation of the developer's journey. It humorously depicts the common trajectory of moving from naive simplicity to a period of over-engineering - where developers, armed with new knowledge, create unnecessarily complex systems. The final return to simplicity signifies true mastery: the ability to solve complex problems with elegant, maintainable, and straightforward solutions, having learned the high cost of complexity through experience

Common Tags

CodeComplexity DeveloperHumor DesignPattern OverEngineering RelatableHumor ObjectOrientedProgramming CodeQuality SeniorVsJuniorDevelopers LearningCurve

Comments

Anonymous ★ Top Pick You know you're on the right side of that curve when you replace a 12-class strategy pattern with a single 'if' statement and call it a win

Anonymous ★ Top Pick

You know you're on the right side of that curve when you replace a 12-class strategy pattern with a single 'if' statement and call it a win
Anonymous

My proudest senior moment: a PR diff of - 3,421 / +1 replacing AbstractVisitorFactoryServiceInterface with `return data;` - merged in twelve seconds and a collective sigh of “finally.”
Anonymous

After 20 years, you realize the AbstractFactoryFactoryBuilder pattern you architected for that config file parser could have just been a JSON.parse() call with a try-catch
Anonymous

This graph perfectly captures the arc of every architect's career: you start writing procedural spaghetti, discover the Gang of Four and suddenly everything needs seventeen layers of abstraction and a factory factory, then after debugging your tenth AbstractSingletonProxyFactoryBean at 3 AM, you realize the junior who just wrote a 50-line function that actually works might be onto something. The real senior move is knowing when NOT to use that design pattern you spent three years mastering
Anonymous

Real seniority is deleting the AbstractFactoryFactoryManager and replacing it with two small functions and a map, because YAGNI pages less than inheritance
Anonymous

The expert's secret: every abstraction layer you add today is just future tech debt you'll pay off tomorrow - with interest
Anonymous

Peak architecture is the day you justify an IStrategyFactoryProvider; true seniority is deleting it and shipping a 30‑line function with tests
@ideugen 2y

База
1. @ZgGPuo8dZef58K6hxxGVj3Z2 2y
  
  English only
  
  @Iplay2hours 2y
  
  Baza
  
  @ZgGPuo8dZef58K6hxxGVj3Z2 2y
  
  Whatever that is
  
  @Iplay2hours 2y
  
  that means something "super obvious thing", like smoke after eat
  
  @xamnol 2y
  
  baza = based
  
  @ZgGPuo8dZef58K6hxxGVj3Z2 2y
  
  Ah makes sense
  
  @AlexKart20129 2y
  
  base, not based
  
  @xamnol 2y
  
  Lol, “Based” is a well-known meme and nobody uses “base” in this context
  
  @AlexKart20129 2y
  
  yes, but russian meme "это база!" (eng. "it's a base!") has a different meaning and typically used in different context
  
  @endisn16h 2y
  
  all your base are belong to us
  
  @CcxCZ 2y
  
  you have no chance to survive make your time
@s2504s 2y

True story
@bezuhten 2y

is this meme correct? any super experienced programmers here?
1. @RiedleroD 2y
  
  I'm not that experienced, but I know I'm past the maximum. I sometimes used really complex patterns in the past, but nowadays I just do what works.
  
  @RiedleroD 2y
  
  non-professional self-taught dev of 7 years btw
  
  @RiedleroD 2y
  
  well, semi-professional. I had an internship this summer, and the company seemed to be happy with my work, so.
  
  @Fatimel 2y
  
  lol what were you doing all that time))))
  
  @RiedleroD 2y
  
  school
2. @Fatimel 2y
  
  yes. at least couple of super experienced devs that I watch say that. didn’t get their position for some years, now understanding the meme myself fck oop, btw… ruined my early dev life
@hotsadboi 2y

non-professional dev of 2 years, going through my functional programming arc atm. which part of the slope is that?
1. @RiedleroD 2y
  
  the slope is quite simplified, but I'd guess just a bit before the peak. Depends on how you use it ig
@dsmagikswsa 2y

I am in Oop everywhere now Anyone else?
@CcxCZ 2y

Part of the reason IMO is that OOP (FSVO OOP, Alan Kay would beg to differ) and design patterns are taught as to how, but not why and when.
@ArtemVoikov 2y

Have you noticed how OOP has died? Yes, it happened a long time ago, and no one noticed.
1. @CcxCZ 2y
  
  It died like four times by now. 🤷‍♀ There wasn't agreement on what it meant in the first place.
  
  @ArtemVoikov 2y
  
  Since C++ it was about inheritance, polymorphism and encapsulation. After IoC we have: 1) inheritance has been substituted by injection, 2) single implementation of an interface - yes, no one wants to write unit tests = no polymorphism 3) DTO/POCO everywhere. Encapsulation is the last man standing, but it will surrender any time soon to reflection and code generators.
  
  @Araalith 2y
  
  Inheritance has been replaced by composition. Because no one wants to guess what will happen with the base class after an update.
  
  @CcxCZ 2y
  
  CLU got it right and Simula wrong :]
  
  @ArtemVoikov 2y
  
  yes, this is more accurate definition.
  
  @CcxCZ 2y
  
  Without inheritance most functional languages with typed interfaces (Standard ML, Haskell) or in general structurally typed procedural languages (Modula2/3, Algol68, probably Go) would now count as OO languages. A way to implement virtual methods was the addition to Caml to make it OCaml.
  
  @CcxCZ 2y
  
  We've talked through this extensively here https://loup-vaillant.fr/articles/deaths-of-oop https://t.me/devs_chat/52446 https://t.me/devs_chat/52487
  
  @ArtemVoikov 2y
  
  Good article. I would be glad to see an example of a code, that would substitute a C++ method Render(listOfObjects) that wouldn't use polymorphism with the same or faster performance and that would've increase of developers KPI.
  
  @CcxCZ 2y
  
  Well, listOfObjects kind of implies that the list contains references to things with different behaviors. The traditional functional approach here would be closures. Both methods and closures are something that you can call/evaluate to access some local state. There are no clear wins in performance here. The main performance advantage we see with ECS is move from what http://canonical.org/~kragen/memory-models/ calls LISP memory model (which the regular OOP-y use of C++ has) to Fortran memory model by using memory pools and thus having huge locality improvements. And that's quite general concept. However I think this article might be closer to what you intended to ask: https://blog.janestreet.com/why-gadts-matter-for-performance/
@ZgGPuo8dZef58K6hxxGVj3Z2 2y

Yeah ignore catch just have them there to not take the whole docker container down

Use J and K for navigation

The Developer's Journey: A Graph of Code Complexity vs. Experience

Description

Categories

Common Tags

Comments

More like this

Senior Dev Code Too Complex, Junior Dev Code Also Too Complex

I Write Spaghetti Code and AI Adds the Meatballs

Clean Code's legacy: 25 functions to do the work of one