The question is in
the title. I want to have my thinking verified by experienced people. You can add more or disregard my opinion, but give me a reason.
Here is an example requirement: Suppose you are required to implement a fighting game. Initially,
the game only includes fighters, who can attack each other. Each fighter can punch, kick or block incoming attacks. Fighters can have various fighting styles: Karate, Judo, Kung Fu... That's it for
the simple universe of
the game. In an OO like Java, it can be implemented similar to this way:
abstract class Fighter {
int hp, attack;
void punch(Fighter otherFighter);
void kick(Fighter otherFighter);
void block(Figther otherFighter);
};
class KarateFighter extends Fighter { //...implementation...};
class JudoFighter extends Fighter { //...implementation... };
class KungFuFighter extends Fighter { //...implementation ... };
This is fine if
the game stays like this forever. But, somehow
the game designers decide to change
the theme of
the game: instead of a simple fighting game,
the game evolves to become a RPG, in which characters can not only fight but perform other activities, i.e.
the character can be a priest, an accountant, a scientist etc... At this point, to make it more generic, we have to change
the structure of our original design: Fighter is not used to refer to a person anymore; it refers to a profession.
The specialized classes of Fighter (KaraterFighter, JudoFighter, KungFuFighter) . Now we have to create a generic class named Person. However, to adapt this change, I have to change
the method signatures of
the original operations:
class Person {
int hp, attack;
List<Profession> skillSet;
};
abstract class Profession {};
class Fighter extends Profession {
void punch(Person otherFighter);
void kick(Person otherFighter);
void block(Person otherFighter);
};
class KarateFighter extends Fighter { //...implementation...};
class JudoFighter extends Fighter { //...implementation... };
class KungFuFighter extends Fighter { //...implementation ... };
class Accountant extends Profession {
void calculateTax(Person p) { //...implementation...};
void calculateTax(Company c) { //...implementation...};
};
//... more professions...
Here are
the problems:
To adapt to
the method changes, I have to fix
the places where
the changed methods are called (refactoring).
Every time a new requirement is introduced,
the current structural design has to be broken to adapt
the changes. This leads to
the first problem.
Rigid structure makes it hard for code reuse. A function can only accept
the predefined types, but it cannot accept future unknown types. A written function is bound to its current universe and has no way to accommodate to
the new types, without modifications or rewrite from scratch. I see Java has a lot of deprecated methods.
OO is an extreme case because it has inheritance to add up
the complexity, but in general for statically typed language, types are very strict.
In contrast, a dynamic language can handle
the above case as follow:
;;fighter1 punch fighter2
(defun perform-punch (fighter1 fighter2) ...implementation... )
;;fighter1 kick fighter2
(defun perform-kick (fighter1 fighter2) ...implementation... )
;;fighter1 blocks attacks from fighter2
(defun perform-block (fighter1 fighter2) ...implementation... )
fighter1 and fighter2 can be anything as long as it has
the required data for calculation; or methods (duck typing). You don't have to change from
the type Fighter to Person. In
the case of Lisp, because Lisp only has a single data structure: list, it's even easier to adapt to changes. However, other dynamic languages can have similar behaviors as well.
I work primarily with static languages (mainly C and Java, but working with Java was a long time ago). I started learning Lisp and some other dynamic languages this year. I can see how it helps improving my productivity.
