Sometime in the past, a friend asked me: ‘Why do you program?’. I told her: ‘Cos I love to?’. Cliche. And then I grew, and the reason-stack grew, and the love-it response was pushed somewhere towards the top, belonging with other items like:

• I’m passionate about it.
• I wanna become a software developer.
• [scarcely-thought-out reason associated with adapting to global trends]

Traversing down to the middle of the stack, there were items like It’s Art and It’s mindblowing what you can do with just a computer, at the comfort of your home.

Hit Rock Bottom-

Code is Groovy. Not the dandy-groovy thing. It has these grooves, like a screw does. Like a screw, it fits in. Somewhere deep down in the cerebral chasms. Which is, in all likelihood, the same Modus Operandi of Music and Math. It’s almost like fitting these grooves into threaded holes in the brain. The brain functions on algorithms and patterns, and everything it coughs up is patterned in some way or the other. Nothing else can explain why most people sound their vehicle horns like ‘Beep Beeeep’, or rev up their engines with ‘Vroom Vroooom’. That’s a geometric progression of two elements with a common ratio of 2. Yet, it happens so subtly, unnoticed, everyday, everywhere, all the friggin’ time. It’s a daily street-dose of math, music, and it also gives us a code analogy. A codalogy, if I may.

#python-like
for i in [1,2]:
     honk(delay=i)
     sleep(ShortestDelayBetweenReleasingHornAndPressingAgain)

Pizza!

Another one of these commonplace applications of patterns and math is what enhances the droolworthiness of a pizza. The whole structure is progressively bisected to about 8 pieces. This is the mainstream way of cutting a pizza, and apart from giving equal pieces, it also makes the pizza look the most sexy. A different pattern, like closely placed vertical segments probably won’t look great. Here’s a codalogy for how most pizzas in the world are cut(again, a geometric progression with common ratio 1/2):

#python-like
for i in range(1,numberOfPieces):
     for each piece on the table:
          cutPieceInHalf()

There are an infinite other ways to split a pizza into equal parts, but this is probably the simplest, most structured, and beautiful way of cutting it, and that makes it mainstream. Also, note the reusability. The code above doesn’t just apply to a pizza. Map it to microcontroller language, write the function code, interface hardware, and you can have a cutter that emulates this pattern for just about any structure.

There are inherent grooves and patterns down below in the depths of the brain, which are mapped to the outer physical world. This mapping is spontaneous and natural. Go dance or headbang to a groovy beat, or find yourself unconsciously drumming with your fingers or nodding your head off to distant music, and the mapping becomes conspicuous. Code exploits these patterns and grooves. There’s no pattern you can’t reproduce in code. Which leads us to-

It’s very tempting to write a loo joke, so here goes a codalogy:

#python-like
while True:
      if(stomach.isEmpty()==True):
            feed()

#python-like
while True:
      if(bowels.soundShitAlarm()==True):
            dashToTheCrapper()

Let’s suppose the former loop were to fail due to some unknown reason or the conspiracy of the devil. We’d stuff ourselves and explode. And if the latter fails? Again, we’d stuff ourselves and explode. And the world would be a shitbath. And……………..!force stop.

Failure of a trivial-looking piece of code can spell worldly doom. Things at present are the way they are, because these cerebral loops work the way they do. (Ref. Godel Escher Bach)

This is no different from Assembly programming or, say, Arduino projects. Using the microcontroller to interface with hardware sounds like a perfect analogy to biological or cognitive processes. An example code for making a Piezo-Electric buzzer buzz out the automobile ‘Beep Beeeep’ might look this way:

int noteDurations[] = {
  durationOfTheFirstHonk,durationOfTheFirstHonk*2 };

void setup() {
  for (int thisNote = 0; thisNote < 2; thisNote++) {
    int noteDuration = 1000/noteDurations[thisNote];
    tone(somePin, frequencyOfVehicleHorn,noteDuration);
    delay(ShortestDelayBetweenReleasingHornAndPressingAgain);
    noTone(somePin);
  }
}

Code can mimic natural symmetry. Program separate hardware parts for a cumulative goal(a sense-response system which senses the surrounding environment for input of specific type, and a corresponding preset response), interface them through a microcontroller, join them all together in one body structure, and there's a Robot. The analogy is striking. Code is the universal analogy.

Like everything else, there are certain grooves that don't wedge into certain threads. Forcing the brain to faithfully construct an asymmetrical pattern can be a pain in the assbrain.

A small game that would show this would be - 'I'll ask you questions, and you keep answering to the previous question.' To complicate it further, the answers could be for questions 2 or 3 displaced from the present. Yeah Right. Give the brain a groove, and ask it to form an anti-groove of sorts. This is like walking in the opposite direction and increasing the distance to the goal. Here, of course, the brain stutters unless it chooses not to acknowledge the main pattern and instead, create the required pattern from memory, in a dedicated process.

Also, random number generation. Try going into a coughing-up-random-numbers-spree. You'll notice that a few adjacent numbers are innocently close, or desperately far away depending on the scale. The uneasiness of the brain to breach patterns is again obvious here.

Random number generation in computers isn't really random, in the true sense of the word. It either depends on a seemingly random external physical event(like, say, results of rolling a dice, or the measure of radioactive decay) or a pseudo-random number generator(pseudo - pretending to be). Here's the classic pseudo-random number generator from K&R:

unsigned long int next = 1;
/* rand: return pseudo-random integer on 0..32767 */
int rand(void)
{
next = next * 1103515245 + 12345;
return (unsigned int)(next/65536) % 32768;
}
/* srand: set seed for rand() */
void srand(unsigned int seed)
{
next = seed;
}

Here's xkcd's take.

The brain adheres to patterns that are fed to it. An artificial sense-response system, need not, necessarily. Like in an answering bot that keeps appending the present question to a linked list, and keeps answering the question from the penultimate node. Code can harness anti-grooves. It can go against the groove.

The universality of code makes it live on a world of its own. It can aid in mapping almost any system into any other system. That gives humans a lot of domains to work on. On a world of its own, some domains-

• Civil Engineering - Software construction, Web design, Application development, and an infinite other things.
• Artistry - Algorithmic music composition - like fractal music, algorithmic and representational art and an infinite other things.
• Science - Artificial Intelligence, Machine Learning, Neural Networks and an infinite other things.
• Electronics - Microcontrollers, Hardware design and an infinite other things.
• Finance - High-Frequency Trading algorithms, Stock predictors and an infinite other things.
• And an infinite other things.

Without code, most technology wouldn't exist. We breathe and live and bathe and eat on code. More importantly on a mainstream scale, we Facebook on code.

All this stuff about indiscernible and difficult music, it's all in the grooves. The more complex it is, the more time it takes to sink into the brainpits.

Here's a quite inaccessible but genius 70s Kraut groove:

[Link]

And a simpler Tamil Kuthu(translates to punch, but I call it orgasmic percussion). Note: Simple, awesome, trending groove viral on the interwebs as of the time of this post. No wonder it hit mainstream. Everyone just groov'd. Notice the people in the video mapping their cerebral grooves to headnods. Or maybe you're doing it yourself.

[Link]

Grooves and patterns are what make pleasant music pleasant, great artwork great, and a hot chick hot, even. And in all likelihood, AI has everything to do with grooves fitting into threads. An explosion of patterns and structure and symmetry. If in future a machine passes the Turing test, it would probably attribute to its skillful perception of grooves and patterns and structure. There are deeper mysteries down in the mind than in the universe. If humans ever find the Answer to Life, the Universe and Everything, it would be because of code. Nothing exploits these structures better than code. Simply because Code is the Analogy to Life, the Universe and Everything.

I wanted to dump more thoughts in, but, of course, time-constraints and insecurity always beat you. Hopefully I'll follow up on these in further blog posts.

Going back to the top of the reason-stack now, 'Why do you program?'. 'Cos I love to!'

Gotta love teh code, mahn.

/SignOff