This is the first time I am working on a serious agile project and obviously my life has changed for the better to -

1. Wearing jeans / t-shirts (on all days) versus just Fridays
2. Shared check outs (Subversion) versus Exclusive check outs (TFS, VSS)
3. Running ALL NUnit tests multiple times a day versus writing MSTests once (and running very infrequently)
4. Using Spring.Net, NHibernate, MassTransit, NUnit, Moq versus no Open Source
5. Each team member discussing (in an iteration meeting) how much functionality to attempt in an iteration versus the management telling me how much to write in a certain time frame
6. Use of Resharper by every member of the team versus just one
7. Using TeamCity for CI (which obviously runs all unit tests before the build) versus none

Needless to say that there is little or no value in the items on the right and I absolutely hate them. But sadly, most companies think, practice and follow the items on the right.

May there be many more companies who follow Agile development. AMEN !!!

Btw, if you haven’t yet read the Manifesto for Agile software development, please do yourself a favour and go read it. One doesn’t have to be a genious to realize that Indian companies follow the above manifesto backwards

(Note: With whatever little knowledge I have of Agile development, I believe writing unit tests and having CI are the bare minimum requirements to follow it).

It’s stunningly surprising how, sometimes, someone describes something which mirrors some of our past experiences. This “Just a Bunch of Web Services” post accurately describes my experience in one of my previous projects. It also accurately describes what the (software) vendors gain, by trying to popularize some technology (like SOA) on the basis of how easy their tools (IDEs) make it to produce, only at the expense of businesses that fall into the trap.

I saw the first implementation of (Asp.Net) web services as merely a wrapper over traditional Ado.Net data access layer I’ve also seen an approach (in a typical big financial enterprise) where every communication has to happen through web services ???

One might not even realize the simplicity of RESTful web services until one has to climb the steep learning curve of technologies like WCF, where implementing a service is damn easy but everything else (configuration etc.) is a forgettable story. And though I am not sure, but my conclusion is that WCF must’ve been used more in remoting (TCP / IP endpoint in WCF) scenarios than the web (HTTP endpoint in WCF) based scenarios. Of course, YEMV (your experience might vary). So have you seen this JBOWS architecture?

Till date, I’ve worked on programming languages which were not open source and were a property of some company (Microsoft, in my case – VB 6 and C#). However these days I’ve heard a lot that how important it is for a programming language to be open sourced. If you think deeply, you too might realize that there are a few advantages which cannot be had in a closed source language, e.g. -

1) How many languages can boast of being backward incompatible? Python 3 is one of them.

2) One could start using a newer version of the language whenever one felt comfortable. The choice of which version of the language to use, would not be tied to the use of a particular (newer) version of the IDE. Yes, I am talking of C# and Visual Studio. [ I understand MS wants to make money, and decision makers who, many times are non-techies, are never in a hurry to upgrade to the newer version of the IDE and therefore the language, forcing us poor developers to write delegates even though lambdas are available Most people would've switched to a newer compiler if the older IDE could support it. ]

3) One could vote for what features to be included. Yes, the decision might still rest with some committee of core developers of the language, but one would’ve had some say. Amazingly, I don’t understand why Java 7 won’t have closures.

So choose your language (and the platform) wisely, else you might have to code in C# 2.0 in the days of C# 4.0 (i.e. keep using VS 2005 in 2010)

You might have read in the Alt.Net circles that the tools (like IoC, ORM etc.) aren’t as important as the techniques (SRP, separation of concerns, persistence ignorance etc.). To be frank, those guys (Ayende, Jeremy Miller etc.) are trying to save themselves from stupid arguments like “so you mean to say, if someone doesn’t use IoC, ORM etc. he’s a bad programmer”?

The fact of the matter is that it’s highly unlikely to find someone who is aware of the techniques, but haven’t used (or at least heard of) the tools. The reason is that there’s a symbiotic relationship between the tools and the techniques – sometimes the techniques lead you to the tools and sometimes the tools lead you to the techniques e.g. I became aware of persistence ignorance after reading the Hibernate book; I became aware of the term separation of concerns after encountering Castle Monorail and Windsor and reading about IoC.

So if you’ve never used an IoC container or an ORM tool, you won’t realize what you are missing until you give them a try. Not only you’ll learn the techniques, you’ll learn something more than plain Ado.Net or plain old singletons

I was thinking Lisp might be the best language yet, but this article, has left me wondering. Still, I have to keep myself at learning Lisp and eventually Clojure

Work is something you do,
not some place you go.

Teleworking = Performance not presence.

An Intel advertisement [seen in a DC metro train]

I wish and pray, this becomes a reality soon.  Btw, if you haven’t read Paul Graham’s other essays, do check them out, he’s an absolute genius and I can’t do anything but agree to what he has to say, most of the times.

It seems this phenomena is not limited just to India, but to some other advanced countries as well. This is not to suggest that the standard of all the colleges has deteriorated, but very few of them are exceptions. Have a look at this article by Dr. Mark Tarver or the very famous The Perils of Java schools by Joel Spolsky, if you don’t believe me.

If we talk about India, the paradox is that if there are not enough colleges offering advanced courses like engineering or management, so many good guys will be devoid of a degree. On the other hand, the mushrooming of private colleges has given rise to dilution in quality of those degrees. So even though a student might have an engineering or a management degree, he might not necessarily, get a lucrative job, or sometimes even a mediocre job. Most of the times, people from such colleges end up being underpaid and doing jobs which might not even require those degrees – a term which is called underemployment.

But since, underemployment is better than unemployment, I believe, the governments let this continue, because it is in their favor too. The colleges are definitely the biggest beneficiaries, because without providing quality education or campus placements, they can charge hefty fees from the students – “debt and degree inflation” as per Dr. Tarver.

The only way to avoid this vicious cycle is well, the time tested way – study hard in the school, so that you are able to get into one of the good colleges. Well, some rules don’t change ever

This is a very nice article which emphasizes the importance of formal learning as well as hardening that learning in the field i.e. becoming a street fighter. It clearly states that the combination of the two will surpass either. Go read it.

Let us consider this code -

public class MathUtil {

	public static Func<int> MakeIncrementer() {
		int n = 0;

		Func<int> incr = () => ++n;
		return incr;
	}
}

Given the above code, what do you think should be the output of the below program -

public class Program {

	static void Main(string[] args) {

		Func incr = MathUtil.MakeIncrementer();
		Func incr1 = MathUtil.MakeIncrementer();

		Console.WriteLine(incr());
		Console.WriteLine(incr());
		Console.WriteLine(incr());

		Console.WriteLine(incr1());
		Console.WriteLine(incr1());
		Console.WriteLine(incr1());
	}
}

Well, if your answer is -

1
2
3
1
2
3

then great, you already know what closures are and don’t need to read any further.

For those of you who don’t – Closures are a block of code with bindings to the environment they come from. Please read this post from Martin Fowler for more details. Also read an excellent article on Functional Programming by Slava. What does bindings and environment mean? In our case, the incr() function, inside the MakeIncrementer function has access (is bound) to the variable n, which is outside the scope (i.e. the environemnt) of the incr() function body.

The most important observations are -

1) That local variables are no longer limited to simple scope rules and have an undefined lifetime.
2) The obvious conclusion is that they’re no longer stored on the stack – they must be stored on the heap instead.

Slava writes this in his article – “Closures bring functional and OO worlds closer together. Every time you create a class that holds some state and pass it to somewhere else, think of closures. A closure is just an object that creates “member variables” on the fly by grabbing them from the scope, so you don’t have to!“

And as my friend, Raj mentioned that Java had the notion of inner classes since long back, and they have similar characteristics, I believe closures (implemented with functions) are much less overhead, at least the syntactical part.

Do you still think that local variables are local and stored on the stack