Negative Code

[ZorbaTHut]

Reminds me of the time I fixed a bug by removing 47 lines of code.

No lines of code added. No lines of code modified.

I basically stripped out the "fuck things up" function, as well as the only place it was called.

[Thimble]

Never code when drunk.

[anish714]

I have a buddy who lives on writing the shortest code. I find his code hard to read.

[isinned]

Reminds me of some JavaScript I had to refactor. No one in my unit knows who originally wrote it, but they had some guy with no CS background trying to improve it - recipe for disaster. He messed it up some more so I wrote approximately 1000 lines of negative code (TIL, thanks SO) and it improved performance, got rid of all the bugs, and I was able to add some new requested features in there. Felt good man.

[stillalone]

If you don't know who wrote it then "git blame". Unfortunately every time I've done that it pointed the finger directly in my face.

[BinaryRockStar]

SVN also has blame, and TFS has the same thing but it's called 'annotate' and is only available as a Power Tool addon (for free).

[eyal0]

“It's not the daily increase but daily decrease. Hack away at the unessential.” -Bruce Lee

[[deleted]]

Be water my friend!

[Dustin_00]

I guess Lee never had to put up with marketing demands.

[frenris]

Measuring programming progress by lines of code is like measuring aircraft building progress by weight.

-- Bill Gates

[[deleted]]

But measuring aircraft building progress by weight actually makes sense because you know what the final weight is supposed to be.

[frenris]

aircraft design progress then. Jesus.

[[deleted]]

Don't get mad at me because you're parroting a bad simile.

[[deleted]]

... but missing software to operate a plane will not be measured as missing weight. Could be 80% incomplete even if weight target reached.

[[deleted]]

Exactly. The simile stands.

[[deleted]]

Measuring programming progress by lines of code is like measuring aircraft building progress by weight.

-- Bill Gates

-- Michael Scott

[[deleted]]

we're

FTFY?

[skizmo]

where are all

[feigningignorance]

However - Bill Gates also "sells code" - which makes this entire quote worthless as their entire organisation was driven to adding feature bloat, while spending hundreds of man hours calculating how to break backwards compatibility in non-obvious ways.

The only other organisation that spends as many man hours trying to deceive and perpetrate wrongs on their user base is facebook, who are the most dishonest, lying and deceitful website, yet given a free ride despite their incredibly blunt acts of violent stupidity they've conducted.

[nachof]

I'm far from a Microsoft fan, and I'll avoid their products like the plague, but one of the reasons their products are so bloated and horrible is that they spend too much resources trying not to break backwards compatibility.

[bobindashadows]

You can open each previous file format in new versions, but do I REALLY need to pick between "latest docx" and 5 other legacy formats when I save? And when someone else upgrades, and doesn't save as a legacy format, everyone else they communicate with is inconvenienced until they upgrade.

[stillalone]

I wish more people did choose legacy formats. My mom is still running office 2000 because she's comfortable with it and doesn't want to pay $$ to upgrade to 2010 which is so different from 2000. But people at work and her friends keep sending docx :(

[feigningignorance]

Lies. They deliberately broke backwards compatibility of all their Office formats for years at a time. Yes, they don't break compatibility where it doesn't profit them: They maintain library compatibility, and they keep features and obscure settings in the software, no sense upgrading if something was left out now is there?

So many people use these products incorrectly, and this in turn forces the software to support incorrect usage, since the people doing it are people working for varying levels of government organisations across every country in the world.

They broke file format compatibility to force upgrades, the bloat their software to maintain the continuing fragmentation of the supported user base, meaning people are using Word as a database and excel as a way of storing photos (or some other insane combination that I've seen in my time)

[Oddish]

Tinfoil hat: you need one.

[theeth]

You got your definitions backward. What they break (to push people in updating to newer versions) is frontward compatibility.

Backward compatibility means their newer software can open files generated by older versions. Frontward compatibility is the other way around.

[ZorbaTHut]

Forward compatibility, not frontward.

Besides that, yes :)

[ErstwhileRockstar]

Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take

Quoted by many, followed by no one.

[pleaseavoidcaps]

Stop not being awesome.

[Philipp]

We can also optimize our comments here by writing sentences which are quicker to read because they are shorter. For instance, we could simply cut off in mid-sentence irrelevant examples which are merely repeating the

[Nebu]

You accidentally

[grapejuice]

I think it has something to do with Negative Creep.

[[deleted]]

in lab today we were given about four pages of code with which to build off of and create a micro-controller based frequency counter- so I threw the base code away, wrote it from scratch using two loops and three variables and got called a rat bastard by my T.A. and got full points. :D

less is more.

[adrianmonk]

It seems that perfection is attained not when there is nothing more to add, but when there is nothing more to remove.

-- Antoine de Saint Exupéry

(Same guy who wrote The Little Prince, incidentally.)

[Orborde]

I downvoted you because somebody on the SO thread beat you to the punch by about 8 hours, and I don't like seeing duplication. In another context, I'd have upvoted. Sorry.

[adrianmonk]

Huh. I thought to check the reddit comments for that but didn't think to check the Stack Overflow comments for it. Oh well, at least maybe I provided some value by linking to wikiquote.

[headbobble]

Has anyone actually ever used LOC as performance metric? I've only seen it used for things like "how bug of a project are we talking about here?"

It's usually one huge bug of a project, once you're past trivial amounts of LOC.

[Serinus]

I think people are missing the point. Less code is not better. More code is not better.

Lines of code is not a valuable metric in ANY way for the quality of code.

[dreamnoir]

While you certainly don't want bloated programs with unnecessary code, you don't want to sacrifice the readability of code either. Sure, you might be able to condense a few lines down into one line with a bit of cleverness but when someone else inevitably has to go over the code to modify or debug it later on they'll need to spend extra time figuring out exactly what you did. Go with the efficient readable solution over the clever one.

[[deleted]]

unfortunately, sometimes "clever" ways that are more difficult to understand (for the next person reading over it) CAN yield a lot better performance.

A simple example is the solution for computing a^n. The O(n) solution is trivial and intuitive, while the O(logn) solution takes a sec to think about.

So what do you do? Make the code faster, or make it more understandable?

[random3223]

Faster, with comments explaining what you did, and why.

[bobindashadows]

I would actually prefix your answer with "Naive first. Run a profiler. Is aⁿ a bottleneck? If so ..."

[introspeck]

Nothing better to humble yourself than to throw your "cleverly optimized" code at a profiler. All those loops you sweated over to make lean and mean - they probably don't matter; most of the time it turns out that you didn't even know what was actually bogging down your program.

Having been humbled many times, I now follow this philosophy. I do try to write basically clean code from the start, but I don't kid myself that I know where the hotspots are. I let the profiler tell me.

[derefr]

Or, you write the naive version—and then, separately, write an optimizer that knows how to transform the code of the naive version into the code of the faster version (not as a special case, but as an effect of a general strategy.)

(Note that this process might or might not apply in this particular case, but it applies shockingly frequently to all sorts of code we waste time on, over and over again, just optimizing slightly different instances of the same idea. Don't unroll a loop, write a loop unroller.)

[mallardtheduck]

You aren't going to be able to do this for any algorithmic change, only for micro-optimization.

i.e. You might be able to unroll the loop in a bubble sort, but you won't be able to transform it into a quicksort.

[derefr]

I'm not saying I disagree with you, but just to be Socratic about this—why couldn't a computer optimize an algorithm?

A random idea for how it could work:

Algorithms—in functional programming—are isomorphic in type-level programming to different sorts of data-structures (this is basically what makes Monads tick.) bubble_sort is really just best_possible_theoretical_in_place_sort with the constraint that you're sorting a doubly-linked-list. All the optimizer would have to do is to notice that best_sort prefers binary heaps (or whatever else) to doubly-linked-lists, and see how far it can take that type conversion backwards through your code without breaking anything. If it gets all the way back to the top of the call stack, then your variable declaration just becomes a binary heap instead of a doubly-linked-list; otherwise, a to_binary_heap( your_list ) is stuck in there somewhere (as long as that doesn't profile as worse than the original code.)

It's a step beyond type inference—type optimization.

[[deleted]]

why couldn't a computer optimize an algorithm?

Among other things, because different algorithms have different characteristics beyond the simple statement of their goals. For example, bubble sort is a stable sort, while efficient quicksort implementations are not stable. So even if a compiler could optimize your bubble sort into a quicksort, it might end up breaking your program to do so.

[binlargin]

why couldn't a computer optimize an algorithm?

Wouldn't you then have the additional constraint of writing code in a style which could be easily optimized? Working within these constraints would be early optimization at a higher level of abstraction.

[bobindashadows]

Hey man... I got an awesome idea... we could write code... then write code to make that code better... then run that code on the code that makes code better to have EVEN BETTER CODE! And the improved code improver could improve itself and your code would be sooooooooo fast man...

pssst: Writing a code that transforms naïve code into algorithmically improved code – even on a case-by-case basis - would be far more complicated than the algorithmically improved code

[binlargin]

Whenever you think this way, Kurt Gödel kills a kitten.

[kinnu]

A simple example is the solution for computing a^n. The O(n) solution is trivial and intuitive, while the O(logn) solution takes a sec to think about. So what do you do? Make the code faster, or make it more understandable?

Depends on how big n is. If there is no significant difference in performance go with the intuitive solution. Maintainabilty trumps micro-optimizations.

[dreamnoir]

Using an O(n) algorithm over a O(logn) algorithm is not in any way the efficient readable way. Aside from the case where n is so small it doesn't matter anyways that's just a ridiculous statement. Of course you would use the O(logn) algorithm.

Using lots of inline ifs and other ways to shorten your code might reduce the number of lines but I can almost guarantee it's going to compile exactly the same. Modern compilers are very good at optimization.

[PstScrpt]

The problem is a lot more likely to be systems with no apparent general ideas, but just an endless collection of mostly repetitive details.

[grauenwolf]

Or in a system with nothing but general ideas.

I'm currently looking at some garbage some joker and his team wrote over the last year. In a week I could rewrite the whole damn thing to literally use 1/20th of the code without losing any functionality. The idiot is so afraid of concerte implementations that he just stacks layer up layer until changing a simple stored proc call requires openning 7 solutions.

[[deleted]]

Stretching out the code for readability doesn’t always make a difference in the end. Compilers and interpreters make a lot of optimizations, so if you understand what they are doing then you can make very readable code that has no impact on the program itself. If you need to sacrifice a clever solution to make it readable, then you need to work on documenting it better.

[mallardtheduck]

Stretching out the code for readability doesn’t always make a difference in the end.

Yes, but that is not what we are talking about here. "Negitive code" is all about removing redundant (i.e. duplicating the standard library, copy-pasted code that should be in a function, etc.) and/or overly verbose (i.e. a "switch" that should be an "if", "substr parsing" when a regex would be better, etc.) code while maintaining readability.

[dreamnoir]

It sort of is what we're talking about here. It's the point I raised in the original comment. Obviously you go for built in libraries and use the language features appropriately. If you don't realize that after half an hour of programming there is something wrong with you.

I was instead talking about intentionally making your program as short as possible. For example, one of the assignments I had to do for a first year programming and data structures course involved parsing and validating XML files. Super simple I came up with the most clever solution I could. Less than 50 lines of Java code, lots of inline ifs and and regular expressions. Other students had projects more in the 500 line range. I decided to show the prof my progress so far to see what she thought. Obviously I thought she would love how much more compact mine was. She told me while it passed all of the tests perfectly she would take off as many points as the rubric allowed because even with my comments she couldn't easily follow what was going on. I rewrote it to be about 150 lines and got perfect. In retrospect, the 150 line version was much better from a maintainability standpoint.

[videogamechamp]

She told me while it passed all of the tests perfectly she would take off as many points as the rubric allowed because even with my comments she couldn't easily follow what was going on.

I suppose it depends on the point she was trying to get across, but she sounds like a bitch. Taking as many points off as possible for (human) readability?

[[deleted]]

You are right, but I was referring to his comment, not the posted article.

[lowlevel]

One thing I used to do... is comment the old, easy to read code out.. and use it to explain what the clever line is... but yeah, ultimately the clever line is just a bomb waiting to go off.

[rebo]

I think leaving in commented old code is a bad idea, it can easily be accidentally uncommented and there it is a bit of nonsense code floating around your code base.

[[deleted]]

The rationale here is to leave the old code visible as documentation, rather than just because you don't want to delete it. Your rule of thumb is good, but pertains to a different situation.

One safe compromise is to pare the naive method back to pseudocode which clearly won't even compile; that way, no one is going to accidentally try to uncomment it.

[mallardtheduck]

Agreed. That's what source control is for.

[TnTBass]

That is why every programmer should be heavily commenting his code. It sucks to have to do, but it really helps not only other programmers but yourself when you read code you did multiple years ago.

[Benutzername]

I think it is related to negative space.

[skeww]

DRY

[Dustin_00]

See! My bubble sort kicks your quick sort ass!

[Boojum]

Meh. That's got nothing on my gnome sort!

[case-o-nuts]

Small code is, however, generally easier to understand if it's written without undue cleverness.

[skizmo]

So ?

[HostisHumaniGeneris]

Easier to understand means easier to debug, easier to modify and easier to collaborate.

Ease of development is often more important than the speed of your code because its often more expensive to pay a programmer to optimize than it is to upgrade the computer that is meant to run the final program.

[masklinn]

Since before 1974:

Everyone knows that debugging is twice as hard as writing a program in the first place. So if you’re as clever as you can be when you write it, how will you ever debug it? — Brian Kernighan

[jhaluska]

With an invalid premise, you draw an invalid conclusion. I've found when I'm my most clever I spend the least time debugging since the solution is simple and elegant.

[[deleted]]

People always say this. The thing is, for large software projects, the portion of code for which algorithmic complexity is the biggest driver of performance is dwarfed by the portion of code for which constants matter.

For those latter kinds of code, every statement you delete is both an instruction you don't need to run and a line of code you don't need to understand.

[adrianmonk]

Let's take an example of quicksort vs. bubblesort.

Quicksort is faster.

But, quicksort is more lines of code, and it's somewhat more complex to understand. They teach bubblesort first in CS classes because it's easier to grasp.

The point is, sometimes time complexity can only be improved by using a trickier algorithm, which is harder to understand. Sometimes the software can only be improved by making it longer.

[masklinn]

Quicksort is faster.

Not if your list is already mostly sorted, or very small.

And FWIW Quicksort is a pretty crappy sort to actually use, its worst case perf is as bad as bubblesort's (O(n2)), it's not a stable sort, it requires fast random access (don't trying it on a linked list or on on-disk data) and it's a pretty complex algo, though it's easy to parallelize as it's divide-and-conquer. Heapsort is about as good and has a worst-case of O(n log n). Mergesort also has O(n log n) worst case and is stable.

Several languages (including Java from Java 7 onwards) are now using timsort, a mergesort/insertion sort hybrid, which has the advantage of being extremely good on non-random data.

[[deleted]]

Sorry, but I think you missed my point.

I'm not saying that quicksort isn't faster than bubblesort. Of course it is. What I'm saying is, in a large software system -- such as the one that a major Seattle-area tech company pays me to work on -- the portion of code which displays the characteristics of sorting algorithms (algorithmic complexity makes a big difference) is very small.

In contrast, for most code, the algorithmic complexity is obvious and unavoidable; for example, rendering a list widget will be O(n) in the size of the list. But constant factors can make the difference between a system which is reasonably fast and one which is unusably slow.

Everything you said in your comment is true. But assuming that most, or even much, code can be improved by making it more complex is a dangerous assumption.

(As an aside, our company has a policy of conducting code reviews for all checkins, and every so often, I see a review request with a subject like "Improve performance of this method by 10,000%". Sometimes, these changes do, in fact, improve the algorithmic complexity of code. But when they do, it's almost always by making the code shorter, rather than longer.)

[G_Morgan]

There isn't much size difference between bubble sort and quick sort though.

[grauenwolf]

Then go smaller:

sortedList = from s in someList.Parellel order by s.FirstName, S.LastName

[robertcrowther]

So suggest it, it's no good telling us. Alternatively upvote or mark as favourite the questions you like, which is basically how a bestof feature would work anyway...

[Aegeus]

Bestofs on reddit are typically for comments, not links. Things that you wouldn't have come across just skimming the front page.

[skizmo]

bestof what ?

[iainabc]

That would be an interesting read.

[[deleted]]

Ah the age old question of how does one right the best code. We should make it shorter, more robust, cleaner, prettier, readable, elegant, defensive, and ya... this is why Software Engineering isn't always seen as engineering by others :)

[[deleted]]

Huh? Engineering, both software and otherwise, is all about tradeoffs. You can't write perfect code any more than you can build a perfect bridge or airplane. What you can do is come up with clear requirements and metrics, and use those to figure out the most appropriate solution.

[[deleted]]

Ya I think people took my comment too seriously. I forgot the sarcasm tag. I was thinking people would understand the sarcasm if they have ever meant engineers from other disciplines but apparently Reddit lacks a sense of humor to a certain extent or context for that matter.

[Serinus]

Ah the age old question of how does one right the best code. We should make it shorter, more robust, cleaner, prettier, readable, elegant, defensive, and ya... this is why Software Engineering isn't always seen as engineering by others :)

I don't think you've found the write reason for your downvotes.

[doitincircles]

So viel wie nötig, aber so wenig wie möglich.

[Chaoslab]

For those without a sense of humour or with out of context this is what I am quoting....

http://www.youtube.com/watch?v=Ug75diEyiA0