Samik's Restless Rants

Code aging:Can a computer program age?

noreply@blogger.com (samik chakraborty) — Fri, 04 May 2012 05:26:00 +0000

Aging is a life phenomenon. A life always age from birth to the day it ends. A computer program also dies; we in software industry like to replace a piece of code with completely a new one. We do it by rewriting the software. Here is what happens for software:

Birth: We write the software with a purpose.

Growth: We find some bugs in the behavior of the software; we fix the bug. We do it again and again.

One fine day we feel the software is bulky to fix bugs or the purpose has grown to such an extent that we need to rewrite the software.

Death: We rewrite the software and replace the old one with the new.

How a code age? Here is how it happens (IMHO):

Software gets fat by added code all the time. We add code to fix bugs, to add feature etc.

Code becomes complex. As in life, with time, code also becomes complex by code complexity (like if –else –then). It so happens, that code becomes complex by overloaded methods, multiple entry points, more than one way to do one thing, etc. With time it becomes hard for the developer to understand the code.

The code can also age due to library it uses has aged and being replaced with newer one. Even the programming language may have morphed. Like in case of Java, concurrency, generics, etc. are making some code look old.

The other indicator of old code is its interfaces and deprecation. If an interface is filled with same methods with just parameter or return type mismatch (overloads), I suspect the code has aged.

That’s all that I can think. If you know any others please share.

You may also like: Why is it harder to read the code thanwriting it.

Why I Code or note to my first love?

noreply@blogger.com (samik chakraborty) — Wed, 25 Apr 2012 15:49:00 +0000

I am a programmer. I code every day. Why I code? Here is my answer.

Coding is an activity where I can write a program and computer will execute it. It started with very basic use of computer. I gave a command: date and it printed out the date. It was amazing. I was four years old and I started thinking how it came to know today’s date. Some years fast forward, I got into the computer lab of my school (no computer was not a subject for a 12 year old in my school, it was just luck that I was able to go inside my school computer lab), a senior was coding in Basic. I asked him what he is doing. He showed me what he was doing. I said to him can I do a simple multiplication? He said why not so I wrote (under his instruction) a program that multiplied two numbers. My first love started.

The feeling was something like a master and slave. I am your master and commander you follow my orders. This is my first understanding of coding. I understood that if I code it right it will do what I want it do. So computer gave me my first feeling of being master of something. I was not so popular among kids so I had time to play with school computer. It gave me opportunity to learn how to tell computers what to do. So then I coded so I can tell my pet what to do, and that was the reason I used to code that time.

Late in teenage, I realized that people around me were getting their friends. I mean someone special in their life. They used to spend a lot of time with them, talk to them. College was full of people who were dating. I was not even a cool guy in college. So I needed something to hold on. In our college lab we used get access to computers during college hours. So I started to show up in lab in the morning and screw all classes. I used to code. I used to code in C. I felt like I am at last in peace with the world. I felt like I am in conversation with computer. So now I started coding to communicate to the computer as a friend. A friend who will be with me, always. My first love.

Next I joined a company as a programmer. Where I saw and met a lot of programmers in the company. They are all amazing people. I started working on code. I came to know that you do not write code from scratch you take others’ code and maintain them. I used to see code comments with bug ids, I used to go to the bug tracker pull up those bug ids and saw the names of people who worked on them. The code was talking to me, some of them were so clear as if I have coded them. Some of them were a bit awkward, hard to understand. Then I realized that I was talking to them, in space time continuum I was there sitting with them in conversation with other programmers. I was debugging the code – also trying to map their mind for a sorting logic, searching technique or a trivial account money transfer between two currencies. In all this I understood that why it is a programming language. The value of code readability, the value of lambda calculi or Turing Machine, all of that I came together so that we programmers can talk a time apart. Computer became a paper, programming be the language. My first love metamorphosed to me again.

So why I code my love, is it because I love to code or is it I want to communicate to some unknown programmer in the future. I code because I love you. I want to remain with you and discover you in my old age that I have reached a position where I can say, I know why I loved you for so long. My guess you will guide me to my nirvana. I will rest then at peace.

Needed a better Twitter so we made one for ourself

noreply@blogger.com (samik chakraborty) — Tue, 27 Mar 2012 05:06:00 +0000

Yeah! We are out of our mind, or may be not. We felt a lot of things can be improved in twitter or micro-blogging for that matter. So what all things that we wanted to improve in a micro-blogging service:

Posting:

Give some more characters darn it. Have you ever felt like that you just need that extra 10,20 or so characters in your tweet. If so read on.

Why the hell I need to go to another service to shorten my URL. That's pretty basic. A micro-blogging site should do it automatically for you.

Following:

Why not follow my interests - in a wholesome way. So following people gives me a lot of sh*t. I have to wait for my meat. I will jump on to a conversation, if I find it interesting. One more thing about interest is it's not always people but tags. Some tags are interesting enough to follow and get a stream in.

Tagging:

This brings me to tagging. Tags are meta data not data. Please don't clutter my post with #FOO and #BAR. I should be able to add tags separately.

Can you help with suggesting some tags for a link. So we wanted an auto-tagging system, it need not to be perfect (as long as I can remove suggested tags which does not make sense), but give me something.

All this can be done. We need to do it for us. So we did it. If you are interested take a look at: ScoopSpot.

How we made a social news service with machine learning from scratch

noreply@blogger.com (samik chakraborty) — Sat, 24 Mar 2012 03:33:00 +0000

How do you get to news which interests you in Hacker News or TechCrunch or The Next Web or the ReadWriteWeb? I mean when you go to a news website do you read all articles or do you scan the article titles and try to guess which ones to read based on your interests?

In my case I have noticed that I am looking for the news which interests me. Like startup news, Java or Ruby programming language news. So it beg the question can I build a system which scans through all the news and then classifies, indexes all relevant terms and serve to me so that I can get a stream of news which I would like to know and read about.

So we(my friend and I) started building a system which when given a website link does the following:

It tries to get the relevant content from the page.

It uses natural language processing to understand a bunch of things like: sentences, parts of speech etc. We score the word relevance in the article.

We also do classification and clustering with bunch of statistical methods of the article to find out which category an article belongs to. Like is it a technical or scientific or law related article.

Once we got the meat of the document we tag it with the terms that we have identified with the above steps.Now we were faced with the challenge that how can we make it available to us. We needed a web site which will allow us to see the content in stream. We should also be able to customize the stream to user’s choice. So we thought of creating a micro-blogging site, after all, we just needed to put a post with article title, URL and the tags. Here is how a post looks today in the stream.

If you would like to see a full stream:

As you can see here that I am seeing news with startup and java. As I am following news related to java and startup.

We noticed that we need more character support than 140 character of Twitter so we increased the character limit to 300. One more choice that we have made is adding tag separately from the actual post. This allowed us to add as many tags as we want. We feel tags are more like meta information so one should not be limited with hash tags.

Once we have such a system, we needed a way to get the latest news from Hacker News, TechCrunch, TheNextWeb etc. RSS feed came to our rescue. These websites provides RSS feed which we read periodically. We created an account called news in ScoopSpot which will do the posting in our micro-blogging site. If you would like to see news in action, visit: http://news.scoopspot.com/.

So now if a user comes to our web site and post something with an article link we are now able to auto tag it.

Here are some links to tag based pages:

Ruby: http://www.scoopspot.com/Ruby

Startup: http://www.scoopspot.com/Startups

Steve Jobs: http://www.scoopspot.com/Steve_Jobs

If you are interested to try it out you can visit: www.scoopspot.com

Ten Commandments for How Not to Become a Good Programmer

noreply@blogger.com (samik chakraborty) — Thu, 23 Feb 2012 07:05:00 +0000

thy should never waste time in reading about code
thy should always respect your IDE and carry it all the time with you (in a USB key)
thy should always find a non-existing requirement in mind and code for it
thy should never write a comment
thy should show your karate in all obfuscating syntax
thy should show no interest in algorithm and its implications
thy should always be shy away from mathematics
thy should never test your code extensively; those who do are weak
thy should write in abbreviation it will communicate more in less characters
thy should use GOTO always

That's all I have.

Want to know better micro-blogging platform read on

REST will stay – you can wash your SOAP away

noreply@blogger.com (samik chakraborty) — Fri, 17 Feb 2012 06:36:00 +0000

REST web services will stay. It is a bad thing to predict future of technology. But I am ready to bet on this one. REST will stay. It will stay because of multiple reasons, and today I am going to give you mine.

REST is simple. You can create a RESTful web service easily. I mean very, very easily. Actually you have been doing it all along if you are in web development. Every page in a web site is an example of REST web services (hold your concern a bit more), the only difference is your client is a web browser.
REST is succinct. You can do almost everything in REST. If you cannot do something in REST chances are you do not know how to do it yet. It’s succinctness is so powerful that you can do some great magic.
REST is easy to learn. If you know web development you know rest. If you need to expose your database to the web – you just need to provide a URL (with all query string and HTTP headers). Whatever is running in the background for your web server (or app server) can return the data using JSON or XML. That’s it.
REST is scalable. If the dang thing supported the Internet to scale to what it is today – it can scale your web site also. Even if you have more data than Wikipedia.
REST teaches you a lot more than anything else. With other web service standards – you are limited with the framework you are working with. But not with REST. It does not impose you anything – no configuration, no heavy tricks, no non-sense. Follow the conventions and you are there with your service. As it does not have any heavy stuff so it push you to think in simple terms and help you build a system which easy to maintain and consume.
REST service is ready to be consumed anywhere. I mean as long as your server is reachable. So you need no fancy pant client library to work with.
REST will stay – you can wash your SOAP away. If you are not with REST of us and with some other stuff. Think about the future where everyone will have a handheld try to access your service. They will have different architecture and software stack which you do not know. You will have to serve data to all of them and your SOAP will wash away.

That’s all I had in my mind. What do you think?

Lets Un-Uncomplicate

noreply@blogger.com (samik chakraborty) — Tue, 17 May 2011 07:18:00 +0000

The world is a beautiful place if you can see things simply. But once you are in the software it becomes ugly and you start seeing things in a completely different way. I have seen thing happening so may times – that I felt like writing this one out.

Its story time here – so enjoy!

The “Hello! World”

You must have written a “hello world” program in your life. It’s the simplest program that you can write in a programming language . So I will tell you a story with “Hello! World”.

In a software company, “ComplicateSoft” (henceforth called as “CS” – for simplification!), there was a requirement from a customer to write a program which will print “Hello! World”. But as with any customer, there is a catch – they did not know where will it be getting printed or how many times will it be getting printed. So they said the “Archie” of “CS” make something generic. Actually the customer said “make something which will do the job in most cases”, the “Archie” documented it as “generic”.

The Dev-Archie meet

“We will do it the proper way”, said Archie.

Dev guy, “Yeah, makes sense – cool.”

So the dev guy wrote a good old Java class, which has a simple method which prints “Hello! World”.

Dev was happy as he never got a easier project than this. So he even wrote it in TDD.

Archie came along and saw that piece of code and said, “Okay, but that’s not generic enough. Dude, make the string “Hello! World” externalized”.

So the dev guy, did.

Next, Archie said, “Dude we do not know where this will get printed no sys-out. Take a output stream instead!”

Well this should be all. The dev guy did that.

Next, Archie said, “This class is doesn’t have any state so lets make it a Singleton.”

The dev guy thought wow! I will implement a design pattern now on this – cool.

The Archie said, “Now we have to make sure that if someone request this as service over the web, do a WSDL for it and test it with a client.”

Dev guy did that!!!

Now Archie thought about the requirement once more and remembered the phrase, “don’t know how many times will it get printed.”

If it needs to printed multiple times with a distributed file system?

He asked his dev guy a final thing – “Can you make this class support Hadoop map-reduce”

The dev guy ….

The end.

Hope you enjoyed.

Why is it harder to read the code than writing it?

noreply@blogger.com (samik chakraborty) — Tue, 01 Mar 2011 07:52:00 +0000

It is harder to read a code than to write it.

In a meeting where a team is deciding whether to write the code a fresh, this is the reason given in favor of writing it all over again. With this reason we sometimes add seasonings like: we will design it better, we will write in TDD, blah, blah and blah.

But if you think very closely you will come to know why you are re-writing the code. If you are re-writing a code from language X to Y. There must be some very good reason behind it. Like if you have a old C code which you want to re-write in Java your list of reason could be: portability, multi threading, OOPs design, security etc.

But if you have decided to re-write the entire code in the same language you are doing so because:
It is harder to read a code than to write it.

Now stop think about the part:

It is harder to read a code

Why is it harder to read the code?

Answer the following questions:

1. Is there a high level documentation to follow the code flow?

2. If I put a break point in main (for C/C++/Java – you can think of the name of the entry point method in your project. In a web development you can think of a Servlet also.) can I follow it?

3. Are all the “if statements” (even assert statements for debug) is well commented?

4. Can I test all the methods for their side effects and returned values?

5. Can I look at the output of the program and get to know which paths are involved to produce any part of the output?

If your answers are mostly “No”. You need re-organization of your code – not a full blown re-write. That re-organization can be: adding comments to full refactoring of the code. But here I will tell you a little bit more about each point that I have mentioned above.

• High level program flow is very crucial for understanding of the software. A full-blown call graph tree is perfect. But at least all programmers in a project should be able to draw the high level program flow easily. Now let me tell you that this high level is not a one block with input to output. It has to be at least describes all the major boxes in the system. It should show the interaction with various modules, including internal and third party modules used.

• One should be able to go though the whole system effortlessly when she has put a break point at the beginning. Now if you have multiple entry point (one for one feature), one should not look out for an entry point for particular feature more than one documentation file. If you do not have it – do it now.

• The branching statements in a code are very important. This is the place where business logic is implemented. So they must be documented – and the documentation is in the code as comments. You do not want your programmer to look for the spec while debugging any feature. Any changes to the business requirement should be tracked in the code comment. If any of the method is going to change the state of some variables or objects which impacts the overall behavior you should document that also, again in the code comment.

• Nothing is like a unit testing but that is less for automation and more for human understanding. Any developer in the team should know where the unit test case resides for the method that he is working on. A new developer should start by doing the unit tests first. Sometimes in old code we do not have unit test cases for historic reasons. If that has state changes going around we should provide the developer a way to understand the state and state changes.

• This one is important! Look at your output and tell me which code or code path is responsible for this output. Like if you are showing a count of students in a class you should be able to trace that front end to the back end code till the DB.

If you do all that you should be in a good position to understand the code and work with it rather than dispose it off. If you anyway decide to follow the re-write make sure the documentation points that I have mentioned here. Do the docs for this re-write else you will drop this code some day with the reason:

It is harder to read a code than to write it.

10 Things to Keep in Mind while depeloping a Web App

noreply@blogger.com (samik chakraborty) — Fri, 18 Feb 2011 06:22:00 +0000

What should I ensure before I start developing a web application? So here is my humble list of things that I must do (don’t) in the future:

1. There is a need for authentication so figure that out first. Use a well know library for it – like if you are using Java use Spring Security.

2. Do not write your backend first. Especially for Ajax based web apps. You will need to add or change the API with the page design changes.

3. Do not return HTML from any Ajax API ever. Use JSON. [If you do this with # 2 you are doomed]

4. In your HTML, JSP (or ASP) or XSLT - do not write the style attribute (in HTML tags) to save time today. Instead add a class in your style.css file. It will save a lot of time in the future. Like if you want to change the color of the whole page you can work with one css file instead of all your ASPs and JSPs.

5. Have one entry point for all services – use a dispatcher. What I mean by this is make your web app configuration lean (for Java world it is web.xml).

6. Keep the logged in user in a secured URL like HTTPS. Never transport password over HTTP.

7. Try to standardize the JSON response. If you need to render something from JSON data this will help you a lot. You can write one helper JS function which will take care of it.

8. Follow css box model always. No excuse.

9. Divide the web page into multiple parts. Each part should be working fine. I mean as much as possible.

10. Build a feature a close it for today’s requirement. Do not jump to a feature without finishing the one in hand – it will bite your ass later.

10 + 1. Test in a lot of browsers (IE7+, FF, Opera, Chrome)

Reading Cricekt - A Fun full Learning

noreply@blogger.com (samik chakraborty) — Mon, 28 Jun 2010 12:34:00 +0000

Cricket is a game where you play either as a batting side or as a fielding side. Players from batting side try to score runs and the fielding side tries to stop the batsmen by getting them out. It sounds pretty similar to many games that are played worldwide, like baseball. But I am not going to blog about a game that’s played out door. I am blogging about an indoor game that I learnt during my school days. It is an amazing game where cricket is mixed with reading habit. It’s called Reading Cricket – conceptualized and invented by our Bengali language teacher Mr. Tejesh Adhikari.

This game is very simple to play – especially in a class room situation. So how is it played?

The “Rules”

There will be two teams of course. One will bat the other will bowl. But instead of bat and ball they will have the same book. Like the history book that is used by all students in the classroom. The team which is batting will be reading from the book. One of the team members will be reading the book aloud so that the other team can listen. The fun begins now.

1. If the batsman (the guy who is reading the book) can complete a line (note – a line not a sentence) will be awarded 1 run.

2. If the line contains just one word which is foreign and is not part of the normal vocabulary of the original language of the book, or is written in a different language alphabet. If the batsman reads that line with proper pronunciation, he will score 2 runs for that line.

3. Consider the point# 2 for multiple words but not the whole line. In this case the batsman will score 4 runs.

4. Now consider if the whole line is written in the foreign language – the bats man get 6 runs.

5. Now for all 2,3 and 4 the batsman should know beforehand and he can declare that he does not know the language. No one can penalize him for that.

6. So what the fielding team is going to do? They will listen carefully each word of the batsman. If any of the fielders finds that the batsman has mispronounced any one of the word according to the convention learned by the students in the school – he can appeal for an out. If the teacher thinks that the appeal is correct he gets out.

There were so many other things in it. But the above mentioned are the gist of what I can recall.

What an effect that it used to have when we used to do it in the school. The guys who never gave attention to anything used to glue to the pages and follow the batsman when they used to field. It is an amazing way to learn how to read, understand and possibly remember.

Like the best bridge players – who never forget a mistake that he has made in a deal or like a chess player who always remember the blunder that he had made, we used to remember our mistakes while reading.

I just thought this game might help a lot of people who works with young learners, who are dedicated to bring out the best in our young – if they know about it, they can try it.

If you try it please let me through your comments. If you want to know more about it – please ask me any question.

Come Back!!!

noreply@blogger.com (samik chakraborty) — Thu, 25 Mar 2010 06:36:00 +0000

“We're getting close to the end of my blog. After today's entry, I only have three left to write. After that, I'll only blog anonymously or (more likely) not at all.” – Steve Yegge

“programming is rather thankless. you see your works become replaced by superior works in a year. unable to run at all in a few more.” - _why

So people do like to disappear from the web world. I really do not know why a person like Steve wants to stop blogging; _Why likes to stop contributing to the programming language he loved.

We all need time to do things that we must, should and have to do. I must spend quality time with my family; I should spend an hour or two with Concrete Mathematics; I have to keep my day job (hey I love my day job – please don’t take it in the other sense.) so that I can pay the bills.

But it seems strange that one day one may decide to go in the clouds and never come back. If someone really does that, whom should we blame? Why some people really wanted to know the so called “real” person behind _Why? Some people think that’s may be the reason for the drastic step that _Why took. If you do not agree with what someone has to say about something (like Marijuana) – why do we always have to hit that guy?

Yeah! We are intelligent beings – and have big fat ego like – I know this stuff better than you and I can show how great I am in…. but hey dude. You are just good at criticizing and nothing else. You know pointless criticism is pointless! FLAT POINTLESS – don’t do it!

I do not know why the hell these guys disappeared. But I want them to come back. But why should you come back? These thankless people will never stop. They will always come back and hound you guys. I am just thinking about people who really go inspiration from you guys. An email, blog post or code snippet can clarify an air of uncertainty in our mind. For ruthless, restless and may be “I know all” types all you have to do is “ignore” them. They will always be there as their existence depends on it. They will not practice agile for 2 years and come back and say “Hey Steve, you missed out these (or that point) in why Agile suck.”

You know I am may be just ranting for no reason at all. I know this will not change your mind sets. Just one request to you guys. Do not punish all for a few!

Caveat - The Name has Changed

noreply@blogger.com (samik chakraborty) — Wed, 27 Jan 2010 07:22:00 +0000

After almost three years of blogging, I am changing the title and subtitle of my blog. It will no longer be called as lisp any more. Why? Of late I was not writing enough about (or on) lisp. It is more and more becoming my restless rants that I do out of desperate need to fulfill my alter-ego of creativity. I gave it a long thought and paused for several minutes before I changed it. I was thinking that some people who read this blog may feel that it has changed from what it was previously. Do not worry – it is impossible to change an opinion, let alone a personality.

My obligation was not only to my reader but also to the people who lands on my blog. They shouldn’t be misguided to a belief that it is a blog purely for Lisp. Hope this will clear some clouds – hope you will enjoy it as before.

Oh I almost forgot to mention! I will definitely write about lisp and lisp related articles in the future.

Loooopy

noreply@blogger.com (samik chakraborty) — Wed, 20 Jan 2010 05:21:00 +0000

How Tortoise Taught Recursion to Achilles

This post was there with me for quite some time - but couldn't complete it for almost six months. At last its done! Hope you will enjoy it.

One should read the dialog in Lewis Carroll writing or Godel, Escher, Bach.
Here is the dialog that I have referred to from Wikipedia.

[Achilles and Tortoise meet at a coffee shop after a long break.]

Achilles: It has been long that we have met.

Tortoise: Yeah! But the good thing is that, here we are together; once again. So what have you been doing all these days?

Achilles: Nothing!

Tortoise: So it must have been boring for you.

Achilles: Oh no, no! It was not boring at all. I have learnt programming of late and I was playing with couple of programming languages. Like I was figuring out how I can model all that we have discussed previously. Especially the one that you and I got into endless thousand page ranting on with A, B, C … to prove Z. You remember?

Tortoise: Yes, I do in fact! That was a fun! I hope you understand that it is very difficult to prove that uh!

Achilles: You should learn programming and you will come to know that what you did was an infinite loop. You would have understood the loop will go on and on.

Tortoise: Loop?

Achilles: Yes my dear friend – loop.

Tortoise: So what is this “Loop” is all about?

[Achilles smiles and continues, after a sip of cappuccino]

Achilles: You see loops are very simple. If you want to do something repeatedly you just say that.

Tortoise: Elaborate please.

Achilles: Like say you want to add all the integers from 1 to 10. You start a loop, let x equals to 1 and sum equals 0. Add sum and x and assign the result to sum, after that you increase x by 1 and do this till x is less than 11; you see you want to add all integers till 10. Pretty simple, huh?


Code snippet:
  int sum = 0;
  for (int x = 0; x < 11 ; x++) {
   sum += x;
  }

Tortoise: Fine! But looks odd to me!

Achilles: Why? Is there anything wrong?

Tortoise: You know my friend; you have learnt a programming language but I am a little handicapped with that, i.e. “programming language”, but I feel I have a different way of understanding this one.

Achilles: How?

Tortoise: Do you know the mathematical concept of function? Like F(x, y) = x + y?

Achilles: Yes I do.

Tortoise: Great! We can represent the solution like the following function in mathematics:


       F(x, y) = y + x; if x = 10   … (RULE 1)
         = F(x+1, y+x); 1 <= x <= 9  … (RULE 2)

O mighty Achilles! How will you write this in your programming language?

Achilles: I see! Let me tell you how to do that in programming language. [Achilles shows the code snippet]


 public int sum(int x,int y) {
  if (x == 10) {
   return y+x;
  } else {
   return sum(x+1,y+x);
  }
 }

Achilles: I knew this from my advance classes in programming – it is called recursion. But how do you explain this.

Tortoise: Very simple my friend! The RULE 1 says that if the variable x is equal to 10 you are going to produce the summation of x and sum as result else it will keep on calling itself with an incremented value of x and summation of x and the y variables. It’s very basic math you see.

Achilles: But you need to have a termination rule to complete the task! How would you explain that A, B and Z proposition problem with recursion? It was an endless loop right? No terminating condition.

Tortoise: Really? But I knew that there was a terminating condition there too! It was your last proposition. If I would have accepted it – the so called loop was over. But I did not accept it I just kept on adding one more layer in between the final and penultimate statement. So the final statement was the terminating condition.

Achilles: But as you see now, in this example we have a terminating condition as 10…

Tortoise: That need not to be 10, we can introduce a third variable say z or we can call it terminator if you like it. We can rewrite the function definition as follows:


       F(x, y, z) = y + x; if x = z   … (RULE 1)
            = F(x+1, y+x, z); 1 <= x <= 9  … (RULE 2)

And this one should work for any integer value of z – isn’t it?

Achilles: Yes it would and the program would look like:


 public int sum(int x, int y, int z) {
  if (x == z) {
   return y+x;
  } else {
   return sum(x+1, y+x, z);
  }
 }

And we could invoke this with something like: sum(1, 0, 10) and it works. But, tortoise, it is still does not create an infinite loop like what you had created.

Tortoise: Yes, Achilles it can but needs a little imagination. I created something like this:


       F(x, y, z) = y + x; if x = z   … (RULE 1)
            = F(x+1, y+x, x+2); 1 <= x <= 9 … (RULE 2)

Look closely, warrior; I have introduced a never reaching fallacy in the RULE 2 function. Instead of z I am passing x+2 as the last argument. This will prevent the condition for RULE 1 and it will remain like that illusive last statement.

[Tortoise paused for a moment]

Tortoise: Now you see it!

Achilles: Yes.

Tortoise: I am going home – would you like to join?

Achilles: No!

[Tortoise leaves slowly. Achilles looks at the paper and nods his head in disbelieve.]

Achilles: Waiter! Get me a java green please.

The java code for this never ending recursion would look like:


public class Recursionist {

 /**
  * @param args
  */
 public static void main(String[] args) {
  Recursionist r = new Recursionist();
  System.out.println(r.sum(1,0,100));
 }

 public int sum(int x,int sum,int termination) {
  if (x == termination) {
   return sum+x;
  } else {
   return sum(x+1,sum+x,x+2);
  }
 }
}

OUTPUT: A stack overflow exception - at some point of time I gusse.

Moreover you do not do all these for Arithmetic Progression you just use the formula.

Weekend Programming Excursion - 1

noreply@blogger.com (samik chakraborty) — Sun, 17 Jan 2010 06:53:00 +0000

So I have joined a new company on 30th December 2009. I am now working for Thomson-Reuters. As always the blog that I write here will not represent in any manner what so ever my new employer’s views, these are just my technological rants that I always write. I do not even know whether these are read or not, but just in case you are among those people who surf around and read this blog (either occasionally or regularly) be assured that I will eventually write something in here.

So, gosh what new year it was – leaving one company and joining another, I didn’t even got a chance to work on anything (other than all the pending items that I had on my plate with my previous employer, writing a good-bye mail, meeting people who wanted to wish me luck for my new venture and of course the team send off dinner) significant to write. It was all work and no play with my laptop.

As some of you may have noticed in this blogs that Lisp is not the programming language that I am working now. I am no longer in those fortunate few who get paid for learning Lisp, working with Lisp and writing Lisp codes. But that said nobody stopped me from learning a new programming language – but as you can guess from my worthless rants that I have not even scratched the surface of it.

On a boring weekend you usually start the day with your home stuff like laundry. However, if you are a programmer who cannot live without coding something or the other in a day, you also code. That kind of coding I call a “weekend excursion into programming”. Most of the times one tends to lose all the code that you have built over the time. This is especially true for me. So before I forget what I did I would like to put it in here.

So what was that I did?

A class and an interface in Java! Yes you heard it correct just a class and an interface - an interface with one method signature and a class with one method (as of now). That’s it!

You must be wondering what the heck! 1 interface, 1 class and 1 method for each of them!

You may tell me, “Dude! You are not working hard.”

Point taken! No more blah, blah….

So here it is what I did.

The One Interface

I bad at naming but I knew that the word “lambda” has to be there for this interface name. So in the kingdom of noun (i.e. Java) I have to use adjective for interfaces so the name of the interface is LambdaService.

So what is there in this interface? Here is the code for you:


import java.util.List;
public interface LambdaService {

 T lambda(List params );
}

Pretty simple, huh! It takes a list of arguments of type T and returns an object of type T. If you are from some functional programming background, you already know this stuff. But for people who do not know how I am going to use it – hold on, you are in for a ride.

The One Class

Let me give you the class definition code also.


import java.util.ArrayList;
import java.util.List;

/**
 * @author samikc
 *
 */
public class Functional {

 public static   List map(LambdaService lambda,
           List... list) {
  List retList = new ArrayList(); 
  List params = new ArrayList();
  int iterCount = getShortestListSize(list);
  for (int i = 0;i < iterCount;i++) {
    int paramCounter = 0;
    for (List l : list) {
      params.add(paramCounter, l.get(i));
      paramCounter++;
    }
    retList.add((T) lambda.lambda(params));
  }
  return retList;
 }

 private static  int 
                getShortestListSize(List... list) {
  List retList = list[0];
  for (List l : list) {
    if (l.size() < retList.size()) {
      retList = l;
    }
  }
  return retList.size();
 }

}

So what this method map is doing here. Let me try to explain.

In map you provide a lambda service (which is a method at the end of the day) and a list. The lambda service is nothing but a strategy pattern, I am allowing others to provide an option to provide an algorithm which will be applied to each member of the list provided and result will be collated in a different list.
Notice that I have made “different list” bold. Why? As I am applying the algorithm provided I am not changing the anything inside the actual list passed on. So it does not have a side-effect.

The main is given below without any comments; I feel it’s very simple and intuitive.

The *main* Story


import java.util.ArrayList;
import java.util.List;

public class Main {
  public static void main(String[] args) {
        ArrayList il1 = new ArrayList();
        il1.add(10);
 il1.add(20);
 il1.add(30);
 ArrayList il2 = new ArrayList();
 il2.add(10);
 il2.add(20);
 il2.add(30);
 il2.add(40);
 List li = Functional.map(new LambdaService() {
  @Override
  public Integer lambda(List params) {
    Integer i1 = params.get(0);
    Integer i2 = params.get(1);
    Integer ret = i1 + i2;
    return ret;
  }
 }, il1, il2);
  
 for (Object o : li) {
  System.out.println(o);
 }
    }
}

Sample output:
20
40
60

Last Day at Wipro

noreply@blogger.com (samik chakraborty) — Tue, 29 Dec 2009 17:22:00 +0000

After working for almost four and half years I have left Wipro. Tomorrow I will join a new organization (will let you the name tomorrow).

Great learning experience in Wipro.

JSON – Traps and How to Avoid Them

noreply@blogger.com (samik chakraborty) — Wed, 03 Jun 2009 05:57:00 +0000

Disclaimer: This post is suggestive but not complete

When you are working with JSON there are plenty of chances that things may go wrong. We all know that when something can go wrong it will go wrong. JSON never mentions the data type or it does not get validated by existing JS engines that run on the browser – so the onus lies on the developer to make sure that the data that she has received is in correct format and if possible the value is correct.

Any one can think about whole bunch of defensive programming techniques to avoid such a scenario. But it is impossible to guess what all things can go wrong so we should be prepared as much as possible.

Never evaluate a JSON. It is as bad as it can be. Don’t do it. You do not what you have received in the JSON. If it is a malicious code it can do havoc on your DOM and JS environment. It can corrupt your JS name space, steal cookie information or even worse user information. I know you must be thinking that we have to do it time and again, use json2.js library for this purpose – please do not repeat yourself with all the JSON string parsing again.

JSON data access is where your code will break (I mean eventually). Say you have a JSON structure (produced by the server) like this one:


{ name :  {  first : “Joe”, middle : ”Moe” ,  last :  “Doe” },  age :  23 }

Now you wrote the logic like this:


var name = json.name.first + “ “+ json.name.middle +”  “+ json.name.last;

This look pretty straight forward and you are sure nothing can go wrong with this simple code. But your server works with this logic: If there is a middle name then it adds middle name if it is not there it keeps mum about that. So the JSON comes like this:


{ name :  {  first : “Joe” ,  last :  “Doe” },  age :  23 }

Your code now will not work as expected, the reason being the absence of name.middle object. This is undefined.

So how do you make sure that it works as expected? Here is how:


var name = “unknown”;
If (json.name.first & json.name.middle & json.name.last) {
name = json.name.first + “ “+ json.name.middle +”  “+ json.name.last;
}

This is more important when it comes to calling some methods on a JavaScript object. If the object does not exist (i.e., undefined) then it will throw an error and your rest of the script won’t run. So if you are working with some JSON and you expect some kind of an object check the type of the object before invoking the method on it. Like if you want to split some CSV (comma separated value) string check that the object is of string type.


if (csvObject instanceof String) {
// Do your stuff here for string
}

Building Shindig 101

noreply@blogger.com (samik chakraborty) — Mon, 01 Dec 2008 13:25:00 +0000

"Proxy" problem:

While most of the world in enjoying the freedom of non-proxy Internet some people (like me) are behind a proxy server. Whatever, to get Maven working behind a proxy you need to go to your Maven installation folder and edit the file settings.xml in conf folder. What do you put in there?


<settings>
.
<proxies>
 <proxy>
    <active>true</active>
    <protocol>http</protocol>
    <host>proxy.somewhere.com</host>
    <port>8080</port>
    <username>proxyuser</username>
    <password>somepassword</password>
    <nonProxyHosts>proxyhost.somewhere.com</nonProxyHosts>
  </proxy>
</proxies>
.
</settings>

Building Shindig - The canonical way:

Building shindig (I assume that you know how to get the code using Subversion) the canonical way is simple:


cd ~/src/shindig/
mvn

This should be enough for most of you but if you are unlucky like me. You may get variety of errors:

1. Too many unapproved licenses: 12

Some people get a different number (even 0 - see this mail trail: http://www.mail-archive.com/shindig-dev@incubator.apache.org/msg07718.html)

2. Test failure :

May be one of the most frustrating thing is the test failures. They are hard to find and resolve sometimes.

So the question is; what are the options that you can try while building Shindig (and if *something* goes wrong - the list is in no particular order):

1. Delete your .m2/repository folder and retry - This will download all the required jar files once more. If you have missed something in the previous go you may get it (due to downtime to some download location). This is important if you get "Missing Artifacts" kind of an error.

2. Try : mvn clean install [ This cleans old bad builds and gives you kind of a fresh start]

3. Checkout or update the code from the Shindig repo once more.

4. Update the code once more if the build fails badly as this can happen due to unintentional commit mishaps.

5. If only the test fails and you are not patient enough to debug, use the following to suppress the error:


 mvn -Dmaven.test.failure.ignore=true

6. If you are too brave you can even try:


 mvn -Dmaven.test.failure.ignore=true -fn

[This worked for me when I got *too many unapproved licenses : 12*]

all the failures are suppressed by this -fn it will *NEVER* fail the build.

So that's about it while building Shindig. Hope this helps - if you have any other way of doing this let me know.

Code and Data Equivalence

noreply@blogger.com (samik chakraborty) — Sat, 15 Nov 2008 09:55:00 +0000

That code and data are equivalent is a common idea in common lisp. However any programmer who has started his programming in any language other than lisp may find this idea alien to him. This happened to me, and it took me some time to understand the concept. This post is all about my understanding about “code data equivalence” in lisp.

First of all what is code? Code is anything that can be executed in a computer. In other words code is what we write in a programming language. Code is as the text books suggest is a human readable representation of what computers going to execute. Like the famous hello world program that all of us has written at some point of our life.

Data on the other hand is something which will be processed by the code. So the code will execute on a data and data change from one execution cycle to another. Data can be given to a code from various sources, like input from a user, file or even a program or code. So in our mind there is a difference. For example take the example of a function which will add two numbers passed to it.

int add(int a, int b)

{

return a+b;

}

In mathematics we know that the operation summation will do *something* with two (or more) numbers and will return a result. This result also will be a number. So the operation of addition is important than that of the data that it operates on. This creates a difference of treating data and code. This difference is the underpinning of treating data and code as separate entities which is true for most of the programming languages.

But in case of lisp this is not true.

In lisp anything that comes to the REPL is s-expression. What is s-expression? Sexp or s-expression is defined in lisp as an atom or list. Atoms are number, string, character etc. So when a input or data come to REPL it evaluates that as any one these alternatives.

The code that we write in lisp is also s-expression. Now as in mathematics we know that:

If A = B and C = B so A = C.

For lisp:

CODE = SEXP and DATA = SEXP so CODE = DATA

QED.

Why lisp is Unpopular

noreply@blogger.com (samik chakraborty) — Wed, 18 Jun 2008 11:56:00 +0000

Lisp is a great programming language which has lot of power; however it is far from being most popular programming language. If you see lisp from a distance you will find:

1. Orthogonal syntax

2. Very quick to learn the basics

3. Very power full when it is used in high level project

4. You write less code as it has most powerful macro system

But still lisp is not the language of choice. It is a fallacy of programming world. Why? This question has stumped me number of times.

This post is my attempt to understand why it is so.

Prefix notation

Lisp is a programming language where prefix notations are used extensively. Prefix notations are good for computer but not for human being. From very old age human civilization and its mathematics is built on top of infix notation. We comprehend mathematical expressions in infix. You can argue with educational system but you cannot ask to change the year old mathematical notation to help a programming language to be understandable. That is simply not possible. This seems to me a perfect road block for lisp and it has to survive with that.

It will not be out of the turn to tell you a story about my friend. She was looking at Practical Common Lisp, and told, “How do you write 4*3+6 in common lisp?”

I replied (in writing), “(+ (* 4 3) 6)”.

She looked at it and closed the browser which was rendering “Practical Common Lisp”.

Mathematics behind lisp

Believe it or not all programmers do not like mathematics. They lie in the pantry, in conferences, in blogs. But the truth is a handful among us really like mathematics and care about it. Moreover it is not necessary to have deep understanding of mathematics to develop programs, or to be a programmer for that matter.

But lisp is an exception to this idea. To have a fair idea about lisp you have to understand some mathematics, like higher order functions. To understand functional programming paradigm one have to devote some weeks to lambda calculus. If one does not understand this he can write programs in lisp but it will be distant from the lisp style. The very idea of Turing machine and lambda calculus is fundamental to computer science but at the real world of software development those ideas do not cross our mind. To be honest with everyone I learnt C programming language without any knowledge of both Turing machine or lambda calculus.

There are self educated programmers who are very good in their trade and they care a damn about those theoretical computer science topics.

So lisp (and proper lisp style) is beyond many programmers and the target audience is less.

Programming language politics

Politics is pervasive; programming languages are not an exception to it. Big corporation look for development environments which are well supported, backward compatible, developers are available, etc. This is true in all large organizations or profit making corporations. When you decide about writing software you try to find out a middle ground. Lisp is powerful, 100 java average programmers = 10 or 2 great lisp hackers, you write less code to get more out programming language – all of them so very true. But when I was asked, “Show me one problem that I cannot solve with Java/Ruby/C++/Python?” I knew as all of them are Turing complete, so there is no problem that cannot be solved by Java/Ruby/C++/Python.

Although you have to learn more lexical separator in those programming languages than lisp still lisp looses. This is *PLP* - Programming Language Politics, we have to live with it. People will reject our ideas of development in lisp and the reason will never be purely technical; rather techno-political.

Code – data Equivalence – Hard to understand

I said, “In lisp code is data and data is code”.

Ron said,”What?”

People do not understand code data equivalence, because they are tuned by other programming languages. Those programming languages are their bread and butter so the immortal suggestion of “Unlearn “is “Unreal”. This is the bottom line of any lisper. This is *THE BASIS* of lisp macros. And it is so away from all other brick-mortar programming languages that no one understands its power without coding for many months and many macros. I got the feel of the matter when I read first ten chapters of Paul Graham’s “On Lisp”. This adds to another stiff cliff in any newbie’s learning curve.

Macros

Lisp macros are different beast, a beast when under you command do wonderful job for you. As any other programmer, especially *I know all* programmer like me, need some time to understand that lisp macros are really different.

It took me couple of week to realize that, when I realized it I felt like a stupid school kid with all red score card who has been slapped by his father for his exceptional result. Then I understood,”Oh! Yeah lisp macros are different.”

It opened my mind about programming as whole. Like when I learnt lisp – I learnt map, list, mapcar and all other cool lisp techniques. Before my lisp journey I was struggling with C++ STL concepts, after I learnt lisp all the things fell into place.

But the point here is that lisp macros are the last challenge that one has to understand (if not master).

Run-of-the-mill programmers

In many places it has been mentioned that lispers are not *Run-of-the-mill* programmer. They are different (in some cases arrogant), may be programmer elite. But popularity of a programming language depends on the acceptability of the language not on its power. Natural languages evolve out of existing languages to a simpler but verbose form. The same is not true for programming languages. There is no programming linguistic tree which has a common root node for syntax or semantic or paradigm. Lisp’s elite status may be the singular disadvantage to the general programming cloud.

We all play the role of *run-of-the-mill* programmer in any given project while it comes to coding and debugging. So *run-of-the-mill* programmers are necessary for any project to succeed and sustain. If your target is not *run-of-the-mill* guys you are bound to lose one day or the other.

Undermining Microsoft Windows

Not many lisp software works properly in Microsoft windows. The lion share of desktop application runs on windows box, but many lisp apps do not work.

Lisper world over has to take up the challenge to support Microsoft version of all the application that they are going to release. The word support can be even this one liner: “I do not care about windows. If it works fine else just do not disturb me.” At least some who cares about Microsoft compatibility will not use your stuff in his software.

Undermining Microsoft is bad, because Microsoft to computers is like photosynthesis to trees – it is a necessary evil.

Closure II and some future thought

noreply@blogger.com (samik chakraborty) — Fri, 13 Jun 2008 13:08:00 +0000

My last post about closure in my blog and my query in the comp.lang.lisp have created some interesting debate among lispers and my friends. They have sugested their views about my posts. Some of them said that it was required and some said “I do not care about closure”. All in all I felt good about it. At least some people took a notice about closure and what it means.

To begin the post I must correct one program from my privious post:


(let ((s0 0) (s1 1) (state 0))
  (defun input-action(in)
    (if (eq state in)
 (setf state in)
      (if (eq state s0)
         (setf state s1)
       (setf state s0)))))

I was really busy with my work of late and could not find any time (or topic) to write. I am busy with javascript and I am very happy with that. So I feel that in next couple of blogs I will write about some of JavaScript. For this I will go back to my school days and write programs which are like stack, queue and linked list. So that I can keep up with my old habits; what is it?

Programming.

Closure

noreply@blogger.com (samik chakraborty) — Wed, 23 Apr 2008 05:10:00 +0000

A closure can be a very deceptive concept that comes with programming languages like lisp, JavaScript etc. So what is a closure? Definition of closure from Wikipedia is like this:

“a closure is a function that is evaluated in an environment containing one or more bound variables.”

In closure we get an environment and a function in that environment. When the function gets evaluated it has the opportunity to play with the environment. In common practice we think that an environment is nothing but the state of execution of a program. Programs, as pointed out in the classic book “How to design Programs”, is variables plus functions. So we can say, in general, environment is nothing but current state of the variables.

How we create closures? Here is an example:

[1]> (let ((x 1))
(defun foo(n)
(+ n x)))
FOO

Here x is the bound variable which has a value 1 and this makes the environment for function FOO. FOO will always get x as 1 in its execution. When we call FOO we get:

[2]> (foo 3)
4

With this as our base let’s explore a classic example of closure. Yeah! The same old make-adder example, what I am talking about.

Here is the code for that:

[4]> (defun make-adder(n)
#'(lambda(x)(+ x n)))
MAKE-ADDER

[5]> (setf add1 (make-adder 1))
#

[6]> (funcall add1 2)
3

When we defined make-adder we created a closure with variable n in lambda function with its own variable x. As we call make-adder and store the resultant function in variable add1 we created a closure where we will add 1 to the passed argument. Now that’s OK but how can I use it? This question I faced from many. Here is my use case.

MOVE

I (with my friends) developed a simulator for Intel 8085 microprocessor in C. later I tried to redo the code in lisp and found a very interesting application of make-adder closure. By this time I got familiar with IA-32 and Intel family of 80x86 processors where the logic MOVE have not changed but the number of bits (or bytes) to move has changed to match processor register size and architecture. That’s the “Aha!” moment for me. I wrote a function that will create a move as per the bytes to move. Here is the code for that (I have a move function which takes from-reg, to-reg for register purpose and number of bytes to move):

(defun make-mover(n)
#'(move from-reg to-reg n))

This solved (I hope) my problem for backward (or forward) compatibility issues as long as Intel does not change its MOVE.

So now I can get MOVE8, MOVE16 and MOVE32 very easily. I should re-write the whole program like that starting from register class definition.

STATE MACHINE

In the beginning we found that closure has close relation with function and its environment. This fact intuitively gives us a ready made case for state machine implementations in closure.

Consider the following state machine; it has two states S0 (represented as 0) and S1 (represented as 1). Here is the logic that it performs, if the current state of the machine is S0 and input is 0 it remains in S0 else machine goes to state S1. If the current state of the machine is S1 and input is 0 it changes the state to S0 else it remains in state S1. This machine accepts 1 and 0 as input. Also note that this machine initializes at state S0.

Here is the code:

(let ((s0 0) (s1 1) (state 0))
(defun input-action(in)
(if (eq state in)
state
(if (eq state s0)
s1
s0))))

And here is two sample runs:
[19]> (list (input-action 0) (input-action 1) (input-action 0))
(0 1 0)
[20]> (list (input-action 0) (input-action 1) (input-action 0) (input-action 1) (input-action 1))
(0 1 0 1 1)

That’s all I have understood about closures. Let me know if something wrong or you have better idea of closure and its uses.

Thanks for reading.

On Parentheses

noreply@blogger.com (samik chakraborty) — Thu, 06 Mar 2008 14:47:00 +0000

People think about lisp parentheses as most hard thing in the world. When I started learning lisp it was a bottleneck for me too. I used to think what you do with these parentheses? Why it is like this. But now when I have started feeling a bit confident about lisp parentheses I felt I should put a note for absolute beginners of the language.

Parentheses while coding lisp

While you are coding always use a lisp editor for your parentheses handling. Best option is Emacs or XEmacs. If you are using it in windows please install and configure your Emacs in Windows (for some idea you can see here). Understand that good editor (like Emacs) will not only help you in coding in lisp but will increase your speed of translating your idea into code.

Use good key combinations to move around the parentheses as s-expression. Do not waste your time with bad editors which does not support any lisp mode; the faster you unlearn (thoes editors) the better you will be in coding lisp.

Parenthesis while reading lisp codes

There is no parentheses in the lisp code when you are reading a code. Yes, it may sound crazy for anyone starting out in lisp but it is true. Here is an example showing the concept:

(defun show-file(filename)
    (let ((in (open filename :if-does-not-exist nil)))
     (when in
      (format t "~a~%" (read-line in))
     (close in)))

Here is what you get when you removed all the parentheses:

defun show-file filename
let in open filename :if-does-not-exist nil
when in
format t “~a~%” read-line in
close in

It reads like:

Define function show-file which will take filename as argument
Let in be the file handler with filename; if the file does not exist do nothing
When there is a file handler in “in”
Format output as each line in the file comes
And yes close the file “in” before quitting.

That’s all! I hope this will help.

Imperative Programming:What is Wrong?

noreply@blogger.com (samik chakraborty) — Fri, 29 Feb 2008 08:22:00 +0000

What is *wrong* with the imperative programming? That’s the question that came up in a discussion where I was part; the dicussion group comprised of people from diverse software background and most of them has their lineage to C or C++. The points that came up during that discussion were well spread over the day to day activities of the programmers working in various types of projects.

Actually if you see from a distance it is absolutely ok to write a piece of code in your favorite imperative language, but if you take some time and code the software in your favorite functional programming language it feels and looks better; of course your choice of functional programming language has to be good.

Side Effects

Side effects make lot of problems while coding in imperative languages. Say you have a program that runs into several functions and as imperative language like C does not support higher order functions (in true sense) your functions are dependent on what we know as *GLOBAL VARIABLES*(to preserve the global state). Lets assume that you set an error flag if something has gone wrong in some function. As each function is interlinked in producer-consumer relationship with each other, once a function has done its job you have to see whether there is any error set or not. So your code will be sprinkled with codes like this:

i = fn1();

if( !errorset())

fn2();

This is not only bad while typing but also an example how a programmer loose his ability to think. How? As our example goes if you do it in several files and several functions; one fine morning loose the intent to think what may go wrong in simple function which is just checking whether a file exists or not! And I can tell you this happens because this happened with me.

Other than this, think about the time that I spent error handling. People might say that this is because you are using a programming language which does not support better error handling mechanisms to help the programmer. I agree, but as we know the imperative programming languages will always depend on Hoare Logic, i.e. it will have the notion of pre and post conditions. If we see both the paradigms of programming (lambda calculi and Turing machines) depends on those conditions but pure functional programming does not have side effects as it does not change (although lisp programs can do that) the values of its parameter.

But when I code in lisp I know that if I need an output from one function to another I will using the first one as a higher order function to the later. Then the second function only need to know what it expected out of the calling function if something goes wrong in the higher function it can handle it then and there and end the execution flow gracefully. This brings me to next topic execution flow.

Execution flow: Where am I?

Yup! This is a nightmare for any programmer in the imperative programming world; a bunch of programmer I knew once wrote a simulation program for Intel 8085 microprocessor but after each cycle of execution they didn’t know from where the program exited. It used to exit with unhandled error each time in Windows. If you think who they were I can tell you I was in that group. It took us some effort to fill that gap.

Now you might say that boy that doesn’t happen in real world! Oh yes that does not happen but we always have way to complete the process and most of the time the process is return-return-return till you come to main and then do simple check up and clean up of your mess with memory and then die by returning 0. No problems with that but think that if an execution starts and you know from the first command line checking itself that the user has made a mistake but you still follow your way of closing after eating some good processor time.

But in lisp you can’t loose your track! Even if you want you can’t, simple. How? If you are creating a properly designed lisp code with functional style you will be calling functions on top of one another so it will go on till the boundary of your hardware! It may fail some times but you will not be loosing your track. Even in error without any extra effort from your side you will be getting messages like: “Debugger invoked on ….”! I say, it’s just cool.

LOC – Yeah the greatest enemy of code!

I think Steve has given enough reason in his post so I need not prove this. But yes if I look at my C code some times I cry! How much I have typed for so little. Take the famous, old and boring “Hello World” program. In C you have to type at least 5 lines. In lisp REPL it’s only “Hello World”. Even a fancy function will be 2 lines. So you save 60% of typing effort while working with “Hello world” program.

And as the saying goes with lazy programmer I feel good while I use my “TAB” key for auto complete in XEmacs.

It happens especially if you need to work with raw data. By the time I finish structure filling code in C, I bet will be able to complete a subset of other tasks like some parsing also.

The crux of the matter is doing more out of less. If this is not good enough for you rethink about becoming a programmer.

Macros

My first impression about C macros was, “Here is subject which I need to learn because I really do not know what is wrong with my code when I use them.” The best macro I have used in my C code:

# define PRINTLN printf(“\n”);

And believe me it worked wonderfully for me. People in that discussion never understood what I was talking about when I said “function returning macro” or “code writing macros”. Because they do not know what a power a macro can have if you are programming lisp.

(I can go on talking about macros but I should refrain as this is not a sub-topic but requires major effort and can span several posts.)

A Small Mathematical Project

noreply@blogger.com (samik chakraborty) — Tue, 19 Feb 2008 06:48:00 +0000

Some times back I received an invitation to join an online community on Diophantine equations and related mathematical group in my Orkut account. I did not join the group for quite some time as I am very irregular in Orkut. But at last I when I wanted to join the group it is no longer there, this group’s moderator, a student of Indian Institute of Technology, wanted to run the community as complete mathematical community, unfortunately he decided to close the group.

When I learned about Diophantine equations in little details, I felt that how about writing a small common lisp utility to get going in this field. There were challenges to do that and more for a person like me who likes to work on his own code rather than using library in hobby projects. This post is all about what I felt during that development. I made a point of writing some lines while coding. Not as a comment but as a thought process.

How can I create a set (list) of values starting from one number and ending at another number? This question came to my mind first and the solution is writing a function which will give me a list like that on demand. It is intuitive that the arguments in this function would be a starting number, an end number and an incremental element which will increment the starting number till the end number or less. Moreover Diophantine equation demands that variables needs to integers.

(defun diophantine-create-set(start end)
(loop for n from start to end
while(<= n end) collect n))

Once I got that I have to think how I can represent a Diophantine equation in common lisp. The first thing that I felt is this has to be small so it will be a two unknown argument equation not an n-unknown Diophantine. At this point my imaginary linear Diophantine looked something like: Ax + By = K

Here I have to get the constant values from the user. That is good enough but another step needs to be done in this, which re-writing the equation,

y = (K – Ax) / B

Once I got this form of the equation I can write something like:

(lambda (x)
(/ (- k (* a x)) b))

So now how do I do this? I have come with this macro:

(defmacro diophantine-equation (a b k s e)
`(mapcar #'(lambda(x) (/ (- ,k (* ,a x)) ,b)) (diophantine-create-set ,s ,e)))

Following are some evaluation of this macro:

CL-USER> (diophantine-equation 1 1 10 1 100)
(9 8 7 6 5 4 3 2 1 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16 -17
-18 -19 -20 -21 -22 -23 -24 -25 -26 -27 -28 -29 -30 -31 -32 -33 -34 -35 -36
-37 -38 -39 -40 -41 -42 -43 -44 -45 -46 -47 -48 -49 -50 -51 -52 -53 -54 -55
-56 -57 -58 -59 -60 -61 -62 -63 -64 -65 -66 -67 -68 -69 -70 -71 -72 -73 -74
-75 -76 -77 -78 -79 -80 -81 -82 -83 -84 -85 -86 -87 -88 -89 -90)

CL-USER> (diophantine-equation 2 1 10 1 100)
(8 6 4 2 0 -2 -4 -6 -8 -10 -12 -14 -16 -18 -20 -22 -24 -26 -28 -30 -32 -34 -36
-38 -40 -42 -44 -46 -48 -50 -52 -54 -56 -58 -60 -62 -64 -66 -68 -70 -72 -74
-76 -78 -80 -82 -84 -86 -88 -90 -92 -94 -96 -98 -100 -102 -104 -106 -108 -110
-112 -114 -116 -118 -120 -122 -124 -126 -128 -130 -132 -134 -136 -138 -140
-142 -144 -146 -148 -150 -152 -154 -156 -158 -160 -162 -164 -166 -168 -170
-172 -174 -176 -178 -180 -182 -184 -186 -188 -190)

Looks fine till now but see what you get from the following evaluation:

CL-USER> (diophantine-equation 2 5 10 1 100)
(8/5 6/5 4/5 2/5 0 -2/5 -4/5 -6/5 -8/5 -2 -12/5 -14/5 -16/5 -18/5 -4 -22/5
-24/5 -26/5 -28/5 -6 -32/5 -34/5 -36/5 -38/5 -8 -42/5 -44/5 -46/5 -48/5 -10
-52/5 -54/5 -56/5 -58/5 -12 -62/5 -64/5 -66/5 -68/5 -14 -72/5 -74/5 -76/5
-78/5 -16 -82/5 -84/5 -86/5 -88/5 -18 -92/5 -94/5 -96/5 -98/5 -20 -102/5
-104/5 -106/5 -108/5 -22 -112/5 -114/5 -116/5 -118/5 -24 -122/5 -124/5 -126/5
-128/5 -26 -132/5 -134/5 -136/5 -138/5 -28 -142/5 -144/5 -146/5 -148/5 -30
-152/5 -154/5 -156/5 -158/5 -32 -162/5 -164/5 -166/5 -168/5 -34 -172/5 -174/5
-176/5 -178/5 -36 -182/5 -184/5 -186/5 -188/5 -38)

Now the main aim of diophantine equations is failing, as only the integer solutions are accepted as per Diophantine analysis. In the last evaluation we have some integer solution but this list has both integers as well as fractions. This to me is simply “Not acceptable!” Moreover I can bet that it will not be acceptable in mathematics community.

At this point of development I had to put some more code in my diophantine-equation macro, it has to check whether a solution is integer or not. I will map the list and create a list of solutions with integers if it exists. To achieve this I introduced another macro because I wanted to keep diophantine-equation macro as it is. Here is the macro:

(defmacro diophantine-solutions(a b k s e)
`(remove nil (mapcar #'(lambda(x)
(when (integerp x)
x))
(diophantine-equation ,a ,b ,k ,s ,e))))

Let’s see what kind of output I have from this macro:

CL-USER> (diophantine-solutions 2 5 10 1 100)
(0 -2 -4 -6 -8 -10 -12 -14 -16 -18 -20 -22 -24 -26 -28 -30 -32 -34 -36 -38)

Now as we have built this basic framework for Diophantine analysis, let’s put this to some test. I know that I may not be able to answer a lot of questions asked in Diophantine analysis. But this small framework can answer a basic question right now. The first question that is asked in Diophantine analysis is, “Are there any solutions?” of course I have to reframe the question as per my framework as “Are there any solution between the range that I have mentioned?” it looks something like this in the REPL.

CL-USER> (if (eq nil (diophantine-solutions 2 5 10 1 100))
nil
t)
T
CL-USER> (if (eq nil (diophantine-solutions 2 5 10 1 4))
nil
t)
NIL
CL-USER> (if (eq nil (diophantine-solutions 2 5 10 1 1))
nil
t)
NIL
CL-USER> (if (eq nil (diophantine-solutions 2 5 10 1 10))
nil
t)
T

This utility has only one function and two macros.

I hope you like this blog; however if you think that there is a better way (which I am sure would be) of doing some things that I have done here or if you find any bug please feel free comment on it.

Thanks for reading.

Disclaimer: This is a hobby project not for any production use.

Lambda Calculus and Common Lisp

noreply@blogger.com (samik chakraborty) — Sat, 16 Feb 2008 11:33:00 +0000

Warning: If you do not like mathematics this post may not be interesting to you.

When we talk about lisp or any dialect of it we come across the term functional programming. So what is functional programming any way and where it all started? If you ever have thought about such things here is my small attempt to answer some very fundamental questions in functional programming.

So what are the functions? Here are some basics.

In mathematics functions is some kind of relation between two things. But wait a minute isn’t functions are some code snippet that does some tasks? After all we programmers know functions that way. Yeah, both are correct and they do not have any difference. Like a function, which increments a variable by one, can be represented in following way:

f(x) = x + 1

So we can write a lot of functions like this in mathematic and solve them for a value. However there was no such concept as function in the begging of computer science instead there were just Turing machines which used to change state to provide result and solve problems by means of its states; this is such a great system that it can solve all computational problems.

Then Alonzo Church came up with lambda calculus and revolutionizes the whole concept of representing and solving problems. He wanted to solve some mathematical paradox (if you want to know about them see here and here); unfortunately that was not solved but we got our base for functional programming.

I think its enough of history; let’s start what this post is all about.

Basic Notations

Here is how you can represent the previous function in λ calculus:

λx.x+1

And if we want to evaluate for x = 2 we write it as:

(λx.x+1)2

Now we can write the same in common lisp as:

((lambda(x)
(+ x 1)) 2)

Now functional calculus we have learnt another thing which is higher order functions. Higher order functions are nothing but functions whose arguments are also functions (I will not get into the evaluation debate here).

Like this:

Suppose we have a function f(x) = x + 1 and g(x) = x + 2 and we are calling f(x) as f(g(x)).

How is it going to be evaluated?

f(g(x)) = g(x) + 1 = x + 2 + 1 = x + 3

So how do we represent it lambda calculus?

(λx.x+1)(λx.x+2)

Now if we want to evaluate this for x = 2 we write it as

(λx.x+1)(λx.x+2)2

In common lisp we write:

((lambda(x)(+ x 1))

((lambda(x)

(+ x 2))2))

Free or Unbound Variable

“The variable X is unbound.”

How many times you have got this message in your REPL? This comes directly from lambda calculus; here is how.

Any variable that is not a member of any lambda expression is called a free variable and it does not have any effect on the evaluation of that expression. However in programs we cannot use such variable for evaluation. If we do so we get this error message.

In lambda calculus a variable in cases like this:

λx.(x * y)

Here the variable y is free. The same happens in common lisp.

((lambda(x)

(* x y))1)

Logical Stuffs

In programming we use logical operators every day, the two mostly(or *ONLY*) used of them are *AND* and *OR*. How lambda calculus does it?

Before I start I want to give the meaning of the following lambda expression:

λxy.xxy => λxy. if x then x or y.

And this expression is the *OR* function in lambda calculus. So we can write it in common lisp as:

(lambda(x y) (if x x y))

The *AND* function also look quite similar

Lambda Calculus: λxy.xyx

Common Lisp: (lambda(x y) (if x y x))

So that’s all about very ugly comparison of lambda calculus and common lisp. I know that I missed lot of things which include reductions and reduction strategies. But one can read about lambda calculus tutorials to get fair idea on this; here is my choice:

www.cs.chalmers.se/Cs/Research/Logic/TypesSS05/Extra/geuvers.pdf

www.utdallas.edu/~gupta/courses/apl/lambda.pdf

Thanks for reading.

Samik's Restless Rants

Code aging:Can a computer program age?

Why I Code or note to my first love?

Needed a better Twitter so we made one for ourself

How we made a social news service with machine learning from scratch

Ten Commandments for How Not to Become a Good Programmer

REST will stay – you can wash your SOAP away

Lets Un-Uncomplicate

Why is it harder to read the code than writing it?

10 Things to Keep in Mind while depeloping a Web App

Reading Cricekt - A Fun full Learning

Come Back!!!

Caveat - The Name has Changed

Loooopy

Weekend Programming Excursion - 1

Last Day at Wipro

JSON – Traps and How to Avoid Them

Building Shindig 101

Code and Data Equivalence

Why lisp is *Unpopular*

Prefix notation

Mathematics behind lisp

Programming language politics

Code – data Equivalence – Hard to understand

Macros

Run-of-the-mill programmers

Undermining Microsoft Windows

Closure II and some future thought

Closure

On Parentheses

Imperative Programming:What is *Wrong*?

A Small Mathematical Project

Lambda Calculus and Common Lisp

Why lisp is Unpopular

Imperative Programming:What is Wrong?