The most extreme thing that could possibly work

re: The most extreme thing that could possibly work

Michael Giagnocavo — Mon, 14 Jun 2004 05:35:00 GMT

"One line" is a bad metric. Here's what happens if you do that:

Your code looks worse and worse, as you inevitably try to cram more info into the line:

public string Hash(string s)
{
return Convert.ToBase64String(new MD5CryptoServiceProvider().ComputeHash((System.Text.Encoding.UTF8.GetBytes(s))));
}

And the output is a lot worse too. IIRC, The compiler outputs stack based code instead of using locals. I actually benchmarked this code a while ago, and it was slower this way than doing it using a few locals (and the resulting IL was a bit larger).

So you get:
1: Harder to read code.
2: Harder to debug code (see greggm's WebLog)
3: (Maybe) larger code.

As well, this doesn't work very well if you need error handling.

I just don't see how trying to conserve lines any more than usual is going to help at all. All I see it doing is stopping coders from making things extra clear.

Of course, you could just remove the newlines -- would that count? ;)

re: The most extreme thing that could possibly work

Andy — Mon, 14 Jun 2004 11:36:00 GMT

The point isn't to write methods that only contain one line. The point is to think about doing so - what would happen *if* all your methods were one line long? This is the farthest that you can take the concept of "how small should my methods be", since it obviously doesn't make any sense to have methods with zero lines.

If you don't consider this case, then why did you "stop" by making all of your methods 5 lines? Or 10? Or some other arbitrary number?

re: The most extreme thing that could possibly work

Jim Argeropoulos — Mon, 14 Jun 2004 13:53:00 GMT

I worked with a self trained C guy once. His idea of good code was the smallest footprint you could have. Well this resulted in code that was very compact, but few besides him could read it.

I know that you are not saying this, but it is the danger.

On the whole I agree with you. I like short functions. One purpose. Self describing/commenting code. I frequently run metrics analysis on my code, just validate myself. I like to keep my cyclomatic complexity under 6 (switch statements are the gotcha's) and my line count low. But I find that if I stick to one purpose, the line count is usually automatically handled.

re: The most extreme thing that could possibly work

Jim Argeropoulos — Mon, 14 Jun 2004 13:56:00 GMT

Do you find that when you learn something new, you use it everywhere?

I have. I need to check myself sometimes. There are times when the latest technique I learned, just should be put back on the bookshelf. But on the whole I am a better programmer because I apply those sometimes in appropriate tools. I guess it is my way of learning their limits and uses.

re: The most extreme thing that could possibly work

David Cottrill — Mon, 14 Jun 2004 16:15:00 GMT

Be careful -- I can tell you from personal experience with Perl one-liners that you are on the path to perdition... ;)

re: The most extreme thing that could possibly work

Jesse Ezell — Mon, 14 Jun 2004 17:21:00 GMT

Just about the only worthwhile one line methods are function overloads, because of C#'s wonderful lack of default parameters :-).

It is far more important to understand that methods are about small, logical units of work than it is to break them up into 1 liners. You are focusing on the wrong problems if you are counting the lines of code in your methods.

re: The most extreme thing that could possibly work

Darrell — Mon, 14 Jun 2004 17:39:00 GMT

David - no kidding! I used to write recursive perl programs that would scrub my entire web site (university web site), and the only interesting stuff happened on 1 line! Yikes!

But Jaybaz(?) has a good point. It's like the old game show "Name that tune", where people bid down the number of notes they need to figure out a song. The really good people could win it in 1 note! It teaches you to concentrate to figure out what exactly is the minimum needed to accomplish your goal. Challenging conventional thinking, thinking outside the box, and all that blah blah blah. :)

The most extreme thing that could possibly work

Darrell Norton's Blog — Mon, 14 Jun 2004 22:43:00 GMT

The most extreme thing that could possibly work

re: The most extreme thing that could possibly work

Mon, 14 Jun 2004 20:44:00 GMT

rex onliner

It Looks Like ML to me....

Wizzy's World — Tue, 15 Jun 2004 00:32:00 GMT

Properties as objects

jaybaz [MS] WebLog — Tue, 15 Jun 2004 00:42:00 GMT

re: The most extreme thing that could possibly work

Darren Oakey — Tue, 15 Jun 2004 02:11:00 GMT

I go with the idea of no duplication.... at all.. Which does lead to lots of one line functions - but often, you then realise these functions you use a hell of a lot - you put them in your common libraries, and suddenly the world all gets better again.

My rule is simple: you do it once, fine. Twice, optional. Three times NO

For example -
F1: if ( myString.Instr(subString)!=-1) ...
F2: if ( theString.Instr(stringToFind)!=-1) ...

that's not good - time for

bool StringContains( string stringToCheck, string stringToFind)
{return stringToCheck.InStr( stringToFind)!=-1;}

And immediately
a) your code looks better
if ( StringContains( myString, subString))

b) you have something you can use in lots of places, and will work with different implementations of string in the future

c) you have something that when you find odd situations (what do we do with null strings?) - (what do we do with empty strings?) - you can solve the problem across the board.

Yes - this means that my code is littered with one line functions, but a few points:

1) each time I do this, the actual raw _size_ of my code gets smaller
2) you would be surprised at how many of these one line functions don't stay one line!
3) every time I fix a problem or enhance one of the functions, the code improves _across the board_

So - basically, don't set out to design functions this way (I go with the rule one screenful is utter max for a function, including comments) - but also don't permit any code duplication - anywhere - and you automatically evolve quite an elegant structure - I guarantee it :)

re: The most extreme thing that could possibly work

Sean — Tue, 15 Jun 2004 04:16:00 GMT

Here's the most compact, semi-useful code I know of:

DVD Decrypt
The program takes a five-byte title key on the command line (five decimal numbers in least to most-significant order, separated by colons) and an MPEG 2 Program Stream VOB file on stdin, and outputs a decrypted version of the VOB file. For example: to play a movie whose title key is 0xcd302010fe, do: cat file.vob | perl -I 254:16:32:48:205 qrpff | extract_mpeg2 | mpeg2dec -

#!/usr/bin/perl # 472-byte qrpff, Keith Winstein and Marc Horowitz <sipb-iap-dvd@mit.edu>
# MPEG 2 PS VOB file -> descrambled output on stdout.
# usage: perl -I <k1>:<k2>:<k3>:<k4>:<k5> qrpff
# where k1..k5 are the title key bytes in least to most-significant order

s''$/=\2048;while(<>){G=29;R=142;if((@a=unqT="C*",_)[20]&48){D=89;_=unqb24,qT,@
b=map{ord qB8,unqb8,qT,_^$a[--D]}@INC;s/...$/1$&/;Q=unqV,qb25,_;H=73;O=$b[4]<<9
|256|$b[3];Q=Q>>8^(P=(E=255)&(Q>>12^Q>>4^Q/8^Q))<<17,O=O>>8^(E&(F=(S=O>>14&7^O)
^S*8^S<<6))<<9,_=(map{U=_%16orE^=R^=110&(S=(unqT,"\xb\ntd\xbz\x14d")[_/16%8]);E
^=(72,@z=(64,72,G^=12*(U-2?0:S&17)),H^=_%64?12:0,@z)[_%8]}(16..271))[_]^((D>>=8
)+=P+(~F&E))for@a[128..$#a]}print+qT,@a}';s/[D-HO-U_]/\$$&/g;s/q/pack+/g;eval

re: The most extreme thing that could possibly work

jaybaz [MS] — Tue, 15 Jun 2004 15:14:00 GMT

My favorite was the 3 lines of perl that implemented encryption strong enough to be classified as a munition, and therefore illegal to export.

I have trouble grokking the notion of "export of software". Somehow it seems meaningless.

re: Interface implementation

jaybaz [MS] WebLog — Sat, 19 Jun 2004 18:45:00 GMT

No castes!

jaybaz [MS] WebLog — Mon, 21 Jun 2004 20:43:00 GMT

Jay Bazuzi

public MattBerther : ISerializable — Wed, 23 Jun 2004 21:42:00 GMT

One of my favorite bloggers as of late is Jay Bazuzi (rss), who works on the Visual C# IDE team at Microsoft. Give him a read; he's got some posts that are sure to melt your brain, such as "no...

Looking for small programming problems

jaybaz [MS] WebLog — Tue, 29 Jun 2004 02:34:00 GMT

re: The most extreme thing that could possibly work

Chad Myers — Mon, 28 Jun 2004 23:51:00 GMT

Uh oh, jaybaz, Sean just made this weblog illegal! The MPAA will be coming to confiscate your computer soon. Run!

re: The most extreme thing that could possibly work

Sean — Tue, 29 Jun 2004 01:11:00 GMT

*hangs my head* sorry man! ;)

re: The most extreme thing that could possibly work

Aleksei Guzev — Tue, 29 Jun 2004 03:55:00 GMT

Hi,
You will get effect of huge function on another level. We use functions and classes to bring stucture to our code. When every function is one-line long they become similar to each other because they are of the same length. This will make Your code homogenous like assembler but with much longer statements.

Aleksei Guzev

Test Methods are neither Methods nor Tests

jaybaz [MS] WebLog — Fri, 02 Jul 2004 03:49:00 GMT