99 Bottles serial key or number

Here&#;s the first of four different solutions to the "99 Bottles" song.

Listing Incomprehensibly Concise

This first solution embeds a great deal of logic into the verse string. The code above performs a neat trick. It manages to be concise to the point of incomprehensibility while simultaneously retaining loads of duplication. This code is hard to understand because it is inconsistent and duplicative, and because it contains hidden concepts that it does not name.

Consistency

Duplication

Names

This next solution errs in a different direction. It does many things well but can&#;t resist indulging in unnecessary complexity. Have a look at the code below:

Listing Speculatively General

If you find this code less than clear, you&#;re not alone. It&#;s confusing enough to warrant an explanation, but because the explanation naturally reflects the code, it&#;s confusing in its own right. Don&#;t worry if the following paragraphs muddle things further. Their purpose is to help you appreciate the complexity rather than understand the details.

The code above first defines four anonymous functions (lines 1, 7, 13, and 19) and saves them as constants (, , , and ). Notice that each function takes argument but only actually refers to it. The code then defines the and methods. Next comes the method, which passes the current verse number to and sends to the result (line 37). This is the line of code that returns the correct string for a verse of the song.

Things get more interesting in , but before pondering that method, look ahead to the class on line instances are initialized with two arguments, and , and they respond to two messages, and . The method simply returns the verse number that was passed during construction. The method is more complicated; it calls, passing as an argument.

If you now return to and examine lines , you can see that when instances of are created, the argument is a verse number and the argument is one of the anonymous functions. The method gets invoked for every verse of the song, and therefore, one hundred instances of will be created, each containing a verse number and the function that corresponds to that number.

To summarize, sending to an instance of invokes , which uses the value of to select the correct anonymous function on which to create and return an instance of . The method then sends to the returned , which in turn calls the function, passing as an argument. This invokes the function, which may or may not actually use the argument that was passed. Regardless, executing the function returns a string that contains the lyrics for one verse of the song.

1. How many verse variants are there?
   There are four verse variants (they start on lines 1, 7, 13, and 19 above).

2. Which verses are most alike? In what way?
   Verses are most alike (as evidenced by the fact that all are produced by the variant).

3. Which verses are most different? In what way?
   Verses 0, 1 and 2 are clearly different from , although it&#;s not obvious in what way.

4. What is the rule to determine which verse should be sung next?
   Buried deep within the function is a hard-coded "99," which might cause one to infer that verse 99 follows verse 0.

This solution&#;s answers to the first three questions above are quite an improvement over those of Listing Incomprehensibly Concise. However, all is not perfect; it still does poorly on the value/cost questions:

1. How difficult was it to write?
   There&#;s far more code here than is needed to pass the tests. This unnecessary code took time to write.

2. How hard is it to understand?
   The many levels of indirection are confusing. Their existence implies necessity, but you could study this code for a long time without discerning why they are needed.

3. How expensive will it be to change?
   The mere fact that indirection exists suggests that it&#;s important. You may feel compelled to understand its purpose before making changes.

As you can see from these answers, this solution does a good job of exposing core concepts, but does a bad job of being worth its cost. This good job/bad job divide reflects a fundamental fissure in the code.

Aside from the and methods, the code does two basic things. First, it defines templates for each kind of verse (lines ), and second, it chooses the appropriate template for a specific verse number and renders that verse&#;s lyrics (lines ).

Notice that the verse templates contain all of the information needed to answer the domain questions. There are four templates, and therefore, there must be four verse variants. The template handles verses 3 through 99, so these verses are clearly most alike. Verses 0, 1, and 2 have their own special templates, so each must be unique. The four templates (if you ignore the fact that they&#;re stored in anonymous functions) are very straightforward, which makes answering the domain questions easy.

But it&#;s not the templates that are costly; it&#;s the code that chooses a template and renders the lyrics for a verse. This choosing/rendering code is overly complicated, and while complexity is not forbidden, it is required to pay its own way. In this case, complexity does not.

Instead of 1) defining a function to hold a template, 2) creating a new object to hold the function, and 3) invoking the function with as an argument, the code could merely have put each of the four templates into a method and then used the statement on lines to invoke the correct one. Neither the functions nor the class are needed, and the route between them is a series of pointless jumps through needless hoops.

Given the obvious superiority of this alternative implementation, how on earth did the "calling an anonymous function" variant come about? At this remove, it&#;s difficult to be certain of the motivation, but the code gives the impression that its author feared that the logic for selecting or invoking a template would someday need to change, and so added levels of indirection in a misguided attempt to protect against that day.

They did not succeed. Relative to the alternative, Listing Speculatively General is harder to understand without being easier to change. The additional complexity does not pay off. The author may have acted with the best of intentions, but somewhere along the way, their commitment to the plan overcame good sense.

Programmers love clever code. It&#;s like a neat card trick that uses sleight of hand and misdirection to make magic. Writing it, or suddenly understanding it, supplies a little burst of appreciative pleasure. However, this very pleasure distracts the eye and seduces the mind, and allows cleverness to worm its way into inappropriate places.

You must resist being clever for its own sake. If you are capable of conceiving and implementing a solution as complex as Listing Speculatively General, it is incumbent upon you to accept the harder task and write simpler code.

This solution valiantly attempts to name the concepts in the domain. Here&#;s the code:

Listing Concretely Abstract

1. ^Nyberg, Tim (). 99 Bottles of Beer on the Wall: The Complete Lyrics. Andrews McMeel Publishing. p.&#; ISBN&#;.
2. ^Baird, Kevin C. (). Ruby by example: concepts and code. No Starch Press. p.&#; ISBN&#;.
3. ^Cohen, Norm (). Folk Music: A Regional Exploration. Greenwood Press. p.&#; ISBN&#;.
4. ^Patton, Charlie (December 23, ). "Ever-annoying Andy Kaufman gets last laugh | cromwellpsi.com". Archived from the original on Retrieved 15 Sep
5. ^Stewart, Rich. "Rhythm and Booze: The Top 86 Drinking Songs". Modern Drunkard Magazine. Retrieved
6. ^Byrd, Donald (). "Infinite Bottles of Beer: Mathematical Concepts with Epsilon Pain, Or: A Cantorial Approach to Cantorian Arithmetic and Other Mathematical Melodies"(PDF). Indiana University, School of Informatics. Retrieved
7. ^Donald Byrd (). "Infinite Bottles of Beer: A cantorial approach to Cantorian arithmetic and other mathematical melodies". Math Horizons: 16–
8. ^Knuth, Donald. "The Complexity of Songs"(PDF). Retrieved
9. ^Team, 99 Bottles of Beer. "99 Bottles of Beer - Start". cromwellpsi.com.