GOPHERSPACE.DE - P H O X Y
gophering on hngopher.com
HN Gopher Feed (2017-10-12) - page 1 of 10
 
___________________________________________________________________
TerrariaClone - An incomprehensible hellscape of spaghetti code
160 points by warent
https://github.com/raxod502/TerrariaClone
___________________________________________________________________
 
fancyPantsZero - 59 minutes ago
This makes me sad. Not because of the code quality, but because it
makes me think of all the games I used to write back in middle
school that are now lost to the swirling sands of time. The
youngins don't know how good they have it with github!
 
  sgs1370 - 44 minutes ago
  Your comment reminded me of a game (maybe the only one) I wrote
  in middle school, on a TRS-80 Color Computer (I think 4K,
  although maybe I had the 16K upgrade by the time I wrote the
  game).  I wrote it in basic & saved it on some cassette tape...
  random blocks of one color on the screen, and you are a block
  that starts at the bottom and you use arrow keys to avoid the
  blocks as you are thrust upward.  (I guess it was basic in more
  ways than one).  I might have added a 3rd color block that gave
  you points if you hit those.I wonder if I could even write it now
  - even at low resolution?  My limited scripting is now systems-
  oriented, the tiny bit of UI stuff takes me forever & I find HTML
  & JS way more complex than basic ever was.  (Don't misunderstand,
  I think my python scripts that interact with various AWS
  services, postgres, etc are just fine and don't take me long to
  write or maintain, its just the whole graphics world I never
  latched onto...)
 
azr79 - 56 minutes ago
O(N^2)is hell of a drug
 
tgb - 14 minutes ago
When I first started programming (this was in C++), I decided that
the obvious optimisation was to declare all these redundant local
indices i,j,k as globals. Then the program won't need to make all
this redundant crap! Of course that led to absurdly subtle bugs
that only occasionally showed up since whenever I called a function
which had a loop in it from inside of another loop, I would use i
as the index for both loops. Error! I learned several important
lessons when I figured that one out.But now the author here says
they're doing that same thing! How has this not inevitably led to
problems? Or am I misunderstanding the scoping in Java?
 
beala - 1 hours ago
I think true spaghetti code requires teamwork. I mean that
seriously. You need at least 3 people all with different incomplete
and incorrect mental models trying to modify the same codebase at
the same time.
 
  russellbeattie - 1 hours ago
  I agree. But then again, I'm like a completely different
  programmer than I was a few years ago, and even more different
  than I was years before that. I've got some long running personal
  scripts and projects I tweak every so often, and the end result
  is pretty much the same. "What the hell was I doing here?
  Whatever... I'll just add a bit of code and get it working.
  Done."
 
    davisdude - 55 minutes ago
    That describes my experience with some of my GitHub projects
    fairly accurately.Actual commit I did a few days ago:> Begin
    rewrite of rewrite of rewrite
 
      worldsayshi - 6 minutes ago
      Yeah, that sort explains why it's so hard to get anywhere
      with vaguely defined free time projects.
 
  zokier - 1 hours ago
  Instead of having everyone working at the same time, stretch out
  the team over longer time with some overlap. This ensures both
  the "broken telephone" effect and discourages any major
  improvements.
 
  eric_h - 35 minutes ago
  I disagree. I inherited an app that I'm maintaining that was
  written by one person over ~12 years. When requirements were
  added, he just cloned the app and started making the changes so
  the new app would meet the requirements. Repeat 2 more times, and
  you get to now, where there are 4 similar but not identical
  versions of the same code base, with inconsistently applied fixes
  to various bugs. All 4 still need to work for the organization to
  function.It's old school PHP, with sql queries mixed in with
  markup mixed in with php business logic - if that's not spaghetti
  code, I don't know what is.(I'm replacing it, but it's a very
  slow process).
 
    harrisonjackson - 17 minutes ago
    I'd say one person over ~12 years is basically multiple
    developers working on it. I look back on code after a couple
    months and it often feels like someone else wrote it.
 
      eric_h - 13 minutes ago
      Yep, and in particular, one person over 12 years with one to
      three month breaks between sessions of working on it. He had
      no choice but to "monkey see, monkey do" what his past self
      did, and the resultant product is ... difficult to maintain,
      to put it nicely.[Edit: I don't blame him - I understand how
      it happened, and also why he wanted to get out ;)]
 
    swivelmaster - 4 minutes ago
    I swear I know a guy who would have done this. I have worked
    with him. I have cleaned up his code. I have asked him to clean
    up his code and been yelled at in response.
 
    iaw - 26 minutes ago
    My inherited spaghetti codebase took only 24 months for my
    predecessor to build.  I was told: "don't worry, it's in SVN
    and all of the important switches are clearly laid out at the
    top."Well, it was in an SVN repo... with a single commit.It did
    have all the important switches at the top, none of them but
    the ones that were set actually worked.Man, I "miss" that job.
 
    hinkley - 23 minutes ago
    One of the things it took me a while to intellectualize is that
    'you' a year ago is a very different person from 'you'
    today.Given enough time, maintaining a much larger body of code
    than a single person can reasonably handle, you're going to
    have disagreements with yourself without even realizing it.
 
      eric_h - 18 minutes ago
      Absolutely. When I stumble upon some code in my full time
      codebase that I find distasteful, my first thought is "what
      idiot did this". git blame and sure enough, it's me.Past me
      has been and always will be an idiot as far as present me is
      concerned (with some infrequent exceptions).
 
        moomin - 6 minutes ago
        If you like comic books where the hero has to travel in
        time to fight himself, you'll love programming.
 
    eric_h - 20 minutes ago
    I should add that I volunteered to maintain this project, in
    exchange for free stuff from said organization (not money),
    before I knew what I was volunteering for (heh, lesson
    learned).3 years (of occasional work, maybe 1-4 hours a week)
    later and I've got a layer on top that can interact with all of
    the slightly different data models of the four apps and I'm
    gradually replacing the legacy code with new code and migrating
    them all back into a single database/app.Since I'm not working
    for money, I maintain sole ownership of the code, and I hope to
    eventually turn it into a passive income source, since it will
    be useful to other, similar organizations who have it even
    worse as far as their web applications go.
 
keithpeter - 12 minutes ago
http://sohcahtoa.org.uk/kepler/tmoon.cGrunge C and huge comment
block at start, compiles and works though. One day, I'll revisit
this and have a think about data structures.
 
  Retr0spectrum - 2 minutes ago
  Wow, that indentation...
 
danbruc - 2 hours ago
That actually doesn't look too bad to me. Sure, it's verbose,
repetitive, and deeply nested, but just from skimming it, it looks
quite comprehensible. Load all the data from files instead of
filling huge arrays and maps in code, abstract similar code into
methods, tame the usual mess when dealing with grids with some
helper functions taking care of clamping or wrapping around
coordinates, replace all the parallel arrays with structures, and
you should be able to have some reasonable good code in no time.
Might be a nice exercise in refactoring.
 
  yathern - 2 hours ago
  Truthfully - I wouldn't call it spaghetti code. I think of
  spaghetti code as way to many abstractions
  (AbstractEntityFactoryFactory). This code has the opposite
  problem - needing more abstractions - which is the easier
  direction to move.
 
    jdmichal - 1 hours ago
    > I think of spaghetti code as way to many
    abstractions...That's usually termed lasagna code. Lots of
    layers with a little bit of filling in between.https://en.wikip
    edia.org/wiki/Spaghetti_code#Lasagna_code
 
    flatline - 1 hours ago
    Global state causes code to be spaghettified. Having worked on
    several code bases that qualify as spaghetti code, the hallmark
    trait is that the execution flow is wound back around itself
    many times, like noodles in a bowl of spaghetti, in a way
    that's not easy to trace. You may have nice abstractions or
    none. You may have deeply nested type hierarchies or a
    seemingly nice flat structure. You may be using an IoC
    container with neatly separated services. None of it matters,
    you can get spaghetti code with all of them.Just use global
    state! Then you can have something where Module A depends on
    Module B. Now, at one point Module A calls into Module B which
    fires off an event that's handled in Module C that then calls
    back into Module A. If that event is going through a pub/sub
    notifier, bam, hidden global state. Good luck tracing that
    subtle bug down when you swapped out implementations of Module
    C thinking the new one explicitly filled the contract of the
    old one, or worse yet not realizing Module B indirectly
    depended on C in the first place, and that A's response to the
    call from C may repeat the cycle several times. Soon you
    realize everything depends on everything else and your tooling
    does you no good. That's spaghetti code, just as bad or worse
    than the gotos sprinkled through some ugly C code that an
    undergrad wrote in the 80s.
 
    grtrans - 1 hours ago
    I dunno, i would call spaghetti code code with waaaay too many
    entangled concerns, for which this and global state definitely
    qualifies.Personally i associate it with lack of abstractions,
    or extremely leaky abstractions.
 
    fleitz - 2 hours ago
    Yeah, I call the abstract code problems astronaut code, or more
    generally J2EE best practice code.To me this perfectly fits
    spaghetti code.https://www.joelonsoftware.com/2001/04/21/dont-
    let-architect...
 
    watwut - 1 hours ago
    Spaghetti code is when procedural/functional coding goes wrong
    which is pretty much opposite of too much abstaction.
    Basically, spaghetti is what was before OOP when it went bad.
    At least, I did not heard people to refer to too much
    abstraction as spaghetti before.For the record, this one is not
    that bad. It is comprehensible and pretty easy to refactor.
    Real spaghetti is something you have no idea what it does.
 
beager - 1 hours ago
I did the same trying to write a Minecraft clone back in 2012:
https://github.com/beager/craftalikeI'm very much not proud of the
code, it's sloppy, incomplete, quite copy-pasta. But it helped me
learn a lot of concepts about game dev that a web dev wouldn't
know, and it was tremendously exciting to create something in code
that you could compile and play around with. No regrets.
 
  k__ - 1 hours ago
  I did one too.We basically gave up after the networking stuff
  grew over our heads.
 
writeslowly - 51 minutes ago
This reminds me of the C# source code for DRAGON. Its code was
actually much worse, because the creator wasn't aware of things
like loops or method definitions (the main game loop and class
appear to have been generated by a framework).The C# code is here,
and it works well enough that you can buy it on Steam, apparently:
https://gist.githubusercontent.com/alessonforposterity/832da...
 
  serhei - 33 minutes ago
  The ability to buy something on Steam is sadly no longer a
  guarantee that it works.
 
    jackmott - 26 minutes ago
    I played it. it worked.
 
  dividuum - 33 minutes ago
  I'm a bit reminded of the central GAME.C file from the original
  Duke3D source code: https://github.com/videogamepreservation/duke
  nukem3d/blob/ma...It's almost 10k lines of nested if statements,
  lots of magic values and so on. Still one of the most enjoyable
  games of its time :-)
 
BlakeCam - 10 minutes ago
I wonder how hard it would be to write a program to automatically
refactor code like this into something reasonably clean. My
intuition thinks it should be difficult but possible... and
extremely useful.
 
  jeremyjh - 4 minutes ago
  There are linters which do a bit of this, but they only cover the
  lints they have rules for. I'm pretty sure no one has a rule for
  "all loop indices declared as class members" because no one
  writing code of this quality has yet used a linter. Many issues
  in this code-base are not tractable at all for automated repair:
  how are you going to rework thousands of line long methods into
  well-factored classes and methods?
 
chris_wot - 48 minutes ago
The Terraria clone is apparently very much like the
original:https://github.com/raxod502/TerrariaClone/issues/2
 
amatecha - 7 minutes ago
I can barely even read the README.md ... too scary.  This is
perfectly in time for Halloween season!  :'D
 
indescions_2017 - 1 hours ago
I'd actually try to recruit raxod502 at the high-school senior
level. It certainly shows passion and commitment. You just need to
grok the higher level abstractions. And may in the end even find
your "spaghetti" version is actually more performant at run time
;)The thing is you sort of need to write like this for the first
draft of your first game. And Terraria is pretty ambitious.
Considering most people struggle with BlackJack or Pong or Snake!
 
  azr79 - 55 minutes ago
  > And may in the end even find your "spaghetti" version is
  actually more performant at run timenot with those O(N^2) loops
  it ain't
 
  apo - 1 hours ago
  Writing code in spare time, not to mention 11,000 lines of it,
  already sets any high schooler (or any beginning programmer)
  apart from the majority of peers. It's shocking how little
  students in "AP" computer science courses actually end up doing,
  and how few do anything outside of class.Given the choice between
  interviewing a student who had produced nothing but verbiage and
  one who had produced TerrariaClone, I would go with the latter
  without even thinking about it.
 
    moomin - 1 minutes ago
    When I was 12 (and computers weren't really a thing) I wrote an
    RPG. In ZX Spectrum Basic. It wasn't great (let's be honest,
    TerrariaClone sounds like the Mona Lisa in comparison), but it
    worked. I didn't realise at the time that this weird little
    hobby of mine would stick me right at the front of an emerging
    field. Nor did my family who thought I should be doing.. almost
    anything else. I got ridiculously lucky, all because I started
    writing bad computer games in high school.
 
    criley2 - 1 hours ago
    I had a rather unique AP Computer Science high school
    experience a number of years ago.The AP class was mainly a self
    or group study class inside of a lower level programming
    class.We didn't get as much directed study, but we basically
    were allowed to chose projects that interested us and spent a
    lot of time developing them and getting help, iterating,
    figuring it out.We ended up doing only OK on the AP exam, but
    we had built a pretty impressive little java app by the end. A
    scrolling tile based map, enough network code to run a chat and
    let users join, and we had started building some game logic on
    top of our multiplayer game room. Very cool and informative,
    but not exactly what the AP exam was looking for.
 
      johnvonneumann - 3 minutes ago
      Comments like this kill me a little on the inside, I can't
      stand having real work devalued for the sake of contrived
      assessment criteria.
 
  jackmott - 1 hours ago
  I did pong in rust to learn some rust, and it got me thinking
  how, doing pong was really easy (as an experience programmer) but
  if you wanted to do pong "properly", say supporting 4 different
  platforms, 5 languages, proper settings menu and high score
  table, supporting all manner of screen resolutions, full screen
  and windowed, sound, all popular controllers (keyboard, mouse,
  mobile input, game pads, joysticks) etc etc etcthen even pong is
  pretty hard.
 
hinkley - 4 minutes ago
I would love if we could get together as a community,  take a
project like this, and use it as an example for what a little
refactoring can do.As a cooperative endeavor it should be doable,
but a competition would be more fun, though I can't imagine how
you'd judge such a thing.
 
stuaxo - 2 hours ago
I've seen way worse code than this in my time, some in the last
year.
 
yathern - 2 hours ago
I love DoubleContainer:https://github.com/raxod502/TerrariaClone/bl
ob/master/src/Do...which is fortunately only used in a comment
here:
https://github.com/raxod502/TerrariaClone/blob/9ea04b15add48...
 
  sparky_ - 55 minutes ago
  My favorite part is the overloaded print methods:
  https://github.com/raxod502/TerrariaClone/blob/master/src/Te...
 
  alexwebb2 - 2 hours ago
  I'm sure there was a good reason for that.
 
    Nition - 5 minutes ago
    I'm not so sure. In the readme he says there are over 500 cases
    of "unnecessary boxing."
 
  bcbrown - 1 hours ago
  I really like this method:
  https://github.com/raxod502/TerrariaClone/blob/fd1ff8b8b0e78...
 
    danbruc - 30 minutes ago
    That is probably (x + 1) % 10 assuming x is non-negative. That
    kind of code is responsible for quite a bit of the verbosity,
    the author was obviously not aware of many of the little tricks
    usually used in this kind of code.
 
    hacking_again - 29 minutes ago
    Well, it's faster than %, but I bet it's premature.
 
1001101 - 1 hours ago
I had to see for myself. Yep, that's bad. What's not bad is the
author's attitude about learning and improving. It also looks like
this was a stop on the way to Harvey Mudd CS. [1] So, a happy
ending, perhaps.[1] https://github.com/raxod502
 
  iaw - 23 minutes ago
  With one exception I've never looked back at code I've written
  and thought "well that's well designed."Typically every few
  months I've improved enough to notice the quality difference.
 
Buttons840 - 40 minutes ago
This makes me miss my early days of programming, where no code was
too verbose or horrible to stop me from progressing towards my
goal, no matter how misguided I was. Nowadays I'm distracted by the
first hint that there might be some better way, and all progress
stops. I think I'm just beginning to recognize this, and maybe one
of these years I'll learn to recognize when the right abstraction
is really important and when it's not worth sweating the small
stuff.
 
  awj - 20 minutes ago
  Premature abstraction is generally worse than immature
  abstraction. Write the most straightforward thing you can, and
  wait for that feeling that it won't work out.Then, ignore that
  feeling until you get proof. If you've kept your code simple and
  clean reacting to a lack of abstraction is relatively easy, at
  least compared to what digging yourself out of the wrong
  abstraction is like.
 
  jackmott - 35 minutes ago
  watching the creator of The Witness do some live stream coding
  made me realize this too.  he just typed the convenient thing he
  needed at each moment and didn't try to abstract away the mess.
  just forged ahead.
 
    baby - 20 minutes ago
    Thinking of video game, I think this is a good analogy: a lot
    of what you write in the beginning are just tools to your own
    program.I'm really talking about the lines in your code,
    they're structured so well that they will help forge more code
    in the middle and later parts of your code life.Like any good
    video game, if you produce good tools in the beginning to
    produce levels, modes, multi-player games, etc... then you will
    produce something great.If you don't care about what you're
    writing, then it will become a huge mess and you will either
    give up or your users will give up. Or once in a life time, the
    mess you created will still be fun enough that everyone will
    start playing it, deadmau5 will make a tattoo of it and
    Microsoft will buy you out and you will have the most expensive
    house in the world/LA.
 
  seanmcdirmid - 25 minutes ago
  It is often impossible to write code the first time anyways, just
  do it, realize your technical debt, and come back and refactor it
  when the better abstraction is more obvious (if any).
 
  0xbear - 23 minutes ago
  By the time this happens you?ll be ?overqualified? and ?unlikely
  to be happy?, and therefore unemployable.
 
jason_slack - 39 minutes ago
The fact you took the time to follow your idea is great.
Kudos.Also, the fact you "think" your code is spaghetti shows you
have grown as a developer. Kudos.Love the part about codeToLarge()
 
DubiousPusher - 1 hours ago
A little more egregious than usual but some of this is not that far
from code I've seen in multiple AAA games. Some of which you've
probably played.
 
Zekio - 2 hours ago
I forgot this existed, high quality code right there
 
zokier - 1 hours ago
> The TerrariaClone.init() method, which is over 1,300 lines long,
actually grew so large that the Java compiler started running out
of memory trying to compile it!Seems surprising, 1.3kloc doesn't
feel that big in the scale of things. I wouldn't be surprised if
some of the methods at $work would be on the same scale, and it
compiles just fine (relatively speaking..). And based on quick
scroll-through, there isn't really anything especially egregious in
there that would point towards why the compiler fails.
 
  tigershark - 51 minutes ago
  In one of my previous jobs there was ClassSomething1,
  ClassSomething2 until 5 just because java can't have more than
  65535 methods in a class..
 
  ecshafer - 1 hours ago
  Not having looked at the code, my guess would be what the 1k+ loc
  of method is doing. If it's mainly a bunch or if elsea or a
  switch statement that jumps to another function, which is what
  most gross long Enterprise code is, I imagine it's fine. But if
  you have 1k loc that is procedurally creating objects and doing a
  lot that depends on previous operations then I could see starting
  to run out of memory. We also don't know how much memory they
  had, most Java code for Enterprise is running on pretty big
  servers or workstations.
 
XR0CSWV3h3kZWg - 1 hours ago
And here is someone that is trying to rewrite it in
scala:https://github.com/BusyByte/TerraFrame/tree/convert-to-scala
 
tbodt - 1 hours ago
A perfect example of "it's so bad it's good."
 
flavio81 - 1 hours ago
Beauty. I see beauty. I see God in one 6000-line class
(TerrariaClone.java), overflowing with constant data / tables
embedded in the code.Awesome!PS: "Abandon all hope..."PS/2 * : I
saw it and i suspected this was code generated by other tool; then
somebody commented that this was based on dissasembled .NET
bytecode. This explains it all!* (c) IBM
 
Scaevolus - 2 hours ago
The real Terraria code isn't much better. Here's their 3MB
[decompiled] NPC.cs:
https://raw.githubusercontent.com/csnxs/Terraria/67de21a27e1...They
had serious problems implementing multiplayer because they had to
synchronize objects with 50KB of state every frame.
 
  MrMember - 2 hours ago
  Wow, I just glanced at the how they're generating random names
  and it's incomprehensible. What a bizarre way to do something
  rather simple.
 
    mattchamb - 1 hours ago
    My guess is they are using partial classes and generating a
    bunch of the code from other, much simpler files.
 
  monsieurbanana - 2 hours ago
  Surely this file can't be edited by humans as is, right?
 
  kevindqc - 1 hours ago
  Those SetDefaults methods.. ouch.On the plus side, it's fun to
  press the page down and see the code 'animate' from left to right
 
    k__ - 58 minutes ago
    yes, also that it comes back to the left after it hit the right
    end lol
 
  XR0CSWV3h3kZWg - 2 hours ago
  This looks as if this was a compile target, not the source
  code.HitEffect is a quite the function.This reminds me of working
  on CDDA[1] before many of the refactors hit.CDDA is an
  interesting case, it stemmed from a situation similar to the
  original post (one person project, embarked upon it before
  knowing how to do so). It was a complete mess of macros,
  spaghetti code and data and code living happily side by
  side.https://github.com/CleverRaven/Cataclysm-DDA
 
  kbenson - 2 hours ago
  From the first couple hundred lines, they obviously know how to
  use a switch statement (as in how it works at least), but the odd
  cascade of if statements at the bottom makes me question whether
  they know when to use a switch statement (but then again, the
  stuff a the top makes me wonder that a bit as well).Edit: As
  someone else noted, if this is a generated file, that might
  explain a lot of this.
 
  jcl - 1 hours ago
  Per the description on https://github.com/csnxs/Terraria/ , this
  isn't the Terraria source code -- it's a decompilation of the
  binary.
 
  maxton - 1 hours ago
  Important to note is that this code is not the source code, but
  rather was generated by dotPeek, a C# decompiler, as mentioned in
  the repo's README: https://github.com/csnxs/Terraria/
 
    Scaevolus - 1 hours ago
    Variable names and comments are lost, but the overall control
    flow structure of decompiled Java and C# code closely matches
    the original.
 
      danbruc - 1 hours ago
      Even variable names are usually not lost.
 
  warent - 2 hours ago
  I just scrolled to the bottom and all I see is } } } } } } } } }
  } } } } } } } } } } } } } } } } } } } } }What the fuck
 
    mikeash - 1 hours ago
    This is decompiled code, not the original source, so
    much/most/all of the craziness probably comes from that.
 
      danbruc - 1 hours ago
      Decompiling .NET or Java binaries usually yields code very
      close if not identical to the original source code, at least
      unless an obfuscator was used but that seems not to be the
      case here. Chances are very good the original source code
      looks almost exactly like that code, maybe with some
      additional comments.
 
        thefifthsetpin - 1 hours ago
        In this case, it's just that the decompiler didn't think of
        "else if" as a single control flow construct/keyword in the
        way that the original programmers did.What was no doubt
        written like this:  if(a < 1){   }else if(a < 2){   }else
        if(a < 3){   }else{   }  Decompiled into this:  if(a < 1){
        }else{     if(a < 2){     }else{       if(a < 3){
        }else{       }     }   }
 
          danbruc - 37 minutes ago
          I will try this tomorrow, I am pretty sure dotPeek can
          recognize and output else if. Might be a coding style
          option though.
 
        amyjess - 1 hours ago
        Mind you, a lot of Java 5 and later features like generics,
        switch on Strings, Iterable-based for, etc., are syntactic
        sugar implemented in the compiler, not part of Java
        bytecode, so those features don't decompile well.
 
          danbruc - 41 minutes ago
          I am not sure about Java decompilers, but the .NET
          decompilers I have used all perform pattern matching in
          order to detect and reverse language features implemented
          with compiler transformations.
 
smrtinsert - 27 minutes ago
6560 loc in TerrariaClone.java.  Closed tab, will never look again.
 
  hinkley - 2 minutes ago
  A lot of that file is data.Some of it is just plain data
  (arrays), a lot of the rest is a bunch of setters one after
  another.
 
kevan - 1 hours ago
It's beautiful. I have a sudoku solver that's almost as bad (but
not as impressive as yours) written in Scheme when I was first
learning how to code. It's good to look back on your past work
every once in a while and see how far you've come.
 
S_A_P - 25 minutes ago
As Ive gotten older, I have severely relaxed my dogma on coding
standards. I agree that code should be maintainable, legible and
logically formed. Sometimes though, you just need to get things
done, and architecting a large solution of abstractions and
frameworks, just doesn't seem like a good use of time.
 
  hinkley - 14 minutes ago
  For me it feels more like a zero sum game.Some things I care
  about a lot less, others I care about more.  The biggest problem
  I have is with obscure code, and my understanding of obscure has
  shifted over time.Basically, I prefer code that gets you to ask
  the right questions.  I'm still trying to put my finger on what
  qualities those are.I still care about code that looks one way
  but does something else, and I care about code that conceals what
  it's doing and how it accomplishes it by using convoluted
  delegation.But a function with a single purpose and clearly
  named?  If it's loaded with kruft I only care if it's on a flame
  chart or I have to keep stepping through it while debugging
  another issue.  So I care more about functions in the middle or
  the top of the call tree and less about the leaf node ones.I
  still push back on "It's not that hard to figure out this code"
  on the grounds that when an odd bug happens I'm going to be
  scanning dozens of functions trying to spot an issue.  If every
  one is chock full of code smells, that process takes forever.  In
  fact it discourages people from doing the right thing and instead
  they slap more workarounds on top instead of trying to find the
  real cause.
 
[deleted]
 
twic - 25 minutes ago
Reminds me of a rather insightful comment from a Hackernews a few
years ago [1]:> People write MLOC monstrosities in Java because
they can. You get some boring financial topic and some sub-par
programmers and they'll write as much garbage as the language can
possibly sustain.> These things are a testament to how safe and
simple Java is as a language.> Not having massive crappy code bases
is a negative sign in terms of how reliable and easy to understand
a language is.[1] https://news.ycombinator.com/item?id=7653762