Saturday, March 1, 2008

Great quotes on agile


Jesper Rønn-Jensen has some Great Quotes For The Agile Project Wall

My 2 favorites are:

“Life is really simple, but we insist on making it complicated” - Confucius

In software development, we usually tend to try to understand and design all on advance (maybe fearing that later we, our customers and out team won't be so smart as now?) Haha, I think that the truth is that doing requirements and programming incrementally contributes to simplicity and a better continuous understanding of the business domain and our software. So, let's keep it simple and develop in small increments.

Project success is not product success - Jeff Patton, Agile Alliance

In traditional software development, our teams are used to just completing a schedule and releasing the software, but actually our focus should be on the product success, fully satisfying the customer. This is one of the reasons I like agile methods, they focus on the product adding business value continuously.

Check the other quotes and contribute if you got more!

Sunday, February 24, 2008

Thinking about documentation

In working these days in a presentation I'll be doing with a peer on "Requirements in eXtreme Programming". I'm taking a course about Requirements Engineering with a strong focus in RUPs way of doing requirements, so guess it'll be important to address the topic of why XP does so little documentation.

In the Art of Agile Development, James Shore explains the 3 types of documentation:
- Work In Progress Documentation: helps you to get your job done.
- Product Documentation: documents that provide business value
- Handoff Documentation: documents for handing off the project to a new team

Requirements documents and design documents are usually just work-in-progress documentation. The real need is how can we communicate while we develop software. XP emphasizes a whole team (customer, programmer, testers) that sits together, communicates face to face and shares a common language (ubiquitous language).

I agree completely in that oral communication is much more effective than just receiving a document (use case or any other) with a task that says "Program it". What if instead of giving documents to our programmers we give them a brief statement of what need to be done and then they have the chance to get the requirements directly with the customer? That is the idea of using user stories. They are work-in-progress artifacts. They are not little requirements documents, but they replace them with a cool combination:

On Site Customer + User Stories + Common Domain Language + Iterative Development (program byte-sized requirements) + Automated Tests (unit and customer tests)

I thought that User stories were just a lazy way of not writing use cases (or SRSs) but actually they are a smart way of remembering that we need to communicate with the customer. XP practices really support each other, so I think that before saying "XP doesn't work for me cause it does so little documentation", we should take a look at how all practices fit together.

A little conclusion: XP supports written communication with other practices that are far more effective than just written documents. (check page 195 inThe Art of Agile Development).

In the next days, I'll be googling, thinking and writing about where do use cases, as a technique, fit in agile. Hope you'll come back and read my findings and opinions!

Saturday, February 16, 2008

Your best friend on the Internet?

Have you noticed that you could spend all day long just reading blogs about your favorite topic? That is cool, but only before you notice that you'll want to know which are the hottest stories and you got a million hits on Google!

That's the cool thing about Social Rank. It helps you to save time by giving you the top stories about your favorite topic. For example, I found www.agiledaily.com, a Social Rank powered website, of course, about agile software development.



I'll give it a try!

Thursday, February 7, 2008

TDD Doesn't Make Development Take Longer!


Hi people, tonight I'm thinking about the conception that Test Driven Development makes your project take longer. I googled this post from Jeremy Miller and found it to be based on experience and really match what i've found on my own programming experience.

Some people say that a project can take longer cause you must write and maintain more code, and each time you suggest to include more quality in your software through tests you hear the same objections... but why is that?

Well, I think that is really a natural reaction and seems logical if you haven't developed the test-driven way (red-green-refactor). Some people think they have done TDD but they have just coded automated tests, but TDD is about design and continuous design. If you design the test-first way you are going to finish your code in a faster and better way... that's just a non issue for me. Your code will do what you supposed it should do, no more, no less. Why don't you try yourself? This is a pragmatic issue, if it works why don't we apply it and enjoy the benefits?

Jeremy Miller lists where he thinks TDD cuts development time, and I concur:

- Design
- Debugging
- Fixing bugs
- Testing

Let me add a few, IMHO:

Maintainability: When you develop the TDD way, you can refactor and change your code anytime and just enjoy the simplicity of good code and your unit tests are a safety net. That resumes in few development time and make programming more fun. Also, you can focus more in adding value to the code by reducing technical debt and improving your design cause good tests are you allies.
Trust in your own code: Since the days I started thinking and with TDD I trust much more in my code and feel more proud of it. I can even invite you to take a look any time and even make changes with confidence that my tests validate yours!
Trust in others code: if you honestly did TDD and you trust me your code for working on it, I'll feel very secure that your code will be simple, understandable and open to refactorings. We work in team environments, people come and go, and our code should be always hight quality. We'll save ourselves so much pain...

BUT, (and this is a big BUT), you'll enjoy all that benefits if you're honest and mindful about TDD. Please, don't do it as just a requisite. And PLEASE! Don't say that TDD is an overhead to software development if you haven't given yourself to learning how to do it and practicing for a little while. I can assure you, you won't regret.

If you want, take a look at this Introduction to Test Driven Design (TDD). Enjoy!

Saturday, February 2, 2008

In the beginning of a new project...


In the beginning of a new project, you wonder what can you do to get better results than in your last, right? Well, actually the most common is to do the same things you did last time and expect to get different results! I think that's nonsense, we should strive every time to improve our process and make our teams more effective. What's effectiveness? For me, is to deliver a product that satisfies the business needs. That's why I like agile processes, they are focussed on delivering business value from week 1.

Last week, the business people handed us some documents they wrote for modeling the business (as in RUP). I'm sure they spent a lot of time writing them. I read them and am required to make a use case model and estimate. Last project we did that and missed by 100%! (the project was estimated in 5 and me took 10)... actually, the first release will be on March... We estimated a with about 50 use cases that we wrote in about 2 months, and we really missed the target. Why? Some aspects are:

- We did a big Requirements Phase upfront. Requirements always change. In the beginning of the project, you really don't know everything! We all learn a lot during the project time, even the user, and requirements always change.
- Sometimes, the developer read the use case and programmed something different from the what the user expected.
- We didn't include enough time for testing.
- Testers weren't part of the projects but after 7 months of development.
- My MS Project has been in 90% for the last 2 months... My schedule is not guarantee or real indicator of the project status, working software is...

In this new project, I want different results, and for that, I think we need to try different things.

The first thing is: Don't do a lot of upfront requirements.

Check this essay from James Shore:
http://jamesshore.com/Blog/Up-Front-Requirements.html

Saturday, January 26, 2008

Business people really trust in us!

When you are writing enterprise applications, on most cases you are automating information flow, enforcing business rules and managing persistence. No matter what programming language are you using, you need to understand the business. In this post I wanna share some questions that are in my mind...

1. What is the most difficult stuff about making enterprise applications?
In the applications I'm working on, persistence or UI related stuff is not difficult. The hardest thing is to understand business needs, understand their rules and writing them in a way that a computer can understand. We state our understandings using use cases and other requirements documents, then our business people leave us alone, hoping that we really understood them.

2. How much trust do business people put in our teams?
Wow, I think they trust us a lot! We wrote the use cases, they approved them and after several months without seeing the actual software working, we release the software they'll use. Their jobs depend on us doing the right thing.

3. How do we respond to that trust?
Many times, we as software developers aren't conscious on the critical nature of our software, but we want to make a good product. At my job, we apply some agile practices, but our process relies on a big initial requirements phase and a final testing phase. We use TDD, Continuous Integration, we do code inspections and try to go on with the schedule. Then testers try to understand what the use cases state the software should do and use it in our testing servers. An business people? They are trusting in that the product that they have not seen yet is what they expect. Wow, they trust us so much! BUT maybe, the software works great but isn't what they are expecting. Maybe we automated some calculus but they haven't had a chance to use it with real sample data... We software developers do the best but I think we need one more thing.

4. How do we know that they are confident that their business rules are enforced by the software?
We need to be better in our communication. Let's speak more with the business, let us not rely only in formulas, let's ask the business people for real data examples. Last week I found put that they use Excel a lot for explaining their intents. They can give us many tables of example data. Real data that could assert that our software does what they want.

And that's the goal right? Great software solves real needs. it doesn't matter If software is delivered on time, on budget and according to requirements documents, but isn't what the real users need. Quality is perceived in working software doing the right stuff.

So, as a conclusion, why don't you give users the possibility to give you real examples, use them throughout your development and try everyday to improve your communication. Collaborate more, we are on the same team.