CODING INSIGHTS

Running your own one person company

2011-06-06T13:45:00.004+05:30

Recently there was a post on PuneTech on mom's re-entering the IT work force after a break. Two of the biggest concerns mentioned were :

Coping with vast advances (changes) in the IT landscape
Balancing work and family responsibilities

Since I have been running a one person company for a good amount of time, I suggested that as an option. In this post I will discuss various aspects of running a one person company.

Advantages:

You have full control of your time. You can choose to spend as much or as little time as you would like. There is also a good chance that you will be able to decide when you want to spend that time.
You get to work on something that you enjoy doing. Tremendous work satisfaction.
You have the option of working from home.

Disadvantages:

It can take a little while for the work to get set, so you may not be able to see revenues for some time.
It takes a huge amount of discipline to work without a boss, and without deadlines.
You will not get the benefits (insurance, etc) that a company would give you.
Your finances may or may not show a constant graph.
You may have a hard time getting home loans, since most banks (especially in India) feel that employed people are more stable (whatever that means :-) )
People may think you are not doing real work (most people have a very skewed notion of what real work means)
You will have to deal with distractions, if you are working from home.

Even though the disadvantages outnumber the advantages, qualitatively I think the advantages are vast. I may be a bit biased, but I really think that a 9 - 5 job in a large organization, totally sucks the soul out of a person.

Legal

I will restrict this advise to India, whose laws I am accustomed with. You do not need to register any legal entity to run a one person business. You can run it on your own name, you can raise invoices on your own name, and you can file your taxes on your personal PAN number.

Some people may create a sole proprietorship, but that is purely to have a business name and to be able to invoice clients on a business name, rather than your personal name. Besides this, having a sole proprietorship has the advantage of being able to easily separate personal and business accounts. The latter can be achieved simply by keeping a separate savings account for work related transactions.

Some people may also choose to create an LLP. Besides the points mentioned for sole proprietorship,an LLP will shield your personal finances against business losses, lawsuits, etc.

I will not get into the legalities of creating a sole proprietorship, or LLP. My suggestion is to start work on your personal name, and create a legal entity later, if required. You should consult your CA for details of creating a business entity.

Types of work

There are many types of work that can be done as a one person business. I will focus on IT related fields in this post.

Freelancing:

Many people make a living by doing freelance projects. You can either get projects directly from clients, or you can work on one of many freelancing websites. These websites publish projects that people want completed. If you feel that you can do the project, then you can bid for it. If you get the project, you will have to complete it in the stipulated time, and with the required features. The payment usually comes once the client is satisfied with the work. Most of these websites allow the client as well as the developer to rate each other. These ratings go a long way in determining whether a client will give you projects. Typically a freelancing website have work related to coding, documentation, website design, etc. Some such websites are: Elance, vWorker.com, FreelanceSwitch, ODesk, and freelancer.com. (Disclosure: I will get a small commission if you register on some of these websites, following the provided link)

Regardless, of whether you get projects from a freelancing website, or on you own, you should always have your own website, and a blog. I cannot stress how important it is for a freelancer to have a blog. Your blog is the place where potential clients and friends get a glimpse of the real you. It is also your showcase for projects completed, and an online portfolio.

Contract programming:

If you have been in the software industry for a long while, then you probably already have a lot of contacts who would like to give you some contract programming work. This can also be lucrative and fun. In contract programming you typically make a commitment (such as 20 hours per week), and charge on an hourly rate.

Teaching:

If have passion for sharing your knowledge with others, then teaching is a wonderful way to do satisfying work and earn a livelihood. There are various avenues for teaching. You can teach in a local college, you can teach at companies, or you can teach on the Internet. You can also do all of these if you desire.

Some places you can create courses and teach on the web are, edufire.com, and wiziq.com. You can also create your own website for teaching using Moodle, or a similar open source software. I have created my own website for teaching computer science, but I am not yet making any significant revenue from it, so beware before you take it as a role model :-) However, you can check out this website of a database expert who maintains a learning community on his website.

You can also create and sell screencasts like the people at Peepcode, and Destroy all software.

I think there is a lot to be said about teaching, and it probably warrants a separate blog post.

Creating mobile applications:

Many people make a living by creating mobile applications, for Android, iPhone, etc. The amounts vary, but it is very much do-able. Several people give helpful tips and also post there monthly incomes on their blogs. You might find them useful. This is one example website of an independent developer who posts monthly incomes and also gives helpful tips.

Creating stock photos, and designs:

If you are the arty type, you can create stock photos, images, or icons, and put them up for sale on stock photo websites. There are many such websites, and some people are able to make a good continuous stream of income from them. iStockPhoto is one such website. You can also create designs for clients on sites like 99designs.com.

Selling websites:

If you enjoy making and selling websites, you can make and auction your websites on Fippa.com.

Niche websites:

If you are really passionate about something, and also have a lot of knowledge in that field, then you can share your knowledge on a niche website, and earn revenues from advertisements, affiliate sales, subscriptions, etc. See this blog post on information about building niche websites.

E-Commerce:

If you have something to sell, you can also set up shop using a hosted e-commerce solution. However, keep in mind that managing logistics, shipping, handling, and customer care may be more than what one person can handle.

I hope you found this post useful. This is a brief list of things that can be done as a one person entity, and some pointers on how to go about doing it. I think plenty more can be said on this topic.

I will try and write further blog posts talking about each of these points in greater detail.

My HSQLDB schema inspection story

2011-04-27T17:17:00.001+05:30

This is a simple story of my need to inspect the schema of an HSQLDB database for a participar FOREIGN KEY, and the interesting things I had to do to actually inspect it.

I am using an HSQLDB 1.8 database in one of my web applications. The application has been developed using the Play framework, which by default uses JPA and Hibernate.

A few days back, I wanted to inspect the schema which Hibernate had created for one of my model objects. I started the HSQLDB database on my local machine, and then started the database manager with the following command

java -cp ./hsqldb-1.8.0.7.jar org.hsqldb.util.DatabaseManagerSwing

When I tried the view the schema of my table, it showed me the columns and column types on that table, but it did not show me columns were FOREIGN KEYs.

Image 1: Table schema as shown by HSQLDB's database manager

I decided to search on StackOverflow and find out how I could view the full schema of the table in question. I got a few hints, and they all pointed to the system tables, so I decided to turn on the "show system tables" option from HSQLDB's view menu.

The first table that caught my eye was information_schema.system_tables, so I fired the query:


select * from information_schema.system_tables;

This gave me all the system as well as application tables, but did not give me the detail I was looking for, which was the FOREIGN KEY contstraints on the 'USERREGISTRATIONDATE' table.

The next table that caught my eye was information_schema.system_table_constraints, so I fired the following query:

select * from information_schema.system_table_constraints where table_name = 'USERREGISTRATIONDATE';

This helped a bit further. It told me that the USERREGISTRATIONDATE table had a FOREIGN KEY and the constraint name was 'FK98DCB61247140EFE'.

Image 2: Result from table INFORMATION_SCHEMA.SYSTEM_TABLE_CONSTRAINTS

Nice, but it still did not tell me which column the constraint refered to.

The next table I came across was information_schema.system_crossreference. This seemed to have a column called 'FK_NAME'. Good, I fired the query:

select * from information_schema.system_crossreference where FK_NAME='FK98DCB61247140EFE';

Here is what this table showed me...

Image 3: Result from table INFORMATION_SCHEMA.SYSTEM_CROSSREFEREBCE

Awesome, this time it showed me the name of the the FOREIGN KEY 'FK98DCB61247140EFE' references the 'ID' column of table 'USER'

I finally had my answer, but before ending this post, let me mention just one more thing. I realized that I did not need the information_schema.system_table_constraints table at all. I only needed the information_schema.crossreference table with the following query:


select PKTABLE_NAME, PKCOLUMN_NAME, FKTABLE_NAME, FKCOLUMN_NAME 
from information_schema.system_crossreference 
where FKTABLE_NAME='USERREGISTRATIONDATE' and FKCOLUMN_NAME='USER_ID';

Image 4: Finally the query that clearly showed me the FOREIGN KEY

Now all this should not have been so time consuimng. The GUI tool should have given me this information right away.

Double Checked Locking And Java Singletons

2010-10-15T15:49:00.007+05:30

I read this article by Bill Pugh on why the double checked locking idiom does not guarantee thread safety in Java Singletons. That article taught me a lot of new things, and to be honest, I had to re-read that article at least a couple of times to partially understand it :-)

I recently created a presentation to make at DevCamp on this topic. What follows are my slides and an explanation of each slide. I hope you enjoy this presentation and find it useful.

Double checkedlockingjavasingletons

View more presentations from parag.

slide 1:

In this presentation I will discuss the double checked locking idiom, and explain why it does not work to provide thread safety to Java Singletons. I will also talk about how using volatile fields will fix the problem in JDK 1.5 onwards.

slide 2 (Singleton):

Many of you might already have used the Singleton design pattern. In case you have not, here is a brief description of what Singletons are. The Singleton pattern is used when we want to ensure that there is only one instance of a class per something. In most cases, the something is 'JVM - Classloader' combination. So, in such cases we want to ensure that there is only one instance of the Singleton class in the JVM-Classloader. But we are not restricted to this. We may need only one instance of the Singleton per Session, or per Request, or per anything else that makes sense in the software you are making.

It is clear that we want to control the instantiation process of the Singleton class. To do this, the first thing we do as shown in the example is to make the constructor private. With the constructor private, no other class can create an instance of this class. OK, so how will we create any instance of this class? We provide a public static method called getInstance() which will return an instance of this class. We will also use a private static field called instance to hold the one and only instance of this class. Since we control the getInstance() method, every time it is invoked we will return instance. The first time however, instance will not be initialized, so we put a null check in getInstance() and instantiate instance if it has not already been instantiated. Hence forth we will always return a reference to instance. This way we ensure that only one instance of our Singleton will be ever created (the one we save in the field called instance).

slide 3 (Is This A Safe Singleton?):

Look at the class carefully and ask yourself "Is this Singleton safe?"

slide 4 (The Singleton is not Threadsafe):

If you have looked at the class carefully, you will realize that the Singleton is not thread safe. This slide shows why it is not thread safe. Imagine that a thread T1 invokes getInstance(). If an instance of the Singleton has not been created till now, then instance will be null, and T1 will enter the if block. Now imagine that T1 gets pre-empted, and thread T2 also calls getInstance(). Since T1 got pre-empted before it got a chance to create instance, the reference in instance is still null. So T2 will also enter the if block. Now if T2 does not get pre-empted then it will go ahead all the way where it will create an instance of Singleton, and probably even use it. Now when T1 is resumed, unfortunately it does not know that the Singleton has already been created, since it has already gone past the null check. T1 will also happily create an instance of our Singleton, thus breaking the Singleton pattern. We have 2 instances of the Singleton which is simply not allowed.

slide 5 (Let;s Make It Threadsafe):

Alright so we need to make the getInstance() method thread safe. The simplest way to do this is by making it synchronized. Once it is synchronzied, only one thread will be allowed to enter the method at a time, and we will never get into an issue where we end up having multiple instances of the Singleton.

slide 6 (That Was Expensive):

Making a method synchronized is expensive. A thread executing a synchronized method must acquire a monitor before it can invoke the method, and release the monitor after executing the method. This takes time and CPU cycles. In early JVM's (I have read somewhere), the time to invoke (not execute) a synchronized method was as much as 100x the time taken to invoke a non synchronized method. I think this was improved in later JVM's where it was about 15x. I recently did a quick test on JDK 1.6, and the number I got was 2x. Regardless of how much slower it is, it is definitely slower, and programmers always want to make their code fast.

slide 7 (Let's Use Double Checked Locking):

Some very smart programmers came up with the "double checked locking" idiom to relieve the code of this expensive operation. What we really should have done, is only synchronize the code which instantiates the Singleton, and not the entire method. That way we incur the expense of the synchronized block only once, when the Singleton needs to be created, and all subsequent times (instance == null) will always be false, and the instance will be returned to the calling code. We put a second check inside the synchronized block, because it is possible that a thread could get pre-empted just after the first null check, but before it enters the synchronized block. In such a case, if another thread enters this method, and goes all the way to creating the instance then the first thread will not know of it and will create a second instance. To prevent this, we put another check in the synchronized block.

So this is a pretty smart solution. We eliminate the synchronization on the method, thus eliminating synchronization on the main path.

slide 8 (Will It Work?):

The solution described in the previous slide (double checked locking) is a pretty smart solution. But it does not work.

slide 9 (Why?):

There are two reasons why it does not work. The compiler as well as the processor (as well as the JVM) may reorder instructions if they feel it might be more optimal. Off course they cannot randomly reorder instructions but they could if they can prove that the reordering will maintain as-if-serial semantics. However, this is not the only reason. On a multi-processor system, each processor has it's own memory cache. The cache is not always synchronized with main memory immediately. This can cause a write to a memory location to happen in the local cache, which will not be visible to other threads which could be running on other processors. Even if the writing thread does flush it's local cache, it is still possible that another thread which reads that value, may not have pulled in most recent values from the main memory into it's local cache. This can cause a situation very similar to reordering where the effect of a write is not visible to another thread that is reading that variable's value.

slide 10 (instance = new LoneRanger(””) != Atomic operation):

If you look at the example in slide 7, you might think that the statement below is an atomic statement.

instance = new LoneRanger();

But that is not the case. For the sake of simplicity this slide shows the statement above broken into 2 operations. In the first part, an instance of the class is constructed, and in the second part a reference to that instance is assigned to the variable instance.

slide 11 (Compiler Reordering):

Now what if the compiler reorders the instructions in such a way that the field instance is assigned an uninitialized block of memory (created for the class LoneRanger), and then the constructor of LoneRanger is invoked in the second step.

slide 12 (Compiler Reordering Pseudocode):

This slides shows pseudocode to understand the effect of compiler reordering on the double checked locking code. The code in the synchronzied block which instantiates our Singleton is broken into two steps: assignment, and initialization, where the assignment happens before the initialization.

Now imagine thread T1 enters the getInstance() method, enters the synchronized block and executes the statement which assigns the block of memory allocated for LoneRanger to the variable called instance. If T1 gets preempted and thread T2 enters getInstance() then T2 may see a non null value for instance. Thus T2 will actually be returned an initialized object of LoneRanger. This could cause all sorts of bugs in the software.

So in the first problem described a few slides back, we ran into the issue of having multiple instances of our Singleton, which we attempted to fix with the double checked locking idiom. However, this introduced the issue where a thread might be given a reference to an uninitialized instance of the Singleton.

slide 13 (Can We Prevent reordering):

Programmers never give up :-) When an even smarter programmer was explained this problem, he remarked "so let us prevent reordering and our problem will be solved !". Ok let's try that, but how do we prevent reordering? Well there is something called a memory barrier, which may help us. Instructions cannot be reordered across memory barriers (although they may be reordered within a memory barrier). Let's see if we can introduce memory barriers to prevent the reordering that's been giving us such a hard time till now.

slide 14 (Memory Barrier):

A memory barrier is a low level (at the level of the processor) construct which is used to create a fence around instructions. Instructions which are fenced inside a memory barrier cannot be moved out of the fence, and memory caches are also synched with main memory when a memory barrier is encountered.

slide 15 (Memory Barrier):

This slide explains memory barriers with an illustration. In this slide notice that instructions (instr2, instr3, & instr3) are fenced with the memory barrier. Because of the semantics of a memory barrier these instructions can never be moved out of the barrier, but they may be re-ordered within the memory barrier. We can also see when the memory barrier is entered the local processor cache is invalidated and latest values are read from the main memory, and when the memory barrier is exited then the local cached is flushed and the main memory is updated with the latest values.

slide 16 (Memory Barrier):

Because memory barrier is a low level construct, there is no way to explicitly create one in a high level language like Java. However, the synchronized keyword in Java implicitly creates a memory barrier. Before I read this, I had no clue that synchronization in Java is anything more than a mutex. But I read somewhere that when a monitor is obtained an memory barrier is also created and when a monitor is released the memory barrier ends (this is my understanding, please correct me if this is wrong).

slide 17 (Double Checked Locking With Memory Barrier):

The fact that assignment and construction of our Singleton could be reordered created the issue of potentially having an uninitialized Singleton. We want to ensure that the reordering does not happen. For that let us separate the construction and assignment with a memory barrier and put the assignment after the construction. We do this with 2 synchronized blocks and a temporary variable. In the inner synchronized block we will initialize the Singleton and assign it to a temporary variable. We don't care if this is reordered, because the class variable instance will still be null which will prevent another thread from getting an initialized instance of the Singleton. Then we assign the reference to the temporary variable to the class variable instance. This happens outside the memory barrier. So by employing a memory barrier we are hoping to maintain program order in the execution of instructions. Again a very smart solution, but unfortunately this does not work either.

slide 18 (Monitor Exit Semantics):

The semantics of monitor exit specify that everything that happened before the monitor exit should happen before it, which means that nothing from the inner synchronized block (where we instantiate the Singleton) will be moved out of the inner synchronized block, however, it does not mean that something will not be moved from outside of the block to within it.

slide 19 (Monitor Exit Semantics):

This slide explains monitor exit semantics with an illustration. As we can see inst2 and inst3 are within the memory barrier. Neither of them will be moved out of the block, but inst4 which is out of the memory barrier may be moved in the barrier.

slide 20 (Double Checked Locking With Memory Barrier):

This slide shows the code where we tried to use the memory barrier. But this time we show the code with a potential reordering. With the statement instance = tempInstance inside the memory barrier it could be further reordered to the point before the actual construction of the Singleton, bringing us back to the same problem.

slide 21 (OK So What The Hell Will Work ?):

Alright enough of playing around... not I am getting a bit edgy.... just tell me what the hell is going to work. Is this what you are saying to yourself? Java has a special modifier called volatile. We can use these fields to help us with the Singleton.

slide 22 (Semantics of volatile):

The volatile modifier is used in Java to communicate state changes between threads. This slide explains the semantics of volatile with an illustration.

The code on the left shows a class which has two methods: writer() and reader(). The writer() method writes values of variables x and v to memory, and the reader() method reads values of x and v from memory. Imagine that both these method will be called by different threads T1 and T2, running on different processors P1, and P2. Each processor has a local memory cache and off course there is also the main memory. The variable v is volatile and x is not volatile.

When thread T1 executes writer() we are guaranteed that the instructions will not be reordered because v is volatile. We are also guaranteed that when thread T1 exits the method, processor P1's local cache will be flushed to main memory, which means that the value of x as well as v will be visible to other threads. When thread T2 executes the method reader(), it first reads the value of v, this is going to invalidate the local cache of P1, and fetch the latest values from main memory. This ensures that it sees the latest values (which in this case were the ones written by T1 when it called writer()) of v and x.

So this slide explains the semantics of volatile and how volatile may be used to ensure that instructions are executed in program order and also ensure the visibility of writes by one thread by another thread.

slide 23 (Double Checked Locking With Volatile):

This slide shows our old and well known example which uses double checked locking, but this time with a little difference. This time we have made the variable instance a volatile field. Making it volatile will ensure that the write to initialize the LoneRanger object and the assignment of that instance to the field instance will not be reordered. This elimitaes the problem of seeing an uninitialized Singleton object.

slide 24 (Singleton With Static Initializer):

After doing all these coding gymnastics, in this slide we show a solution which is probably the simplest solution for creating a thread safe Singleton. Instead of instantiating the Singleton in getInstance(), we use a static initializer, which will instantiate the Singleton when the class is loaded. Java semantics ensure us that all static fields of a class will be completely initialized before the class is available for use. This means that the field instance will be properly initialized before anyone makes use of the class to get an instance of the Singleton.

slide 25 (Singleton With Static Initializer):

In this slide we understand the pros and cons of using a static initializer. Even though using a static initializer is the simplest solution, it is possible that everything the Singleton needs to initialize itself may not be available when the class is loaded (which causes the static initializer to be invoked). It is also possible that the Singleton may be eagerly loaded, which may result in greater loading time for our application, something that may be undesirable if instantiating the Singleton is an expensive operation.

slides 26, 27, 28 (Summary):

In these slides we summarize the main points covered in the presentation till now.

slide 29 (Resources):

Links to some very good and relevant articles, including my favorite article by Bill Pugh.

slide 30 (Thank You):

Thank you for your patience. I hope you found this presentation useful. One more thing before signing of - many people (here and here, but someone also disagrees) consider Singletons to be evil...

DIY Masters in Computer Science

2010-07-24T15:44:00.007+05:30

Since my formal education, a lot of advances have taken place in software development. I have been able to keep up with a few with regular reading and practice. But a lot of this learning has been a bit random, and as a result a bit dissipated as well. I feel like I want to engage in continuous learning, in a more organized manner.

Over the years there are several core concepts which I have forgotten because I have not been able to use them in my regular work. I feel like relearning those concepts.

I think the volume and content of both these can constitute a masters course in Computer Science. But I do not want to go back to school. Not because there is anything wrong with school - I had a great time in grad school. But here's why...

I don't want to go back to school because I want to define the courses I want to learn, and not pick up from what's offered.

I don't want to go back to school because I want to be able to learn at my own pace, which at times may be slower than 1 course per semester.

I don't want to go back to school because I do not want to spend a fortune learning stuff which I can learn myself using free resources.

I don't want to go back to school because I would rather create online/social credentials than get a school certificate.

I don't want to go back to school because I want to demonstrate that a person can not only get knowledge but also credentials if they engage in disciplined self-study and leave learning trails on the Internet.

So this time I am doing a DIY (Do-It-Yourself) masters in Computer Science. so I can refresh things I have forgotten and learn new technologies and concepts which have gained importance in recent times, in an organized way.

I did a Masters in Computer Science more than a decade back. Since then, Internet, communication technologies, and social networking, have made it possible for someone to do a similar program all by themselves, using open courseware, and social learning.

By doing this program, I am not only planning to enhance my own knowledge, but am also hoping to show how one can get a Master's education worth of knowledge, and credentials, by self learning, and without spending a fortune. Here's a very brief statement of purpose.

My DIY Learning Process:

I have created a learning plan which outlines at a high level the topics I want to learn. I will study one or two topics at a time, and at a manageable pace, given other work commitments.

Once the topics to learn have been identified, I will identify learning resources, forums, and mentors for that topic.

A very basic study plan is to study the material, and make notes of my understanding, as well as questions and thoughts, I get in my mind as I am learning. I will make these notes available on a special blog. This blog will serve as a personal knowledge base (I can refer to it in the future), as well as a learning trail (for proof of study and understanding).

All the homework I do while I am taking a course will be made available in the public domain. I will either post it on my blog, or if the homework involves coding, on a public open source repository such as Github. I will also do one or more projects to practice the entire body of knowledge as a whole and publish that too in the public domain.

I will also create presentations of what I learn, and make them available in the public domain.

I will connect with mentors who are experts in the topic I am learning. Depending on their time availability I will request them to help me identify gaps in my understanding, and validate my knowledge.

When I have doubts, I will ask questions on Internet forums. If my questions are not answered satisfactorily on the forums, I will refer them to my mentors.

Please visit my learning plan for further details.

Establishing Credentials:

A person can have several reasons for learning. One is for the knowledge (either for the joy of knowing something, or for more practical application of the knowledge), and another for establishing credentials, so someone else may entrust us with work which requires such knowledge. A self learned person may have the knowledge, but may lack credentials to prove it. It is also possible for a person studying in a silo to think he has grokked what he just learned, when in reality he may not have understood the matter properly. To be able to provide proof of knowledge as well as to validate my learning with other practitioners, I plan to engage in what can be loosely classified as social learning.

I will do the following to document my learning and to engage with the community of practitioners, in the hope of validating my knowledge and establishing credentials for what I learn:

Answer questions on forums
Blog my study notes, and clearly articulate my takeaway from all the lectures I view, or text I read
Create presentations and post them on YOUTube, or other video sharing services
Publish homework on open source code repositories such as GitHub, etc
Request my mentors to quiz me to help me find gaps in my understanding of a topic. I will publish the quiz as audio/video and request the mentor to post their feedback in the public domain
Take quizzes and tests wherever possible and economical

So I am leaving these learning crumbs on various places on the Internet, but I need something to bring everything together. Something which can serve as the focal point, or a lens into all my learning. I created a wiki site to serve as the focal point.

Have you been meaning to learn something yourself? Perhaps you can do your own DIY course in whatever interests you. Here is a lens into my DIY experiment.

Android apps can run in parrallel (video)

2010-05-12T17:14:00.000+05:30

This is the seventh in a series of videos published by Google on Android programming.

In this video the speaker starts an app to track photos his buddy publishes on Flickr. He can keep this application running in the background, so while he is browsing or checking his email, this application will constantly track the photos and notify him if a new photo has been uploaded.

Adndroid apps don't have any borders (video)

2010-05-11T16:44:00.001+05:30

This is the sixth in a series of videos provided by Google on Android programming.

Index:
00:00 Introduction
00:32 Zebra crossing application
01:35 Library app
02:14 A GeoSocial app which combines user GPS, user created photos, and Compass

My Takeaway:
Android applications do not have any borders. They can use data from other applicatiosns, they can use hardware available on the device such as camera, compass, GPS, accelerometer, etc, and they can also use content from the web API's.

The first application called Zebra Crossing is an application which can pull information from bar codes and QR codes. So if you photograph a product's bar code and give it to the application, it will pull up information about the book from the web. If on the other hand you give it a QR code from the back of a business card, it can extract contact information about that person which you can use to call or send email. The Zebra Crossing app also publishes intents, to allow other applications to communicate with it.

The second application is a library application which uses the "Zebra Crossing" app to add books to your personal library.

The third application, which I found to e really cool is an application which mashes together GPS, photographs, and the Compass to create a GeoSocial application. So here's what it does. Imagine you are on a vacation and want to locate cool things around where you are. You can use this application to find out all the photographs people have taken around that locality. If you find something you like, you can actually locate that thing (which was photographed) on a map and also use the Compass to get there. Cool isn't it?

How to embed the web in Android apps (video)

2010-05-10T10:05:00.001+05:30

This is the fifth in a series of videos provided by Google on Android programming.

This video shows how we can use the WebView to create applications that render HTML pages. Along with being able to embed HTML and Javascript web pages in apps, the most exciting thing I found in this view was the fact that the Javascript in a webpage can communicate with Java code and Java code can communicate with javascript. This is really cool.

Android programming - All applications are created equal (video)

2010-05-09T13:06:00.000+05:30

This is the fourth video in the series of videos provided by Google on Android programming.

Index:
00:25 Dianes ringtone app
01:08 App to create a shortcut to anything on the system
01:36 Replacing the home screen (End at 02:17)

My Takeaway:
This video shows that all applications created on the Android platform are equal. Even though I have not done any iPhone development, I believe applications written for iPhone do not have access to everything the way Android applications do. So this is a positive for Android development.

In this video we see how to a custom application can change the ringtone on an Android phone, how another application can create shortcuts to anything on the phone, and how we can also change the 'Home' application.

Android Programming - API's (Video)

2010-05-08T12:45:00.003+05:30

This is the third video in the series of videos provided by Google on Android programming.

Index:
00:00 Introduction
00:16 Android API's
00:24 Location Manager
01:25 XMPP
02:42 Notification Manager
04:08 View System
06:00 Conclusion (Ends at 07:05)

My Takeaway:
In this video the speaker talks about API's provided on the Android platform to developers.

The LocationManager API allows an application to get the location of the device it is running on. This information can be used to register intents, which will inform the user if they are close to an interesting location such as a Ice Cream shop. I can also think of another use. If traffic information is available, then we can also use the location manager to inform us if we are getting close to a high traffic area. Interestingly this API uses whatever information it has to determine the location. If GPS information is available then it will use that, otherwise it will use cell tower information.

XMPP Service is used to send messages to a device. It can be used to send device to device messages, or server to device messages. I think this API can have very interesting uses. It can be used for multiplayer games, and it can probably also be used by trekkers to track each other.

The Notification Manager API provides applications the ability to send notifications to the user on the status bar. My impression is that this API is very well designed. The notification appears on the status bar, such that if a user selects it (using whatever input method available... touch, etc), it will display a preview about the application and notification. If the user is interested, they can further select the notification to go to the application which send it.

The View system provides several view controls help developers make their applications. Interesting controls include a Map control to embed location information in applications, and an HTML control to embed web pages in applications.

Android programming - Application lifecycle (Video)

2010-05-05T20:41:00.004+05:30

This is the second video in the series of videos provided by Google on Android programming.

Index
00:00 - Introduction
01:00 - How Android integrates apps written by different authors.
07:50 - Conclusion (Ends at 08:16)

This video walks us through a hypothetical use case, where a user opens their email, reads a message which contains a link to some location. The user then clicks on the link, opens the browser and views the location on Google Maps.

While engaging in these activities, the user starts various applications (processes) and also navigates back and forth among them. The video explains how Android manages resources and the application stack so the user can navigate across their apps seamlessly.

My Takeaway
From the video it seems like Android supports a maximum of 4 running processes. One of those processes is the System process, so a user can have at most 3 applications running simultaneously. However, this does not mean that a user cannot open more applications. When the user opens the 4th application, Android will automatically terminate an application, and will also revive it in a known state if the user were to go to it again.

Update:
Ram pointed out that "4 running processes" is purely a number they used in this example. He is absolutely correct. 4 is just an example (perhaps they assumed 64 MB RAM on the phone...). The real number depends on the amount of memory (RAM) available on the phone.

Android programming - architecture video

2010-05-02T12:20:00.007+05:30

I have been getting interested in Android programming, so I went over to their website and found some introductory videos.

Here's the first one with a little index of what is discussed and my take away from the video.

Video Index:
00:0 Introduction
00:40 Linux Kernel
01:09 Native Libraries
03:09 Android runtime
04:13 Core libraries
04:31 Application framework
07:00 Applications
07:25 Application building blocks
09:37 Example of re-using components in Android
12:18 Conclusion and resources
12:48 End

My Takeaway:

Architecture wise the Android platform has several layers:

Linux Kernel
Native Libraries
Android Runtime
Core Libraries
Application Framework

The applications that we make are build on top of the "application framework" layer.

The Linux Kernel was chosen because of it's stability, services, security, and presence of several device drivers.

Native Libraries consist of various components for rendering graphics and fonts (Surface Manager, OpenGL, SGL, Freetype), a lightweight database engine (SQLLite), a browser engine (WebKit), and others.

The Android Runtime consists of Dalvik the Java Virtual Machine created by Google, which is optimized for running on embedded devices which have low resources. Dalvik runs *.dex files which are created by converting *.jar and *.class files. On top of Dalvik are the core Java libraries consisting of things like the Collections, IO API, etc.

Then the Core libraries layer consists of components such as Activity Manager, Resource Manager, Package Manager, Content Provider, Telephony Manager, XMPP, etc.

Android applications typically have 4 building blocks, which applications mayor may not use. These are:

Activities
Intent Receivers
Services
Content Providers

The video ends with an example of how various applications can re-use a photo picker component. So, we may have multiple applications like email, Blooger, etc which may need to select a photo. These applications do not have to write their own photo picker. They just show an "Intent" to pick a photo, and the component which fulfills that intent will be chosen. This binding is done pretty late, so we can actually change the component that fulfills the intent, and then henceforth that component will be used for that intent.

In the next few blog posts I will be embedding more Android videos along with my learnings.

tightvnc with gnome messes up the keyboard mapping

2010-04-30T16:32:00.002+05:30

Everytime I run our unit tests, I get Java Swing windows flying across my screen making it impossible to work. A friend suggested that if I ran the tests in a vncclient session, the windows will be contained within vncviewers window.

So I installed tightvncserver and client on my Ubuntu 9.10 machine. When I started vncviewer I realized that the keyboard mapping as messed up, making it impossible to type anything sensibly in the vnc session.

Some searching seems to suggest that Gnome is causing this problem. This page offered a solution of changing VNC's startup file to not fully start Gnome, and it worked for me.

Workaround: I modified my ~/.vnc/xstartup to be:

#!/bin/sh

xrdb $HOME/.Xresources
gnome-wm &
gnome-panel &
nautilus --no-default-window &
gnome-cups-icon &
gnome-volume-manager &
xterm &

Java Applet on 64 bit Linux

2010-04-27T10:47:00.003+05:30

I have been working on an Ubuntu 9.10 (64 bit system) from some time. I had read some stories of problems running 64 bit Java Applets on 64 bit Firefox, so when I needed to use Applets I did some googling to figure out how to do it.

I came across a couple of posts. Some had different solutions for different versions (3.5, 3.6) of Firefox, and they also wanted me to use IcedTea. The solution I used is outlined here, and it worked perfectly well for me.

Note: You may not have libnpj2.so in the same place mentioned below.

mkdir ~/.mozilla/plugins/
ln -s /usr/lib/jvm/jre1.6.0_12/lib/amd64/libnpjp2.so ~/.mozilla/plugins/

Showing lines before and after a grep match

2010-04-06T22:07:00.007+05:30

Today I ran running grep on the output of hg log, but only to realize that I wanted a couple of lines before and after the line which matched as well.

I am sure this is common knowledge, but I did not know how to do it, so am sharing it in the hope that someone finds it useful.


hg log | grep --before-context=2 --after-context=2 username

Running the above showed me changeset number, comments etc for all the mercurial changesets committed by the specified user.

Some thoughts on redesigning education

2009-10-04T09:55:00.004+05:30

Some time back I read a blog post on redesigning education. It asked some very good questions. Stuff which I had been thinking of myself. I left my thoughts on the blog, but I would also like to start a conversation around these ideas with those who read this blog as well.

I would like to know what other people think of the issue of redesigning (college) education.

I have often thought about how college education can be improved. To answer this question, we first have to ask a very basic question. What is the purpose of education?

To me, we need education for 3 things:

To learn more about the world around us
To lead positive constructive lives
To earn a good living / fulfill our ambitions

I think education has to a large extent evolved to fulfill #3 (with a bias towards earning a comfortable living). The semester system, along with multiple choice tests, and grading, has made our education system into an assembly line. Students are pushed into the assembly line, given classes, administered tests, branded with a grade and pushed out of the assembly line, into the workforce.

Even though this is not the best way to teach, this system has for the most part worked till now. I think there are several reasons.

1. For many of students, getting an education is simply a means to gain employable skills (I do not say this in a negative way).
2. A university has to provide these skills in a time and cost efficient way to the students. It has to provide some branding which will be valuable to students, and make it easy for employers to spot the talent they want to recruit.

In the last few years I have taught programming classes at a local college. In one semester, I tried to move away from the regular grading mechanism. I wanted to focus on deep learning of programming skills, sharing and brainstorming ideas, code reviews, collaborating with the community of practice, etc. However, students still needed to be graded, so I had to come up with a way to fulfill that requirement also. Without going into details I will simply say, in that semester, I put in an effort which was orders of magnitude greater than the regular effort (because I had to fulfill the grading requirement). Students learned a lot in that semester, and I too enjoyed running that course, but towards the end of the semester, I was tremendously stressed out managing the course, and my regular programming work.

So even though the current education system is sub-optimal, I do not think it is because of evil intentions. It is possibly the most practical mechanism that has emerged over time.

However, many things have changed in the past few decades. The shelf life of knowledge has greatly reduced. The Internet has made it possible to share information, and collaborate with people at a distance. Many businesses have started valuing knowledge over degrees (this is at least true in software, and probably in media, advertising, etc as well). The read-write web has made it possible for students to easily create a digital portfolio, and to establish alternate credentials. So all the things a student needs for learning (information, interactions, guidance, review and feedback, and credentials) can be put together in a non traditional way. I stress so much on non traditional because the traditional education system excludes many learners, and this I feel can be changed.

So here is the ideal education system according to me:

A student enters the education system with some goals, and connects with mentors who will help her in fulfilling those goals. These mentors may be traditional teachers who work for a university, or may be employees of an organization, senior practitioners who choose to help on the Internet, friends, family, or people who have retired from the workforce, but would like to share their wisdom and help others.

With the help of mentors, the student defines learning goals, and identifies resources. These resources could be traditional classes, books, or digital material (videos, text, audio...).

With these materials and a micro mentor network, the student begins her learning process. When they have questions, there are a several resources from their mentor network they can turn to. These students may be part of a traditional classroom in some cases, whereas in other cases they may be part of a local or virtual study group. Think of it as being part of an appropriate group for every course they want to take. There are several tools, both real world as well as digital to enable this.

As the student learns, they leave a digital learning trail. One possible way is using blogs, audio recordings, wikis, contributions on forums, and other digital artifacts. So students blog their assignments and problem sets. They participate on Internet forums asking and answering questions. They may create a podcast (or screencasts) of their assignments and presentations. Maybe some students will be able to do practical work which is similar in nature to the assignments and problem sets.

Senior practitioners, traditional teachers, mentors from the community, help the student understand the strengths and weaknesses in their knowledge. The student subsequently fills in the holes by seeking help from their mentor network, and by revisiting those concepts. Community members endorse a students' understanding of their topic of study. Maybe tests still have a place... I don't know...

When a student knows enough, they can enter the workforce. Proof of their knowledge already exists on the Internet. Some organizations may accept them purely based on their digital portfolio and an interview, while others may expect them to take some tests. Students can prepare for these tests, if they wish to work for that organization.

Students however, do not stop their education after getting employed. The process outlined above continues, but perhaps at a slower pace. Thus even after starting work a person continues to accumulate (non credit) credentials. These credentials may either be continuing education certificates from a university or Internet endorsements from the community of practice.

This to me is the ideal educational scenario. But it will not be without problems.

There will always be the issue of credibility of an online portfolio, and endorsements from random mentors. Is there a process using which we can streamline online credentials and validate the credibility???

There will be issues with self-discipline. College gives a certain structure. Doing it by oneself needs a lot of will-power and discipline. One can easily while away time, thinking they are learning something. Maybe the Pomodoro technique can help here.

But I think this scenario is workable. I like it because it allows students to learn at their own pace (without excluding students who do not have resources to attend traditional colleges), from many mentors, thus gaining knowledge and wisdom from many sources. But most importantly, it allows students to take control of their education, and seek out the best, albeit disparate sources for knowledge.

Here's my own humble effort towards contributing towards this goal - http://www.adaptivelearningonline.net

Fixing a mistake after commiting in Git

2009-08-24T22:38:00.003+05:30

So, I ran into an interesting issue while coding today. I made a lot of changes and committed code to my Git repository. Just after committing, I realized that I still had to make some changes to a file and those changes should also have gone in with the previous commit.

Fixing a commit mistake can be done in two ways. Revert the commit, make the changes and then recommit them. This is the preferred way if we have already made the changes public (and thus someone may already have pulled them). However, in my case I am the only one working on this project right now and I had not pushed the changes to GitHub, so I could try the other method.

So here's what I did. I made changes to the file, added it to the index, and committed it thus:


$git commit --amend

Committing code with the --amend switch will cause the index to be committed as part of the previous commit. Git also brings up the editor window, in case we want to change the commit message. This method can also be used to change the commit message without adding any files to the commit.

Reference:

Git documentation on kernel.org

Lack of design patterns in Python

2009-08-23T17:56:00.006+05:30

While searching for PyCon videos, I came across Joe Gregorio's very good video on (lack of) design patterns in Python. I have also added the video timeline along with some notes I made for myself and my takeaway. Enjoy the video.

Timeline:
[00:00] - Start
[00:15] - People pick tools based on a mythology and not necessarily facts
[02:35] - Python isn't just Java without the compiler
[03:34] - Design patterns are also a sign of weakness in a language
[04:06] - Lack of design patterns in Python (proof of lack)
[06:10] - Patterns are built into Python
[07:00] - Strategy pattern in Python the wrong and right way
[07:36] - The strategy pattern is invisible in languages with first-class functions
[08:07] - Some other language features in Python (first class functions, metaprogramming, iterators, closures)
[09:17] - The iterator pattern (iterators) is also built into Python
[09:36] - The observer pattern is also built into Python
[10:17] - Factory method pattern in Python (
[10:34] - Abstract Factory Pattern
[10:40] - Strategy pattern goes away becaise of first class functions
[11:08] - Drawing some useful conslusions
[12:20] - Drawing light on Python from the perspective of patterns
[12:31] - Thread Pool and Concurrency patterns (should we be talking about language features in Python for concurrency patterns???)
[13:49] - Channels (a model for concurrent processes)
[15:12] - PyCSP (implmentation of csp on top of Python)
[18:42] - Conclusions, summary, and questions
[19:17] - end (video goes on for a few more seconds waiting for questions)

Notes:
There are very few references to design patterns in Python mailing lists and discussions around Python... design patterns could be a sign of weakness in a language... patterns are built into Python (hence very little discussion)...strategy pattern is invisible in languages with first class functions...

Takeaway:
If you have to implement a design pattern, first look at language features and try to determine if any can be used instead of the pattern or at least assist in the implementation of the pattern while programming in that language.

Ask yourself if a language feature would make that pattern part of the language itself.

Concurrency patterns are a rich area to look at.

References:

Python isn’t just Java without the compile

Design patterns in dynamic programming

Advanced topics in programming languages: Concurrency and message passing in Newspeak (Rob Pike)

Channels (pdf) C.A.R.Hoare

iAccelerator

2009-08-17T22:32:00.001+05:30

iAccelerator

I took a sabbatical from my consulting work this summer to participate in the iAccelerator program. This is a program for early stage software startups, similar to YCombinator, but the first of it's kind (I believe) in India.

I enjoy teaching programming, I have taught programming classes at a college, done corporate workshops, and more recently have been working on a website for participatory learning. This time I was looking for a different kind of mentoring experience, something which would be free form and fun. After a discussion with Freeman, I decided to go spend the summer at iAccelerator.

In the first few days of the program we had introductions by all the teams where they spoke about their product and vision. This was followed by a session on team building and thinking out of the box, a few legal sessions, sessions on accounting and company law, and several other mentoring sessions. All this is very useful for early stage software stratups, especially when they are founded by techies who are excelent hackers but need some help with legal and business stuff.

iAccelerator had ten very motivated and talented teams. I split my time helping them with technical stuff and working on my participatory learning project.

We worked out of a large hall, converted very tastefully into a working area. Each team had their own space towards the walls, and the centre was furnished with couches, projector, a large whiteboard (where we had presentations and brainstorming sessions) and a wii for fun and entertainment.

Even though everyone had their own work areas, many people chose to work on the couches. Working from the couches was a lot more fun and it gave opportunities for discussions, knowledge exchange, and friendly bantering. The couch culture (as I call this) in retrospect has been a very important part of the cameredierie and the excellent environment we had among us.

A good, positive, and helpful environment is one of the best things in such a program. Whenever anyone was stuck with a problem, or needed help with something new, they would always find someone who had that knowledge and was willing to share it. Everyone had their unique strengths, and collectively we all had a lot of talent which flowed freely. Entrepreneurship is also often a journey of highs and lows. There are times when you feel like your product will take over the world, and then there are times which can be described as not so pleasant. Being in a good environment with friends, means that you are not in this alone. If someone is down he can be sure that his buddies will pull him up.

One team found their first few customers within the group itself, and another team made a kick-ass software for internal communication which had passionate users from day one.

Ever so often we would have mentors, and successful entrepreneurs come talk to us about various things related to business and startups. Many guests spoke about their journey as entrepreneurs, their successes, failures, and lessons learned. Besides these sessions, we were also invited for many talks given by various mentors to the IIM students. This was a benefit of being on the IIM-A campus. Several mentors also worked one on one with the teams to help them with their vision and business plans.

Since we all had technical skills, internally we did several TechTalks on topics such as security, Amazon EC2 & cloud computing, designing with GIMP, JQuery, version control with SVN and Git, and many more. Sometimes we played tech videos from the Internet and had discussions around them. These sessions were a lot of fun and we all learned from them.

Since Freeman has successfully created and exited a startup in the past, he had many insights about how to run a startup. He shared his knowledge and insights with everyone, helping with business plans, vision, fund raising pitches, and many other nitty gritties of creating startups.

However, it was not just work all the time. We had a great time watching MTV while eating breakfast in the college mess. I can now tell you that watching MTV is far better than reading the morning newspaper. We played ping pong (Freeman and me had some really fun and intense ping pong sessions) ... we played cricket... on weekends we watched movies on the office projector. We also had a lot of diverse talent in the group. Jeevan Ram rocked everyone with his dancing and Ghazal made us laugh with his mimicry.

It's amazing how well we all got to know each other in just a few months. Thinking back, this was the best time I have had after graduating. Most importantly, I cannot stress enough the fact that I made really good friends, and I am very grateful for the wonderful time we all spent together.

This year's iA program will end in a few weeks. I wish all the teams lot of success and good luck.

Custom JSON Encoder in Django

2009-08-07T22:00:00.002+05:30

I have been messing around with how to display date formats (in questions and answers) for my web based learning site from the past couple days. After trying various things, I settled for what seems to be a web 2.0 standard for displaying dates - displaying dates as '2 days 4 hours ago' instead of the actual date and time '4th August, 2009 5:50 PM'. I like this because I do not have to deal with any browser localization issues. Everything is a delta between the UTC time a question was asked and the current UTC time (btw if you are working with datetime in Python, do read this blog post).

In my Django based application, I use JQuery to get questions and answers for forums on every topic page. The application sends back JSON to the Javascript functions which display the questions and answers from the JSON objects.

The DjangoJSONEncoder (scroll to the end of this module) provided by Django serializes dates in a specific format. I wanted to change this so that a date would be serialized as '2 days ago'.

A bit of Googling bought me to Jessy's very nice blog post, which explained very nicely how to create a custom Encoder to be used for serializing objects in Python. This seemed like a good idea, so I wrote my custom encoder to change the way dates are displayed;


class Web20DatesEncoder(DjangoJSONEncoder):
  SECONDS_IN_HR = 60 * 60
  SECONDS_IN_MIN = 60
  def default(self, object):
    if isinstance(object, datetime.datetime):
      delta = datetime.datetime.now() - object
      return self.get_delta_as_string(delta)
    else:
      return super(Web20DatesEncoder, self).default(object)

  def get_delta_as_string(self, delta):
    days = delta.days
    seconds = delta.seconds
    hours = 0
    minutes = 0
    hours = seconds / self.SECONDS_IN_HR
    seconds = seconds % self.SECONDS_IN_HR
    minutes = seconds / self.SECONDS_IN_MIN
    seconds = seconds % self.SECONDS_IN_MIN
    delta_str = ''
    if days > 0:
      delta_str += str(days) + ' days, '
    if hours > 0:
      delta_str += str(hours) + ' hours, '
    if days <= 0 and seconds > 0:
      delta_str += str(seconds) + ' secs, '
    return delta_str

However, I could not figure out how to hook this class into the call chain so that it is used when my QuerySet is serialized as such;


res = serializers.serialize(”json”, questions)

One solution which came up was to use the 'cls' parameter in the call to serialize.


res = serializers.serialize(”json”, questions, cls=Web20DatesEncoder)

However, when I ran my code, there was an error:


dump() got multiple values for keyword argument ‘cls’

Why do we get this error? Maybe (I still do understand Python well enough to be sure) because, the end_serialization method in django.core.Serializers.json.Serializer has the following line:


simplejson.dump(self.objects, self.stream, cls=DjangoJSONEncoder, **self.options)

As you can see it specifically passes cls=DjangoJSONEncoder to simplejson.dump(...), and this is the reason why we get the above error message.

Now I do not know what is the right way to resolve this issue, but here's how I did it. I created a subclass of JSONSerializer, such that my subclass used my custom encoder.


from django.core.serializers.json import Serializer as JSONSerializer

class DateModifyingJSONSerializer(JSONSerializer):
  def end_serialization(self):
    self.options.pop('stream', None)
    self.options.pop('fields', None)
    simplejson.dump(self.objects, self.stream, cls=Web20DatesEncoder, **self.options)

and the client code which earlier instantiated JSONSerializer now uses DateModifyingJSONSerializer.


#Here is the code snippet which uses the above class
json_serializer = DateModifyingJSONSerializer()
res = json_serializer.serialize(query_set)

#instead of old code shown below
#serializers.get_serializer("json")()
#res = json_serializer.serialize(query_set)

I hope you find this solution useful. Please leave a comment if it helped you, or if you know a better way to perform this task.

Git supports commiting specific parts of a file

2009-07-23T15:38:00.004+05:30

While working on my web based learning project, I made a lot of changes to a Django view file without committing them. When I actually decided to commit, I realized that the changes in my view file should go into separate commits. I knew it was possible to commit parts of a file in Git, but I was not sure exactly how it could be done.

I asked the question on StackOverflow and got an answer within minutes :-)

Anyways here's how I did it. I had 3 files in my index:


urls.py
app/courses/templates/course/show.html
app/courses/view.py

The first 2 files were fine, but I did not want to commit the entire view file with the first two, I wanted only one change in that file to go in this commit.

Since I had already added the view file to the index, I first had to unstage it with:


git reset app/courses/view.py

Then I did an interactive add to add only one hunk from the view file:


git add --patch apps/courses/view.py

Running this command showed me the first hunk from the file and an option asking me if I wanted ti stage that hunk. I decided I did not want the first hunk, then it showed me the second hunk. This was the change I wanted, so I entered 'y' at the option and proceeded to enter 'n' for all the remaining hunks.

After this I wanted to ensure that the right hunk from the file was staged to be committed, so I typed:


git diff --color --cached apps/courses/view.py

This showed me all the changed that were staged. After ensuring that the changes I wanted were the ones staged, I commited them with:


git commit

JQuery selectors and future elements

2009-07-11T14:33:00.008+05:30

I am using JQuery for the AJAX and dynamic aspects of my web based learning platform.

I like the fact that JQuery allows us to use CSS type selectors to select elements on the page to either manipulate them, add event handlers, or a host of other things.

So, the code below intercepts clicks on all links and dynamically adds a new link when a link is clicked.


<html>

<head>

<link rel="stylesheet" type="text/css" href="/site-media/al/style.css" />

<script type="text/javascript" src="./jquery-1.3.2.min.js"></script>

</head>

<body>

  <script type="text/javascript">

    $(document).ready(function() {

      $("a").click(function() {

        $("ul#questions").append("<li><a href='#'>click me</a></li>");

});

});

</script>

<div>

    <ul id="questions">

      <li><a href="#">Click Me: 0</a></li>

    </ul>

  </div>

    <textarea style="Width: 400px; Height: 200px" name="textarea" cols=20>
<head>

There is a problem with this code. Everytime you click on the link called "Click Me: 0" a new link is added, but if you click on the new link, then nothing happens. So, why does JQuery not work with dynamically added elements?

The reason is because the following call


$("a").click(function() {
//...
});

only binds to the anchor elements present on the webpage when the $(document).ready() function is called. It will not bind to future elements. To bind to future elements as well, we have to use the live() function.

Try using this code to bind to the "a" elements and it will work.


$("a").live("click", function() {
 $("div#questions").append("click me");
});

Refreshing iptables

2009-07-02T17:46:00.003+05:30

The last time I played around with IPTables was about 6 - 7 years back. I have been working with a Linux box again from the last few months and I am absolutely thrilled about it. Nevertheless, I have also been meaning to set up a simple IPTables firewall on my machine.

Since I had forgotten all my IPTables concepts, I decided to hunt the Internet for some good articles. I found some really nice resources to refresh my memory as well as learn new things.

Here is a nice 3 part video series from Linux Journal.

The entire series takes less than a half hour and is a good refresher or introduction to IPTables.

Here is a nice picture which explains how a packet is routed through various chains in the ip tables. If you are looking for a quick refresher, this might help you out.

If you want more details, here is a tutorial, and yet another tutorial, and Netfilter's excellent documentation on IPTables.

So now there is no excuse for not setting up a little firewall on your Linux box.

Inheritance vs. composition depending on how much is same and how much differs

2009-06-22T22:46:00.002+05:30

I am reading the excellent Django book right now. In the 4th chapter on Django templates, there is an example of includes and inheritance in Django templates.

Without going into details about Django templates, the include is very similar to composition where we can include the text of another template for evaluation. Inheritance in Django templates works in a way similar to object inheritance. Django templates can specify certain blocks which can be redefined in subtemplates. The subtemplates use the rest of the parent template as is.

Now we have all learned that inheritance is used when we have a is-a relationship between classes, and composition is used when we have a contains-a relationship. This is absolutely right, but while reading about Django templates, I just realized another pattern in these relationships. This is really simple and perhaps many of you may have already have had this insight...

We use inheritance when we want to allow reuse of the bulk of one object in other objects such that it can change a few things as per it's requirements. So in a way we have a template which we want to allow reuse of in the greater part and modification of in the smaller part. On the other hand we use composition when we want to reuse another object in this object. So we have a template in which we want to plug some holes in functionality.

Does this make sense?

Slashy strings in Groovy

2009-06-15T15:49:00.005+05:30

Groovy has done a great job of enhancing Java Strings. It offers a lot of features like String interpolation with GStrings, triple quoted Strings, multi-line Strings, and slashy Strings.

In this post I will talk about slashy Strings in Groovy. But before doing that let us see how we represent a regular expression in Java. Let's say I have a list of fully qualified file names and I want to match all files in my 'c:\tmp' directory.

I would create a String to represent my regex in Java like this:
String exp = "C:\\\\tmp\\\\.*"

The four '\' are needed because '\' is a meta character in regular expressions, so we need to represent a '\' as a '\\'. Because a '\' is used for escaping special characters in Java, we need to represent '\\' as '\\\\'. Wow doesn't this look cumbersome. Well, this is not just one case. Regular expressions make use of the '\' character for special classes. Everytime we want to use a '\w' or a '\d' or something like that we will have to use '\\w' and '\\d' instead.

Slashy Strings in Groovy give us a way around this by allowing us to represent regular expressions just like they would be represented without having to escape the '\' in Java.

Using them we can write

def file = /C:\\tmp\\.*/

Notice that slashy Strings have to be surrounded by forward slashes, and are mostly used when Strings need to represent regular expressions.

Testing Groovy domain classes

2009-05-30T23:09:00.005+05:30

If you are trying to test Grails domain class constraints by putting your unit test cases in the 'test/unit' directory, then your tests will fail because the domain objects will not have the 'valdate' method. This can be resolved in two ways:

Place the test cases inside test/integration (which will slow things down)
Use the method 'mockForConstraintsTests(Trail)' to create mock method in your domain class and continue writing your test cases in 'test/unit'

What follows is some example code around this finding.

I am working on a Groovy on Grails project for a website to help programmers keep up and refresh their skills.

I started with some domain classes and then moved on to write some unit tests. When we create a Grails project using

grails create-app

,
it creates several directories, one of which is a directory called 'test' for holding unit tests. This directory contains two directories, 'unit', and 'integration' for unit and integration tests respectively.

Now begins an interesting journey with writing unit tests in Groovy. I wanted to write tests for my domain classes. A simple domain class like the one I have below can contain only properties and constraints for those properties. This is what Trail.groovy looks like.


class Trail {
 String shortName
 String name
 String description

 def hasMany = [learningObjects:LearningObject]

 static constraints = {
   shortName(maxSize:6, blank:false)
   name(maxSize:75, blank:false)
   description(maxSize:2048, blank:false)
 }
}

I wanted to start writing unit tests to test the constraints. When Grails creates a domain class, it injects several methods in it at runtime , one of which is a method called 'validate'. This method is called before the domain object is saved and it will return a false if the domain object has violated any constraints. So, I created a simple unit test to test the constraints of Trail.groovy

This is what my initial test case looked like.


import grails.test.*

class TrailTests extends GrailsUnitTestCase {

  def trail

  protected void setUp() {
    super.setUp()
    trail = new Trail(shortName:'sname',
                            name:'Java 101',
                            description:'This is a basic Java course')
  }

  protected void tearDown() {
    super.tearDown()
  }

  void testShortNameConstraints() {
    assertTrue(trail.validate())
    trail.shortName = 'thisisaverylongname'
    assertFalse(trail.validate())
    trail.shortName = ''
    assertFalse(trail.validate())
  }
 
  //... further methods not shown
}

When I ran my tests using

grails test-app

(See how well Grails integrated testing), I got a bunch of errors that told me that the 'validate' method was not found. If you enjoy looking at stack traces... feast your eyes:

Testcase: testShortNameConstraints took 0.159 sec
 Caused an ERROR
No signature of method: Trail.validate() is applicable for argument types: () values: []
groovy.lang.MissingMethodException: No signature of method: Trail.validate() is applicable for argument types: () values: []
 at TrailTests.testShortNameConstraints(TrailTests.groovy:20)
 at _GrailsTest_groovy$_run_closure4.doCall(_GrailsTest_groovy:203)
 at _GrailsTest_groovy$_run_closure4.call(_GrailsTest_groovy)
 at _GrailsTest_groovy$_run_closure2.doCall(_GrailsTest_groovy:147)
 at _GrailsTest_groovy$_run_closure1_closure19.doCall(_GrailsTest_groovy:113)
 at _GrailsTest_groovy$_run_closure1.doCall(_GrailsTest_groovy:96)
 at TestApp$_run_closure1.doCall(TestApp.groovy:66)
 at gant.Gant$_dispatch_closure4.doCall(Gant.groovy:324)
 at gant.Gant$_dispatch_closure6.doCall(Gant.groovy:334)
 at gant.Gant$_dispatch_closure6.doCall(Gant.groovy)
 at gant.Gant.withBuildListeners(Gant.groovy:344)
 at gant.Gant.this$2$withBuildListeners(Gant.groovy)
 at gant.Gant$this$2$withBuildListeners.callCurrent(Unknown Source)
 at gant.Gant.dispatch(Gant.groovy:334)
 at gant.Gant.this$2$dispatch(Gant.groovy)
 at gant.Gant.invokeMethod(Gant.groovy)
 at gant.Gant.processTargets(Gant.groovy:495)
 at gant.Gant.processTargets(Gant.groovy:480)

After some Googling I realized that the 'validate' method is injected into domain objects by the Grails framework, and therefore it does not exist when we instantiate the domain object from test code. I later found that if a test is placed inside 'test/integration' then the test cases are created as the objects would have been created by the Grails framework. So the domain objects would have the 'validate' method. But I also read in another place (I cannot remember where), that if possible it is k better to mock these special methods instead of putting tests in the integration directory, since these tests take longer to instantiate and can slow down the overral running time. And I found in yet another place that there exists a method called 'mockForConstraintsTests(Trail)' which will inject the 'validate' method along with some other methods. So, I added this mock method to my setup after which I was able to run my tests successfully.


  protected void setUp() {
    super.setUp()
    mockForConstraintsTests(Trail)
    trail = new Trail(shortName:'sname',
                            name:'Java 101',
                            description:'This is a basic Java course')
  }

The rest of the class is the same.

So to summarize, if you are trying to test constraints in Grails domain classes, you have two options:

Place the test cases inside test/integration (which will slow things down)
Use the method 'mockForConstraintsTests(Trail)' to create mock method in your domain class and continue writing your test cases in 'test/unit'

I will post more such episodes of how Google helped me resolve issues I faced while developing :-)