About Gregor Riegler

Gregor is a passionate software engineer and RESTafarian who loves to continuously improve. He is interested in modern web development, oo-design and extreme programming. He is also serious about clean code and TDD.

Are you really Agile?

From what i have seen, Agile Software Development is widely misinterpreted nowadays. Many people think to be agile, they just need a process like scrum to define a framework of sprints and iterations. They will sprint until they exhaust and change until they stagnate. But when you’d ask them what principles of objectoriented design are, they’d answer: “Aww yes, we use classes”. And when you’d asked them if they did test driven development, they’d reply: “Ahh, this is the thing where you write tests first, isn’t it?”. Bottom line, people think to be agile without caring about good software design. But in the end, the most important thing is what nobody cares about. It is the agility of the software that they are producing. So if you want to be agile, a process and a mindset is not enough. You need to keep your software agile. By that i mean, you need to keep the design of the software as clean and flexible as possible, to be able to apply any future changes at minimal cost. Software design of course includes your source code. In the end, you are only as agile as your software is.

Why Agile?

A customer does not know what he wants in the first place. He might have a rough idea, but thats it. We cant even blame him for that, because the actual problem that we are supposed to solve is influenced by so many factors and opinions that it is almost impossible to define the best solution right away. Other than that, miscommunication will most likely make things worse. To solve these issues we start small, and deliver fast. Seeing the first result, the customer can verify if we are on track or not. He can check if we have understood, or if he himself made a bad call. He might recognize things that he hasnt thought of before. Delivering repeatedly and iteratively like that, our software will more likely be useful and accepted by the customer in the end. It will more likely lead our project to success. Of course we will have to deal with changes more often, which is why we have to make the software itself agile. In the end it is the software which needs to be changeable, not us.

What it takes

Not only does an agile development process put our software under frequent change, it also demands progress at a fast and steady pace. These facts can quickly cause our software to rot if we don’t watch out. And when it does, we get slowed down even more and changes suddenly become impossible. So we’d better not forget about the most important part in agile software development: Keeping our software design as agile as possible, from high-level architecture to the very code itself. Sadly, this gets ignored way too often, and many agile projects fail because of it. They fail because they chose to go faster by neglecting quality, and they quickly rush into a deadend of code rot leading to stagnation. So please remember: It is the Software you are building that needs to be agile in order to adapt to change defined by the customer. It is the software that needs to be agile in order to react to change with minimal effort. Rushing is not gonna make your software agile. Rushing is not gonna make YOU agile. Agility comes hand in hand with quality. And high quality is not even slow, hell no. Good quality done right makes you go even faster.

So what is Agile Software Design?

Agile Software Design is what makes your software as clean and flexible as you need it to be. It demands deliberate adoption of discovered and well established design patterns and principles of objectoriented programming. This is not easy. In fact it’s hard, it’s very hard. Even if you are really good and experienced at it, you might fail at some point, having to rethink many of your previous design decisions. Agile Software Design is not something that you can rush. It needs time and deliberateness. But it will pay off in the long term by making you progress at a more constant pace, which will in fact be much faster than it would be without agile design. The graphic below should clarify how quick ignorant rushing can slow you down tremendously. The graphic is not based on statistics, but on experience.

Agile Software Design does not end at high-level architecture. It goes on with coding. Bad code can quickly make your project more clumsy than a bad high-level design could. So the devil is in the details.

What can you do to make your Software Design more Agile?

From a developers perspective? First of all, learn the principles and patterns of objectoriented programming – not just in theory. Being good at those needs lots of practice. There are plenty of books for this:

Keep your code clean – don’t underestimate this! When you are programming, you spend more time reading code, than writing code. Thus you want to minimize the time you have to read code by making it more readable. It’s not a secret how clean code looks like. Take a look at Clean Code.

Other than that, use the right practices like

Test Driven Development

Just do it already. And if you don’t know how, go on and start learning. I have heard numerous opinions of TDD where people said

But these are just subjective opinions of people who are not experienced in TDD.

TDD should in fact boost your longterm development speed if you are doing it right. I have not seen a single project in my life that has been as small and simple as that it would not have taken a significant profit from a TDD approach. And i have in fact seen very simple ones. The thing is, you have to test it anyways. What else would speed up your testing more than to automate it? Also, TDD significantly reduces the amount of time you have to spend debugging which already eats up lots of your time – at least more than you’d think. Other than that those tests

become a reliable documentation of your code,

allow you to fearlessly clean up your code,

force you to think of the problem before thinking of the actual solution, which will improve your initial draft,

enforce decoupling of components, which will make your design more agile.

Pair Programming

It’s not only that 4 eyes will see more defects than 2 eyes do, but also that the transfer of knowledge is taking place. You want all developers to learn from each other to become equally valuable. And you always want more than one person to know a specific module to improve the truck factor. Heck yeah, some people even do mobprogramming – Seriously.

Collective Code Ownership

Don’t allow one guy to own that modules code. All code on the project must belong to everybody. Everyone is allowed and invited to view, question and improve everyones code. This might be hard for some people, and might provoke conflicts, but it is absolutely mandatory to make the code better.

Code Reviews

Constantly review code changes. It is the only way to stay up to date, and it will reveal code smell. You need to reveal code smell, because if you don’t, you will get stuck.

Refactoring

Refactor often. Everytime you see something that could be refactored, you need to do it right on the spot. The earlier you do it, the more time you save. So if you do it right then, you save the most possible amount of time.

tl;dr: You are only as agile as your software design, which of course includes code. High speed does not demand low quality. It doesn’t work like that. In fact high quality is needed to allow high speed. Agile design evolves high quality.

4. Java Annotations Tutorial3>

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

3 comments

Nice sentiment, but… I have been fighting the “I don’t have time to write unit tests. I need to functional test my code” sentiment among developers for years. If you go to professional meetings, presentation after presentation focuses on APIs and tools. Universities don’t teach programming *skills* and many developers don’t learn them – they learn persistence. So many of them are still not using unit tests, and think refactoring means editing code to add functionality.

The first key to agile is going to be focus on process change.

I have found a lot of success in getting developers to learn, but only when we were co-located and I could demonstrate the value in person. Doing it in a remote setting is a lot harder, and even harder when management isn’t prodding change.

1. Architecture is a static slow moving background to other processes. I think it is not really suitable for Agile which is by definition for a fast paced and rapidly evolving environment.

2. Design moves faster but is normally relatively static

3. Unit tests are vital but test cases require a full spec which is by definition not available for an agile environment. I note also that developers cannot think of every test case: Testers should write, or at least specify, test cases. I also recall developers refusing to fix a bug saying the code was being tested wrongly “Its not the way the code is supposed to be used” My experience is that writing and validating/debugging unit tests takes at least three times as long as writing the code. Managers, even technically savvy ones, tend not to believe this.

4. I lost count of the times I have been told “Don’t waste time refactoring, just do the job and raise a ticket if you think refactoring is needed”. I regard refactoring as very important.

I have in the past been very critical on my blogs about how Agile is implemented and concluded that where the wider corporate culture is agile-hostile Agile becomes a means to induce conformity, kill creativity and infantilise developers.

Newsletter

Join them now to gain exclusive access to the latest news in the Java world, as well as insights about Android, Scala, Groovy and other related technologies.

Email address:

Recent Jobs

No job listings found.

Join Us

With 1,240,600 monthly unique visitors and over 500 authors we are placed among the top Java related sites around. Constantly being on the lookout for partners; we encourage you to join us. So If you have a blog with unique and interesting content then you should check out our JCG partners program. You can also be a guest writer for Java Code Geeks and hone your writing skills!

Disclaimer

All trademarks and registered trademarks appearing on Java Code Geeks are the property of their respective owners. Java is a trademark or registered trademark of Oracle Corporation in the United States and other countries. Examples Java Code Geeks is not connected to Oracle Corporation and is not sponsored by Oracle Corporation.