OO and Agile

Let´s talk about business! today we are going to talk how the object oriented give a step in the agile metodology les´s rock boys!

Agile and OO are intimately connected, and good OO structure is essential if you want true agility.

There are two main camps when it comes to defining OO: structural (if it uses polymorphism and inheritance, it’s object oriented) and architectural (OO systems are models of real or imaginary things and of the way that these things interact as they perform some useful activity). I fall firmly in the second camp; structure is an important implementation detail, but doesn’t affect the object-oriented nature of the system one iota. I’ve even programmed what I think of as object-oriented systems in assembly language, with nary a class definition or virtual method in sight.

The objections to OO come largely from people so entrenched in the first camp that they don’t know that the second camp exists. For example, they say that Java is too complicated and wordy — which is certainly true — therefore OO is bad — which is not. They say that Java is too hard to deploy — also true — therefore OO is bad. They say that design patterns can add too much complexity to what should be a simple system — again, true, but that’s a good-versus-bad design argument, not a critique of OO. They say that it’s sometimes best to program with functional-programming techniques instead of inheritance — also true, but functional programming in no way renders the system less object oriented.

The real issue is the benefit of a model-driven approach, whether or not you call that approach OO. I’ve better things to do with my time than argue semantics.

The fact is that, if you don’t take a model-driven OO approach to architecture and also leverage some of the natural consequences of that approach (such as hard-core data abstraction), you will fail at Agile (or at minimum, waste an awful lot of time). The constant change that all Agile processes mandate puts too much stress on the code to leave room for sloppiness; and a model-driven approach to design meshes nicely with Agile’s focus on stories. The structure of the code just falls out of the stories, with little or no work.

Similarities Between Agile Development and Object-Oriented Programming

Agile Development and Object-Oriented Programming share many similarities as trends in the software community.

The first aspects of Object-Oriented Programming originated in the 1960’s with Simula. Smalltalk carried it forward into the 70’s and 80’s. It finally crossed the chasm and hit the mainstream in the early 90’s. C++ and Java helped greatly in driving its adoption.

Object-Oriented Programming and the principles it promotes make a big difference in creating large scale, maintainable code. It allows developers to design and write code in more productive ways than were possible with procedural languages.

Agile Development as a trend is about a decade behind Object-Oriented Programming. According to Wikipedia, adaptive software approaches were described in a paper as early as 1974. Scrum got started in the mid 80’s. XP and several other Agile variants were used in the 90’s. But it all sort of came together in 2001 when the Agile manifesto was written.

Agile Development attacks things at a higher level than object-oriented: our processes and approach. Its principles can greatly improve the productivity of a development team. As it has evolved, we’ve learned that it can also help in creating highly productive large scale teams (see this article for an example).

Both trends have/had their conferences where practitioners can get together to share / improve on usage. Object-Oriented Programming and Object Expo and OOPSLA (still going today). Agile Development and its own Agile Conference 

became a pro one!

References:

http://www.drdobbs.com/architecture-and-design/oo-as-a-prerequisite-to-agile/240164883

Credits at the Outstanding image

Marcelo Fernandez

Image from pexels