<?xml version="1.0" encoding="UTF-8" standalone="no"?><rss xmlns:atom="http://www.w3.org/2005/Atom" xmlns:blogger="http://schemas.google.com/blogger/2008" xmlns:gd="http://schemas.google.com/g/2005" xmlns:georss="http://www.georss.org/georss" xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/" xmlns:thr="http://purl.org/syndication/thread/1.0" version="2.0"><channel><atom:id>tag:blogger.com,1999:blog-89891439123743242</atom:id><lastBuildDate>Sat, 05 Oct 2024 02:05:29 +0000</lastBuildDate><category>agile</category><category>xp</category><category>scrum</category><category>Extreme Programming</category><category>Coding</category><category>agile xp</category><category>software</category><category>Code</category><category>Code Normalization</category><category>Code Smell</category><category>Do The Simplest Thing That Could Possibly Work</category><category>Fluent</category><category>Iteration</category><category>Lazy Programmer</category><category>Not Invented Here</category><category>Once and Only Once</category><category>One Responsibility Rule</category><category>Responsibility Driven Design</category><category>Scrum definition</category><category>Special formatting</category><category>Standard</category><category>XP agile</category><category>Yagni</category><category>You Arent Gonna Need It</category><category>agile planning</category><category>agile story task estimate</category><category>chicken</category><category>continuous builds</category><category>continuous integration</category><category>core practices</category><category>development</category><category>download</category><category>free</category><category>matrix</category><category>measurement</category><category>open source</category><category>pig</category><category>planning poker</category><category>product backlog</category><category>product sheet</category><category>project management</category><category>quality</category><category>softwares</category><category>sw</category><category>time estimation</category><category>unit test</category><category>unit testing</category><category>velocity</category><category>xp xtudes</category><category>xtreme programming</category><title>AGILE++, the next step in agile based sw development</title><description>This blog is for those geeks who are interested in AGILE based development model. AGILE is a breakthrough, a cutting edge framework which has been followed by many Fortune 500 companies. I would like to take AGILE one step ahead. So, lets call it AGILE++</description><link>http://agileplusplus.blogspot.com/</link><managingEditor>noreply@blogger.com (Rahul Choudhary)</managingEditor><generator>Blogger</generator><openSearch:totalResults>15</openSearch:totalResults><openSearch:startIndex>1</openSearch:startIndex><openSearch:itemsPerPage>25</openSearch:itemsPerPage><xhtml:meta content="noindex" name="robots" xmlns:xhtml="http://www.w3.org/1999/xhtml"/><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-4946139610859772795</guid><pubDate>Wed, 01 Jul 2009 04:52:00 +0000</pubDate><atom:updated>2009-07-01T10:24:28.190+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">agile</category><category domain="http://www.blogger.com/atom/ns#">Coding</category><category domain="http://www.blogger.com/atom/ns#">Extreme Programming</category><category domain="http://www.blogger.com/atom/ns#">unit test</category><category domain="http://www.blogger.com/atom/ns#">unit testing</category><category domain="http://www.blogger.com/atom/ns#">xp</category><title>Code Unit Test First</title><atom:summary type="text">This practise is also known by many other jargons like Test Driven Development, Test Driven Programming, Test First Design etc.What is the underlying objective is to let you know that you need to avoid writing a single line of code till you have not written to test it. It is nothing but saying in a broader term that if the requirements are not clear the project will go down the drain. Now take </atom:summary><link>http://agileplusplus.blogspot.com/2009/07/code-unit-test-first.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-8572730890425787409</guid><pubDate>Sat, 20 Jun 2009 21:35:00 +0000</pubDate><atom:updated>2009-06-21T03:13:38.545+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">agile</category><category domain="http://www.blogger.com/atom/ns#">continuous builds</category><category domain="http://www.blogger.com/atom/ns#">continuous integration</category><category domain="http://www.blogger.com/atom/ns#">download</category><category domain="http://www.blogger.com/atom/ns#">free</category><category domain="http://www.blogger.com/atom/ns#">open source</category><category domain="http://www.blogger.com/atom/ns#">software</category><category domain="http://www.blogger.com/atom/ns#">softwares</category><category domain="http://www.blogger.com/atom/ns#">sw</category><category domain="http://www.blogger.com/atom/ns#">xp</category><title>Continuous Builds</title><atom:summary type="text">Continuous Build is a very vital aspect of Agile Methodology. It helps you recover quickly and allows bugs to be discovered early. It also put focus on Continuous Integration which is a entirely different subject altogether.The concept of Continuous build implies that the code should be checked out from the repository often and the test should be carried out frequently to ensure that the builds </atom:summary><link>http://agileplusplus.blogspot.com/2009/06/continuous-builds.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-436931108210563653</guid><pubDate>Thu, 26 Mar 2009 20:43:00 +0000</pubDate><atom:updated>2009-06-17T21:54:28.633+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">agile</category><category domain="http://www.blogger.com/atom/ns#">development</category><category domain="http://www.blogger.com/atom/ns#">Iteration</category><category domain="http://www.blogger.com/atom/ns#">matrix</category><category domain="http://www.blogger.com/atom/ns#">measurement</category><category domain="http://www.blogger.com/atom/ns#">project management</category><category domain="http://www.blogger.com/atom/ns#">quality</category><category domain="http://www.blogger.com/atom/ns#">software</category><category domain="http://www.blogger.com/atom/ns#">velocity</category><title>Agile for Quality Assurance</title><atom:summary type="text">Today I will talk about one of the most difficult topic faced by any Project Manager, you got it I am talking about Quality Assurance. Matrix and Number is agile are quite tricky and have to be dealt separately than a normal Project Matrix. I faced it when my company was preparing for CMMi L5 audit and the auditor didn't knew how to deal with a Agile project. He kept asking stupid questions and I</atom:summary><link>http://agileplusplus.blogspot.com/2009/03/agile-for-quality-assurance.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-3866780079752467261</guid><pubDate>Thu, 25 Sep 2008 05:03:00 +0000</pubDate><atom:updated>2008-09-25T10:34:43.317+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">agile story task estimate</category><title>INVEST in Good Stories, and SMART Tasks</title><atom:summary type="text">INVEST in Good Stories, and SMART TasksXP teams have to manage stories and tasks. The INVEST and SMART acronyms can remind teams of the good characteristics of each.In XP, we think of requirements of coming in the form of user stories. It would be easy to mistake the story card for the "whole story," but Ron Jeffries points out that stories in XP have three components: Cards (their physical </atom:summary><link>http://agileplusplus.blogspot.com/2008/09/invest-in-good-stories-and-smart-tasks.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-7130628331325611476</guid><pubDate>Thu, 04 Sep 2008 04:38:00 +0000</pubDate><atom:updated>2008-09-04T10:12:44.984+05:30</atom:updated><title>Pairing Pattern: Ping Pong Pairing</title><atom:summary type="text">Pairing Pattern: Ping Pong Pairing     One of the struggles people can have when they first start pairing, is understanding when it is time to drive, and when it is time to watch. Developing a good tempo to the act of pairing – and understanding when the change over should occur – can make it seem like a much more fluid activity. When it is working well, outsiders will see the keyboard moving </atom:summary><link>http://agileplusplus.blogspot.com/2008/09/pairing-pattern-ping-pong-pairing.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" height="72" url="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiprRXhi8pZfuODffNK65HUWRD6z7Tg_1-E7R4g-GqWWeRfFrWKWGN1ONSkkMPBG7I9e6cQvyABk8rSxiJWDP0T5P0Dp2c47c16CLHgDsi-ZYQOoxE4Rc8-o7dGwI1rcGdJ1ZlOSKJLRtKp/s72-c/tabletennis.thumbnail.jpg" width="72"/><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-1729561515910858786</guid><pubDate>Fri, 20 Jun 2008 07:00:00 +0000</pubDate><atom:updated>2008-06-20T14:04:05.314+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">Code</category><category domain="http://www.blogger.com/atom/ns#">Coding</category><category domain="http://www.blogger.com/atom/ns#">Fluent</category><category domain="http://www.blogger.com/atom/ns#">Standard</category><category domain="http://www.blogger.com/atom/ns#">xp</category><category domain="http://www.blogger.com/atom/ns#">xtreme programming</category><title>Fluent Interface</title><atom:summary type="text">I just read a good article by Martin Flower on "Fluent Interface". Here is the abstract...A few months ago I attended a workshop with Eric Evans, and he talked about a certain style of interface which we decided to name a fluent interface. It's not a common style, but one we think should be better known. Probably the best way to describe it is by example.The simplest example is probably from </atom:summary><link>http://agileplusplus.blogspot.com/2008/06/fluent-interface.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-3603940269021220943</guid><pubDate>Wed, 04 Jun 2008 09:59:00 +0000</pubDate><atom:updated>2008-06-04T16:17:54.182+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">agile</category><category domain="http://www.blogger.com/atom/ns#">scrum</category><title>Implementing Agile in Agile Manner</title><atom:summary type="text">I was attending SCRUM meeting with my team and normally it is followed by a 5 min TIDBIT session by anyone on a round robin basis. One of my team member raised a very good point, he was giving example of how we have successfully implemented Agile in our team. And he pointed out that we have brought in incremental changes. That means we have implemented Agile in the Agile way. We didn't rushed </atom:summary><link>http://agileplusplus.blogspot.com/2008/06/implementing-agile-in-agile-manner.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-6535695534439807630</guid><pubDate>Sat, 24 May 2008 14:59:00 +0000</pubDate><atom:updated>2008-05-24T21:11:56.300+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">agile</category><category domain="http://www.blogger.com/atom/ns#">scrum</category><category domain="http://www.blogger.com/atom/ns#">Scrum definition</category><title>Scrum Unplugged</title><atom:summary type="text">What is Scrum?A variation on Sashimi, an "all-at-once" approach to software engineering. Both Scrum and Sashimi are suited best to new product development rather than extended development. Sashimi originated with the Japanese and their experiences with the Waterfall model. They had the same problems with the Waterfall model as everybody else, so they adapted it to suit their own style. Realizing </atom:summary><link>http://agileplusplus.blogspot.com/2008/05/scrum-unplugged.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-6950694926536225467</guid><pubDate>Wed, 21 May 2008 07:14:00 +0000</pubDate><atom:updated>2008-12-11T02:04:45.223+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">agile</category><category domain="http://www.blogger.com/atom/ns#">agile planning</category><category domain="http://www.blogger.com/atom/ns#">planning poker</category><category domain="http://www.blogger.com/atom/ns#">time estimation</category><title>Planning Poker (Time Estimations)</title><atom:summary type="text">Time estimating using planning pokerEstimating is a team activity - every team member is usually involved in estimating every story. Why?As per Agile at the time of planning, we normally don’t know exactly who will be implementing which parts of which stories. Stories normally involve several people and different types of expertise (user interface design, coding, testing, etc).In order to provide</atom:summary><link>http://agileplusplus.blogspot.com/2008/05/planning-poker-time-estimations.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" height="72" url="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiysOxm2DsFlh-i0W9ujZK7Qv416cXwUTxZF5HuzlCdck8r5HBrX_DggCg3Yadw7tPZ_L6PlHcJelDhsh2BHfPh9NBGRVgMBwVl8iGGPo6IoROwtnb1yfo2p9mDH8wbSovUjVT1iT4eGLbx/s72-c/CrispPlanningPokerDeck.jpg" width="72"/><thr:total>1</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-2174141853937248212</guid><pubDate>Mon, 19 May 2008 10:40:00 +0000</pubDate><atom:updated>2008-05-19T16:28:11.352+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">agile</category><category domain="http://www.blogger.com/atom/ns#">agile xp</category><category domain="http://www.blogger.com/atom/ns#">core practices</category><category domain="http://www.blogger.com/atom/ns#">Extreme Programming</category><category domain="http://www.blogger.com/atom/ns#">scrum</category><category domain="http://www.blogger.com/atom/ns#">xp</category><category domain="http://www.blogger.com/atom/ns#">xp xtudes</category><title>Extreme Programming Core Practices</title><atom:summary type="text">The 12 “XP Xtudes” (Xtude is XP means ‘Attitude’) of Extreme Programming (XP) grouped into four categories 1. Fine Scale feedbackXP thrives on providing feedback at smaller intervals with higher frequency. This allows controlling deviation at the right time, since in software or any othe industry for that matter, once deviation starts happening it is dificult to control at the later stages.Test </atom:summary><link>http://agileplusplus.blogspot.com/2008/05/extreme-programming-core-practices.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-7749719241148165571</guid><pubDate>Tue, 13 May 2008 09:08:00 +0000</pubDate><atom:updated>2008-05-13T15:23:52.531+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">agile</category><category domain="http://www.blogger.com/atom/ns#">Extreme Programming</category><category domain="http://www.blogger.com/atom/ns#">xp</category><category domain="http://www.blogger.com/atom/ns#">Yagni</category><category domain="http://www.blogger.com/atom/ns#">You Arent Gonna Need It</category><title>YAGNI</title><atom:summary type="text">YAGNI perfectly sums up XP (Xtreme Programming). Here is why and how."You Arent Gonna Need It" (often abbreviated YAGNI) is an Extreme Programming (XP)practice which states:"Always implement things when you actually need them, never when you just foresee that you need them." Even if you're totally, totally, totally sure that you'll need a feature later on, don't implement it now. Usually, it'll </atom:summary><link>http://agileplusplus.blogspot.com/2008/05/yagni.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-8878322342295512419</guid><pubDate>Tue, 13 May 2008 07:00:00 +0000</pubDate><atom:updated>2008-05-13T14:49:20.478+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">Code Normalization</category><category domain="http://www.blogger.com/atom/ns#">Code Smell</category><category domain="http://www.blogger.com/atom/ns#">Do The Simplest Thing That Could Possibly Work</category><category domain="http://www.blogger.com/atom/ns#">Once and Only Once</category><category domain="http://www.blogger.com/atom/ns#">One Responsibility Rule</category><category domain="http://www.blogger.com/atom/ns#">Responsibility Driven Design</category><category domain="http://www.blogger.com/atom/ns#">Special formatting</category><title>One Responsibility Rule</title><atom:summary type="text">From Bertrand Meyer's “Object Oriented Software Construction”, there was the statement:A class has a single responsibility: it does it all, does it well, and does it only.Classes, interfaces, functions, etc. all become large and bloated when they're trying to do too many things.When a function has too many responsibilities, it becomes buried deep in "Special Formatting", which has a "Code Smell".</atom:summary><link>http://agileplusplus.blogspot.com/2008/05/one-responsibility-rule.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-2363993764184154380</guid><pubDate>Fri, 09 May 2008 06:39:00 +0000</pubDate><atom:updated>2008-12-11T02:04:45.522+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">Lazy Programmer</category><category domain="http://www.blogger.com/atom/ns#">Not Invented Here</category><category domain="http://www.blogger.com/atom/ns#">XP agile</category><title/><atom:summary type="text">Lazy ProgrammerThis idiom is related to the Albert Einstein's Principle “A scientific theory should be as simple as possible, but no simpler”.It can be worded as "Do as little work as possible to get the task completed, but no less." So, complete the task by trying to write the minimum amount of code that satisfies the requirements and passes all the tests. That means not falling prey to the “Not</atom:summary><link>http://agileplusplus.blogspot.com/2008/05/lazy-programmer-this-idiom-is-related.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" height="72" url="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi1SC1dT49hQqUHLtMjJwDpBsYf8Dbk2q5VVlPhTCyAuEJaLWol16bU3e8_ZTLkVj9guZ0rFqFxhz9XwdpkrX7Fu70qEDM8NCfrPBu0s73Q03NU8PSIpwSaDyARW1RFNYJYSJ2xbYDtUbgB/s72-c/lolcat_based_on_picture_by_lazy_lightning_from_flickr_cc-by.png" width="72"/><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-4550675981426884190</guid><pubDate>Thu, 08 May 2008 05:52:00 +0000</pubDate><atom:updated>2008-05-08T17:55:18.338+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">agile xp</category><category domain="http://www.blogger.com/atom/ns#">product backlog</category><category domain="http://www.blogger.com/atom/ns#">product sheet</category><category domain="http://www.blogger.com/atom/ns#">scrum</category><title/><atom:summary type="text">How to best use product backlogsProduct backlog is normally the starting point, it is where AGILE's heart lie. It is the first step in starting an AGILE based software development. It is nothing but a sorted list of requirements/feature requests/user stories or what ever term you use for high level tasks based on importance of the items in it. The best part is that the items are described in </atom:summary><link>http://agileplusplus.blogspot.com/2008/05/how-to-best-use-product-backlogs.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><thr:total>0</thr:total></item><item><guid isPermaLink="false">tag:blogger.com,1999:blog-89891439123743242.post-7023840083112239207</guid><pubDate>Wed, 07 May 2008 06:42:00 +0000</pubDate><atom:updated>2008-12-11T02:04:46.210+05:30</atom:updated><category domain="http://www.blogger.com/atom/ns#">agile</category><category domain="http://www.blogger.com/atom/ns#">chicken</category><category domain="http://www.blogger.com/atom/ns#">pig</category><title/><atom:summary type="text">Once Upon a Time....A Chicken and a Pig lived on a farm। The farmer was very good to them and they both wanted to do something good for him।One day the chicken approached the pig and said, "I have a great idea for something we can do for the farmer! Would you like to help?"The pig, quite intrigued by this, said, "of course! What is it that you propose?"The chicken knew how much the farmer enjoyed</atom:summary><link>http://agileplusplus.blogspot.com/2008/05/once-upon-time.html</link><author>noreply@blogger.com (Rahul Choudhary)</author><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" height="72" url="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj4XySNkp57dEfZ6v4MmndWRNJrwgETJfqR8F0rt3zxz7asjaXXMAsLEk5L737aMWZUMpY3artVPxVnFZukJyChkYhG8-eP7mk8MoUhA-b-j7RtyktCeCh69b1Waf1pSefVgEy4EXTNi9qc/s72-c/image001.gif" width="72"/><thr:total>0</thr:total></item></channel></rss>