It seems that the Zen of Multiplexing is repeating itself in all aspects of science. A few weeks ago my friend Kostas told me about the properties of C#. He found this feature very handy and usefull.

My opinion is that this feature offers nothing new (i saw properties in Delphi (Object Pascal) a long time ago i think :)), and in addition they obstructing good architectural design. Why is that?

Before OOP we were using structures, at least in most mainstream languages (at this point i will create an imaginary Java to provide my examples). For example, our code looked like:

public class Foo {
   public int fooInteger;
   public char fooCharacter;
}

We could access the content of our struct (class) Foo, directly with statements like foo.fooInteger (where foo is allocated space for the struct). We had a problem with that. The problem was that we wanted to access the fooCharacter in many cases, doing something before or after that. And we created functions with references:

public static char getFooCharacter(Foo foo) {
   foo.fooInteger++;
   return fooCharacter;
}

Our problem still was that the context (our data) was separated from our accessors, and if we wanted our sophisticated programming interface to prohibit unwanted access ... the situtation was more difficult.

Then OOP came, no access to the context with visibility (public, private etc.), and in addition each struct was bind with the associated code. No reference passing! Hooray!

public class Foo {
   public int fooInteger;
   public char fooCharacter;

   public static char getFooCharacter() {
      fooInteger++;

      return fooCharacter;
   }
}

It was cool, and we were very happy about it. Then something twisted happened! We decided that we liked member access, and we liked also OOP. So, we invented properties, and we end-up write something like that:

public class Foo {
   property char fooCharacter;

   setter fooCharacter {
      _fooCharacter = fooCharacter;
   }

   getter fooCharacter {
      fooCharacter = getFooCharacter();
   }

   private int _fooInteger;
   private char _fooCharacter;

   private static char getFooCharacter() {
      _fooInteger++;

      return _fooCharacter;
   }
}

Remember that this syntax is imaginary. It exists only for the sake of this example. What we have done here? Simple, we create a property that is public and we access it the old way (new Foo()).fooCharacter = 1. We say that if you want to set it, use the _fooCharacter field. To get it, call getFooCharacter() method.

My objection is ... what does this feature serve? Is this so much problem to just write the setter/getter method, instead of filling our programs with dead code?