Related
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 11 years ago.
I recently started using "Jira" with the "GreenHopper" plugin. However, I don't feel like this is really doing what I want. I saw a cool feature in "Scrumworks pro" where you can run the app as a desktop application. My requirements therefore include things like:
Must have a really easy UI for managing scrum tasks
Must preferably have a desktop version that plugs into web version
It DOES NOT have to be free, just as long as it rocks!
It must NOT be a butchered app, but rather something specifically designed for Scrum, with a good development team.
It would also be an extra plus if it can integrate with Subversion somehow.
It would ne another extra plus if the sprints could send summaries to business owners of the work that was completed. I.e. Custom reports.
Any suggestions?
You could try IBM Rational Team Concert.
Easy UI: Very, especially the Eclipse version.
Desktop: You can use web, VS add-in, or eclipse version, by team member preference. Like I said, I recommend Eclipse (but haven't really seen the VS add-in)
Price: I believe it's free up to 10 developers, then it's IBM pricing schemas. But if that's not an issue...
(non-)Butchered app: It's IBM, so it's not a hack; and it's built on Jazz, so there's some extra developer community juice there. While it's supposed to be able to support both traditional and Agile, in my experience it's strongest for Scrum. Also, the configuration is highly customizable.
SVN integration: While there's no official bridge for this, I'm pretty sure it's been done before (e.g. by Clearvision), and can be done again if need be. Also, RTC comes with its own SCM system - I don't know if that would work well enough for you to replace SVN altogether, but it might.
Reports: Lots of (somewhat) customizable dashboards and charts. If there's a way for it to send automated reports, I haven't seen it yet.
All in all this sounds fairly close to what you were describing.
EDIT: By popular demand, some screenshots... From my actual Production environment. This is going to be long.
This is the Work Breakdown view of my current sprint. You can see that you have user stories, tasks, you can have defects, ARs, risks, impediments, what have you. It's actually customizable so you can add additional object types, each with its own properties and state machine.
Each of the properties you see can be changed from this view - so it's very easy to just add a new task under a story, set its estimate and a brief title, and you're good to go. All in all maybe 10 seconds for creating a new task. Ctrl+S commits your changes (takes ~1-2s).
In fact, I almost never have to leave this screen during a sprint. You can assign work to someone by making the item under their name, dragging an existing item under their name, or right click -> assign to Owner -> their name. You can change states and set time spent (or time left, the view is customizable) from this screen as well.
Occasionally you want to open an item for individual editing, which you can do by right clicking any object. That opens it in a new tab.
You can see that each individual team member as well as the team as a whole has a work done vs. expected. This is based on the release dates I've set for the sprints and total work estimated. If you're doing Scrum correctly, then by the second-third day you've already assigned each story the vast majority of its tasks. You get a handy meter for how many items you have unestimated. In fact, you can even filter out estimated items so you can focus on estimating the remaining ones (which again is two clicks).
P.S. My teammates don't necessarily have good task breakdowns / estimates here. But you get the idea.
The views you can have are many, and can be customized. So if you like a sticky board for your tasks, you have...
I don't actually use this a lot, but it's there. You can either view it by bunched groups of in progress, resolved etc. (like the screenshot) which is good for viewing several different object types; or you can do it by a specific object type's state machine (so for defects you could have Resolved, WNF, etc.)
Speaking of defects, this can integrate with ClearQuest (though it's got bad limitations if you're using multi-site solution for CQ). I don't know if I'd let RTC completely replace a different defect tracking system, but you conceivably could.
BTW the taskboard is intuitive in the sense that you can drag a task from one state to the other and it would update its state, assuming that the state transition is allowed by the state machine you determined.
More views are possible. Another filter I use during sprint planning is "Execution items", which leaves me only the stories and epics - no clutter under them.
Speaking of "under them", you could have other types of relationships than parent-child, such as "related" or "blocking". To do those though I think you have to go into the specific object. Parent-child can be done that way too, but usually you just drag objects on to one another.
I'll add here a couple of side panel screenshots and then I think I'm done... Because you should get the idea.
Team Artifacts panel lets you browse the relevant objects. Generally for Scrum management that would be Plans, which is where you keep all your work items. The "Work Items" item actually a bit misleading in that regard, it lets you do queries (e.g. "Open assigned to me"), which then appear in a bottom panel. I personally prefer using the plans.
You can also see builds, source control in there - for some teams they are indispensable, for others (like mine) they aren't really used.
Last screenshot...
Actually got three areas in the Team Dashboard (four with "Builds" not presented here, which I don't use). "My Open Items" can actually display any query, by any order. This one uses priority. Hovering on any of these displays the relevant items (takes 0.5-1s to think about it), with F2 enlarging the tooltip. Clicking any of these columns retrieves the items for the bottom panel.
Event Log is what you'd expect, stuff your team has been doing. Likewise easy to expand, clicking on an item opens the corresponding work item in a new tab.
Then there's Team Load, which compares estimated assigned items to each team member's expected hours left to work in the iteration, as well as total. This draws from individual setting of work hours and planned absences (alas, absences don't seem to support any half-day scheduling, only full days).
By complete happenstance, I have one team member with no load, one with load exactly matching their expected hours, and one who apparently chewed more than he could swallow. Of course, he just needs to update his tasks, though in this particular case he really is overworked. This dashboard lets a Scrum Master identify this sort of situation quickly and try to resolve it before it's too late.
(Don't ask why that didn't happen in this case).
Performance is also surprisingly good. I'm not sure what they did in their architecture, but it's a lot smoother than other enterprise solutions I've used. By far.
Maybe I should make it clear that I'm not in any way affiliated with IBM, Jazz, RTC etc. I just think the tool is pretty nifty. I'm not yet done exploring it, actually, but for Scrum it seems pretty darn good and I'm happy to spread the word :)
Is this what you are looking for?
P.S. There are a ton of Agile tools out there, you could continue to look around. But if JIRA wasn't good enough for you, then that probably disqualifies maybe 90% of what's out there which is worse (e.g. Rally).
Pivotal Tracker: http://www.pivotaltracker.com/
No desktop version, but it pretty much rocks. Has many integrations and third-party tools.
VersionOne is very good. Free up to 10 users, nice web interface and rich plugin base.
We have been using Assembla (www.assembla.com) for more than a year. It is not free and does not have a desktop version but it definitely rocks.
Some things I love:
The UI is clean and simple being suitable for developers and business owners alike.
Tasks and commits are integrated from SVN and Github so it makes it easy to track code changes relating to tasks.
The Cardwall/Kanban tool is excellent at quickly tracking tasks.
It is being developed constantly with new features like code review and enhanced cardwall features.
I can't compare it functionality to all of the solutions out there but I can tell you that it works fine for our team, is much better than what our partners use and clients are happy with it.
As a Scrum Practitioner for 8 years and user of most of the above mentioned tool, I recommend nothing better than a simple white board and concentrate on your process.
But if you have to use a tool especially for distributed teams...
I recommend ScrumDo.com Fast, Easy to use.
Nice Kanban board, integrated planning poker, intuitive story management with drag-drop, great for distributed teams.
Also we like the easy source code and time management integrations.
The prices scale very well with our growing teams.
Also the open source version helps out security minded team to install within the firewall.
Scrumdo is highly recommended. Agile Project management made so easy. I am hoping that all the teams in our company will use Scrumdo!
Try AgileWrap. I am sure you would like it.
It has clean, lean and easy-to-use interface for managing scurm user stories, tasks, defects, iterations, releases and backlogs.
Integrates with Subversion and Gits. Has API/Web services.
Free for 5 users team. Very affordable for larger size teams. You can use on-demand or on-premise whatever suits your needs. It does not come in desktop version though.
You can create custom reports as well as use many standard charts - velocity graph, burn-down, burn-up, story cumulative flow etc.
Definitely take a look at OnTime by Axosoft. It fits your wish list to a tee, including Subversion integration (if you're using Visual Studio), desktop and web clients, etc. I've used OnTime for the last five years and highly recommend it.
Best of all, their site has tons of information so I don't have to spend an evening creating screenshots to match Polymeron's answer.
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 9 years ago.
How can I make an Application look nice and not like an amateur pulled it together?
I mean graphic-wise.
Is there some sort of book you can read regarding beautiful program layouts, etc?
I put this in Community Wiki so please feel free to leave your opinions that way we can all learn. :D
Edit: Oh my god. I completely forgot to mention what kind of program. I mean desktop applications. Not web applications. :D
Find a graphic designer.
I'm not trying to be snarky, I'm just sayin'. I fancy myself a pretty good developer, but I am at stick-figure level when it comes to graphic design.
The skills (and the tools) for good graphic design are fundamentally different than the skills of a developer.
Three things:
Hire a designers that knows the business models and customers; unless you are good at it yourself
To help you provide meaningful feedback to the designer, read a book like
I like Don't Make Me Think: A Common Sense Approach to Web Usability, 2nd Edition by Steve Krug
Study many good Apps that have had success in the business of interest to you. Be inspired (aka copy) good ideas from them and mix in your own ideas. A prime example is how Google search "inspired" Microsoft's Bing
The following terms are really important when it comes to the look and feel of an application
User Interface Design
This talks about how the application has uniform soft colors, similarly sized controls, smooth fonts, appropriate groupings of data elements, etc.
User Experience
This is a much more difficult thing to attain. This is how intuitive the application is "Are you sure?" and "Are you Really sure?" message boxes, doing away with pop-up's and dialog boxes, auto-save, the flow from one stage to another, accuracy of data saves, and a host of other things that make the user experience truly amazing.
You cannot have good UX without good UI, but it is definitely possible to have a good UI without a good UX.
Just keep redoing it. Seriously, take all outside criticism. Ask them to be specific. If you're doing web work look at as many websites as you can. Sometimes, depending on the creator, you can email the website to ask why they did what they did and get a response. If you're doing desktop find a library you enjoy that can look good (not Swing, hate me if you want.) Then create, destroy, create, destroy, and so on until you're happy.
The biggest issue I think people have is learning to just throw away a component which isn't working for you.
I have found that going through the various desktop design guides can be pretty useful.
Windows User Experience Interaction Guidelines
Apple Human Interface Guidelines
Gnome Human Interface Guides
I don't think any of them can be considered as being "correct", but they will give you a good baseline idea as to what is expected in general as far as basic theory such as alignment, spacing and widget layout goes.
I recommend reading the AskTog site:
Bruce Tognazzini... ...founded the Apple Human Interface Group and acted as Apple's Human Interface Evangelist.
There's been some great stuff in the past, like how making buttons bigger is directly proportionate to their likelihood of being clicked, how mouse movement impacted design, etc.
But if you're not into learning - by all means, find a professional designer.
For Looks: Follow you platform's Human Interface Guidelines. Use the Golden Mean to please the eye. Simplify, Simplify, Simplify.
For Behavior: Watch the users use your application. Don't help them, don't correct them. Stand behind a two-way mirror if you can. You'll quickly find lots of places where your UI could use a tune-up.
I do try very hard to convince my users of the beauty of a command line interface.
Besides that, I think there is nothing better than "hallway testing". You can always hire an expert for GUI design though.
I really like the book Designing Interfaces. It presents many UI design patterns and when they are appropriate to use. It won't teach you how to make things "pretty", but it can help greatly in making your application intuitive and easy for a user to grasp. It also presents the patterns in a platform agnostic way.
There's lots of books out there are graphic design, interface design, web application design, css design, etc.
General rules:
think in terms of grids
don't fear white space
keep it simple
understand hierarchy
understand basic color theory
hire a user interface designer
Keep your coding work out of the design work, and do your mockups in photoshop or something similar before trying to implement them. Good coding and good visual UI design can be directly opposed to each other very often - what looks good on the outside takes some backend work that that most coders think is monstrous, and good UIs often require custom behavior where using standardized libraries might seem to make more sense from an engineering perspective. Having a target for the functional UI will help you to push yourself beyond the "good enough" results you might get if you let what your libraries do by default determine what the site or application will look like.
First of all, usability should always be priority #1 and should drive your design:
http://msdn.microsoft.com/en-us/library/ms997577.aspx
http://www.bucketsoft.com/blog/post/is-usability-standard-changing.aspx
However, that doesn't mean your application has to be ugly. And I disagree with those who say "you either have it or you don't." I think almost anyone can develop basic design skills if they put their mind to it. The very fact that you're asking about it proves that you're interested, which is a big step towards learning. And indeed even as a developer it helps to at least have a good sense for what looks good and how to make an engaging user interface. And if it's important you can always hire a professional designer later to take it to the next level.
There are a few fundamental details to design work that have helped me:
1.) Use colors wisely. Dull colors are not bad but they can make the design look boring and uninspired by themselves. If you add exciting, more saturated colors sparingly you can emphasize the more important elements. This will not only improve the look, but it can even be used to improve the usability by bringing attention to elements that you don't want your users to miss. Again, if you overdo this it's kind of like highlighting everything in your physics book. If you do it everywhere, it loses its meaning. I wrote more about colors and contrast in my answer here.
2.) Use white space wisely. This is huge. It doesn't matter if you're talking about a website or a Windows app -- a cluttered application is an ugly one. There is a good article about this relating to web design, but the same basic rules would apply to a desktop app.
3.) Fear not the big fonts. Another means for providing emphasis -- the big font. When combined with proper whitespace, a call-to-action written in great big words can be a powerful thing visually.
Come to think of it, all of these suggestions relate to creating emphasis.
There are a lot of sites that offer tips on Graphical User Interface (GUI) design. Google for "GUI design guidelines" and you'll find some. While these tips might not make your application look 'beautiful' they can make it look professionally designed. If you want beautiful graphics you might need to get some help from a graphic artist.
Check here for a good list of books on GUI design.
I really like this book, from Joel Spolsky:
[http://www.amazon.com/o/ASIN/B001O9LB86/ref=nosim/betteraddons-20]
General guidelines we use:
Make getting around easy: use a toolbar or side menu to access different parts of the application.
Make viewing information as easy as possible, and in different formats.
Make changing information as consistent as possible. I.e., put New, Edit, and Save buttons in the same place.
Make the most common action the easiest.
Specific guidelines we use:
Use the same or similar font across the application. Vary by size or bold to catch attention.
Use color backgrounds to group and separate types of information.
Put the most relevant information together and make the most commonly used button larger than the rest.
Don't use a drop-down control where there are only only a few options. Use a list control big enough that one doesn't have to scroll or use a radio-button.
Adding some white space can actually make it easier to read the screen or report.
Has anyone got any tips for the programmer who has no budget, or is working on a project at home for fun? We can't hire a designer, but we'd like to make a bit of an effort to get our applications looking less home-built.
I suggest showing a screenshot of your creation to family and friends. You'll hate their suggestions because they will differ from yours, of course. But it can help.
Research apps that are similar, AND some that are not, then pinch one small idea from each one!
Hire an expert. Design is something you either have or you don't. It sounds like you (just like me) are in the "don't" category :)
It'll give you an idea of where my head is at that my answer to "How do you normally make a program look beautiful?" starts with:
Short methods
Appropriate whitespace
Consistent naming conventions
Consistent formatting conventions
It's probably not a good idea to ask me what I think makes for a good UI.
I am looking for a good way to keep a design document up to date with the latest decisions.
We are a small team (two developers, game designer, graphic designer, project manager, sales guy). Most of our projects last a couple of months. At the start of the project a design is made but we generally find ourselves making changes or new decisions throughout the project. Most of these changes are improvements, so we want to keep our process like that. (If the changed design results in more time needed this is generally taken care of, so that part is OK)
However, at the moment we have no nice way of capturing the changes to the initial design document and this results in the initial design quickly being abandoned as a source while coding. This is of course a waste of effort.
Currently our documents are OpenOffice/Word, and the best way to track changes in those documents will probably be adding a changelist to the top of the document and making the changes in the text in parallel — not really an option I'd think as ideal.
I've looked at requirements management software, but that looks way to specialized. The documents could be stored in subversion but I think that is a bit too low level to give insight in the changes.
Does anyone know a good way to track changes like these and keep the design document a valuable resource throughout the project?
EDIT: At the moment we mostly rely on changes to the original design being put in the bugtracker, that way they are at least somewhere.
EDIT: Related question
Is version control (ie. Subversion) applicable in document tracking?
I've found a wiki with revision logging works well as a step-up from Word documents, provided the number of users is relatively small. Finding one that makes it easy to make quick edits is helpful in ensuring it's kept up to date.
Both openoffice and word include capaiblities for showing/hiding edits to your document. Assuming there's resistance to changing, then that's your best option - either that or export to text and put it into any source control software.\
Alternatively, maintain a separate (diffable using the appropriate tool) document for change-description text, and save archive versions at appropriate points in time.
This problem has been a long standing issue in our programming shop too. The funny thing is that programmers tend to look at this from the wrong optimization angle: "keep everything in one place". In my opinion, you have two main issues:
The changes' descriptions must be easy to read ("So what's new?")
The process should be optimized for writing of the specification to agree upon, and then get to work already!
Imagine how this problem is solved in another environment: government law making. The lawbook is not rewritten with "track changes" turned on every time the government adds another law, or changes one...
The best way is to never touch a released document. Don't stuff everything into the same file, you'll get the:
dreaded version history table
eternal status "draft",
scattered inconsistencies,
horribly rushed sentences, and
foul smelling blend of authors' styles
Instead, release an addendum, describing only the changes in detail, and possibly replacing full paragraphs/pages of the original.
With the size of our project, this can never work, can it?
In my biggest project so far, I released one base spec, and 5 consecutive addenda. Each of around 5 pages. Worked like a charm!
I don't know any good, free configuration management tools, but why not place your design under source control? Just add it to SVN, CVS, or whatever you are using. This is good because:
1) It is always up to date (if you check it in, of course)
2) It is centralized
3) You can keep track of changes by using the built-in compare feature, available in almost any source control system
It may not be the 'enterprisish' solution you'd want, but you are a small team of developers anyway, so for that situation, it is more than perfect.
EDIT: I see now that you already mentioned a source control system, my mistake. Still, I think it should work well.
Use Google Docs. Its free, web based, muti-user in real time, you can choose who has access to your documents, and keeps versioning. You can also upload all your word documents and it will transform them for you.
For more information: http://www.google.com/google-d-s/intl/en/tour2.html
Recently I've been doing lots of weekend coding, and have began to really need a bugtracker as things are gaining speed. This is probably the worst case scenario because I basically have to let things cool down over the week,so I simply can't remember the bugs in my head. So far I've been using a text file to jot down bugs,but I'd rather use something a bit better.
The biggest points here are ease of use and very little setup time.Don't want to spend more than an hour learning the basics and trying to install something. Also in my case I'm on a Mac so that would help, but solutions for other platforms are welcomed as they will likely help others.
FogBugz has a student/startup edition that's free indefinitely, for 2 or less users.
Personally, I use Excel. (Wait, come back, I'm not crazy!) For a bigger / team project, I've gotten a ton of mileage out of Bugzilla, but that tends to be kind of overkill for a one-person project.
But, a well-organized spreadsheet, with columns for things like "status", "description", "code module", "resolved date," etc, gets you pretty close to what you'd need for a small project. Sorting a spreadsheet by column isn't anywhere near a search, but its a whole lot better than "find in text file."
Heck, if you use Google docs rather than excel, you can even publish the thing as an RSS feed and get it anywhere.
And, the major advantage is that the setup time and learning curve are both effectively nil.
Addendum: And of course, the instant your "One-Person Bug Tracker" becomes a "Two-Person Bug Tracker" you must switch to something better. Bugzilla, FogBugz, anything. Trust me, I've been there.
Trac or Redmine are both pretty good. I don't know how easy they are to set up on a Mac.
It's worth mentioning that FogBugz also has a free version for up to 2 users, which would suit you. It is hosted so there is no installation and you can use something like Fluid to access it in its own window.
I don't think you need a full blown bugtracker for your scenario.
Try tiddly wiki, store each bug in a tiddler and give them tags like 'open' or 'closed'.
There is no installation required (only one html file), and it's very easy to use.
And platform neutral.
If you're working on a LAMPP stack, then for ease of setup and use I would probably recommend Mantis. It's written in PHP / MySQL and the only installation involved was specifying where the database should be created and what credentials should be used.
Oh, and its FOSS.
I would suggest Omnigroup's Omnifocus - it's an excellent task tracker, and if you just make the mental leap from bug to task, I think it works famously for one man projects as well as being an excellent way to organize your no doubt burgeoning task queue.
Eclipse has a really interesting system--I don't know why so few people seem to know about it.
It's tied in with their to-do list. It gives you the ability to enter bugs with as much or as little info as you like. You can tie it to versioning or an external bug tracker if you like. It's a decent bug tracker in itself.
The real trick is how it works with your source code.
Before you begin work you select a bug from the list. All the time you're coding, it tracks what files you are editing. It can close old tabs for you, and will also highlight areas of the source tree that you have modified a lot.
The nice thing is, you can go back to any bug you've edited an you will get your "Environment" back. Not only all your notes and stuff, but the same tabs will open up and the same sections of code in the navigator will be highlighted.
Also eclipse works with virtually any language, it's not just restricted to Java...
let me put in a good word for ditz - it's a bit bare-bones, but it has the invaluable feature that bugs are checked into your repository. it's also very easy to use once you get used to its way of doing things
You can use fogbugz for free if you're a one man team.
It's super easy to use and quick to learn.
They made it so that bugs are really easy to enter, no mandatory fields.
I'm the author of BugTracker.NET mentioned in another post. If I were looking for a tracker for JUST ONE PERSON with MINIMUM hassle, I'd use FogBugz, because it's hosted. No installation, no need to worry about backups.
But, what are you doing about version control? Don't you have to worry about that too, and backing that up? If so, consider something like Unfuddle or CVSDude where you can get BOTH Subversion and Trac, or Subversion and Fogbugz.
I use Mantis at home and I'm happy with it. It can be a pain in the arse to get it working so you can choose to download a free and ready-made VM installation. Cannot be easier than that,
Maybe a spreadsheet would be the next logical step? I know it sounds really un-sexy, but if you're the only user, you don't have to worry much about others mucking it up, and it adds a few basic features over a text file like sorting. Then if you later need to graduate to something RDBMS-backed, you would likely have a feasible import path. I just know that for me, when working by myself, I don't tend to get around to putting bugs in anything that requires more care and feeding than that (of course when working with others the collaborative needs make a more defined repository a requirement, but that's a different story).
EDIT: After noting the availability of free, hosted access to FogBugz, I'm re-thinking the bar for care and feeding...
RT from BestPractical is great.
I also get a lot of mileage out of just keeping a list of items in a text file with vi, if I can express them all in one line. This is usually for many small todo items on a single component or task.
I've tried bugtracker.net and even though it's a little bit rough on the edges, it's free and was built with ASP.NET:
http://sourceforge.net/project/showfiles.php?group_id=66812
Are you using a source control repository as well? If not, you really should, even though you're only a one-man team.
My personal preference is to use a VMWare Virutal Application (free) that offers no-hassle setup gives you access to both Trac and Subversion. You can find many different virual appliances through searching. Here is one example of getting a Trac/SVN virtual appliance up and running:
http://www.rungeek.com/blog/archives/how-to-setup-svn-and-trac-with-a-virtual-appliance/
Trac is an excellent project management tool that sports a bug tracker, wiki, and integrated source control management. It's adaptable to your needs, and fits me very well personally.
I use bugzilla for this purpose. Plus for me was that it has integration with Eclipse (precisely with Mylyn). FogBuzz has it to but AFAIK it is nonfree.
Plus it sits on my laptop so I can code and add/remove bugs when offline (it was biggest disadvantage of hosted solutions for me)
Installation was not a problem in Ubuntu (and any debian-based distro I suppose).
I dig ELOG in those cases, it's more of a personal blog, but it's easy to handle and install, the data is local on your computer and you can search all entries via fulltext. Always sufficed for me.
If you have a Windows box with IIS and MSSQL (including SQL Server Express), you should look at Bugtracker.net. It is free and open source (you get the source code), and it is extensible.
Even if you are a one man shop, having a free bug tracking system with this much power will allow you to grow over time, because it is fairly easy to add future users into the system.
You can also customize it for the look of your organization, business or product.
Ontime 2008 by Axosoft is free for a single user licence. It's industrial strength and will give you alot more that just bug tracking!
http://www.axosoft.com
Jira which now has free personal licenses.
I am using leo for this purpose. To be more specific, its cleo plugin.
Of course you might need to spend some time to get used to leo, but it will pay off.
A flat text file is just a list, an Excel spreadsheet is a two-dimensional list.
leo lets you keep the data in a tree! And it also has clones.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 5 years ago.
Improve this question
In traditional Waterfall, requirements were gathered - typically in a MS-Word document - following an esoteric template. In a "strict" waterfall model, this document is frozen after the requirement phase and a Change Control / Change Management process is responsible for introducing controlled changes. (**) [Typically, the document is turned into a "living document" and eventually a "living nightmare"]
Currently, I've to lead a project that is a rewrite of an existing desktop application to web (from VB 6.0 to ASP.Net). The client has a baselined version of the application that he wants rewritten. [So requirments are frozen... No scope creep]. The data model to be reused as is. Only the front end/Business rules to be migrated. Looking at the application, I feel it's a at most 3/4 major screens and that's it.
Some of the team members want to document (old school of thought, in my opinion) the entire thing before they start on the new development. I & and some others feel, it shoud be relatively easy translate the UI to Web, to look up old code, write the business logic, do automated unit tests, proceed to integration tests and deliver screen by screen (or business function by function)
My question is:
In an Agile development how I do I remain "agile" if I were not to optimize this. My opinion is writing detailed documentation is anti-agile. What do you think? How would an agile guru approach the above problem (of rewriting an existing VB 6.0 app to ASP.Net)?
Disclaimer:
Creation of a 1000 page Functional Spec could possibly be to meet contractual obligations, a political necessity, the system could be genuinely complex (now, definition of "complexity" is a journey unto murky-land).
First, you can produce documentation and remain agile, if the customer or the Product Owner requests to have (read is ready to pay for) documentation.
Grow your documentation incrementally and iteratively, as you'll do with code. Test a little , code a little and ... document a little.
I see three ways of doing this : either include the time to write the documentation in the tasks estimation, create documentation specific tasks, or have documentation backlog items/stories.
The risk with the documentation stories is that they may be planned very late, a long time after that have been implemented, so I won't recommend this.
Documentation tasks have the advantage of being visible in the iteration planning, so they should not been forgotten or overlooked.
Agile does not mean "no specs." It mean test and release early and often (but not necessarily to production).
The backlog in Scrum is the "spec." If you don't actually write down and manage the list of features, you WILL lose features, and you will NEVER be able to figure out when the product will be released (won't be able to estimate amount of work left because you have no idea where you are or how much there is left to do). The list of features MUST be managed by someone. The easiest way to do that is to write down everything the product should do (you can get as intricate in the wording and definition as you want) and keep track of what has been completed and what is left to do. How else will you assign work to developers and report status to "management?
I've put a lot of thought on the subject - we work in a Scrum environment, and we've ended up having difficulties to organize the documentation.
What I'm heading to at the moment, though it's quite early so I don't know if it'll pass the long term test, is to use a wiki for the documentation.
Basically, the workflow is the following :
Stories come up in the backlog
Story gets picked up by a programmer
Programmer does the code, and in the DoD (Definition of Done), also has to write some tests against the new functionnality, and has to edit the wiki to add a page for the new functionnality.
The wiki is organized with mediawiki templates, pretty much inspired from mediawiki extensions doc pages, with the name of the functionnality, the version it has been introduced into, anything that can be usefull. The template adds pictos to distinguish between different kinds of features (and of their status).
At the end of the day, the wiki has the great advantage of letting you add the documentation page without being bothered about where or how to put it, but obviously regularly you need someone to come behind and organize the mess.
The important thing to keep in mind, whatever tool you use, is that the developper should write some doc just after the development has taken place (including technical aspects) - and not before, and not months after...
In my view the functional specification is necessary depending on how involved is the tech team with the product and how senior is the team. If the tech team is involved in the product definition you'll definitely need less documentation because there will be less room for assumptions. If you have a team of engineers that are juniors you need a stronger documentation or else things will not be done the way they were defined in the end of the sprints.
Also be aware that remote teams need more documentation in the form of functional specs due to the natural barrier of not being close to the stakeholders and product visionaries.
Having upfront functional specs is a feature of agile. I saw a lot of tech teams where the tasks where solely described by a user story and quite often I saw those teams failing to achieve the releases and meeting the stakeholder's expectations.
This subject is very broad and there are a lot of opinions but in my view this can be reduced to the fact that the developers should not have to guess the requirements.
In fact I believe that the success and quality of the deliverables is inversely proportional to the number of guesses/assumptions that the developers need to make. I think agility increases with how well specified is something because you will have less mistakes and will spend less time correcting those mistakes.
If creating a Function Spec is a contractual necessity you should think really carefully what goes in it. You could be refused payment if you fail to deliver what you promise in your functional spec.
Unfortunately you're not going to remain very agile if you adopt this process. Does the client really want the same functions for the re-written application? If yes, then why is it being re-written? I'm sure that there a features that are never used.
I would not bother to document the old version. You have a reference already, the application itself. There is no ambiguity in the software.
Document writing is not anti-agile. Designing something without prioritising and getting feedback from your customer is. An important aspect of agile is getting buy in from the customer. If they don't believe it, then the project will have a harder time than it should.
As already pointed out, Agile does not mean little to no documentation - "working software over comprehensive documentation".
The way I approach documentation is almost to flip things on its head and to consider just about everything part of documentation (including code and unit tests as technical specs). So, a story (or whatever other mechanism you use to divvy up work) describing a business/user requirement should be detailed enough to be estimated by the team doing the work; otherwise, it is incomplete and vague. Further, something I do in my own practice, if the story (or whatever) is estimated to take longer than one working day to fit the team's definition of "done" it should most likely be broken down (this atomizing then compiling eventually leads to pretty extensive documentation, but does not assume as many unknowns as not doing it will - and can lead pretty interesting reuse and pattern revelations).
Example using BDD style requirements:
Given I am working on a document
When I select "Save As..."
Then a menu should appear allowing me to choose a name,
and a file type,
and a location in the file system,
and a file should be created in the file system
We may need/want to add UI elements to accomplish this, menu items, storyboards, keyboard shortcuts, etc. to this description (we may have multiple variations on the same theme of "saving a file"). And so on.
All of these related artifacts can be attached onto the base story/requirement; resulting in more complete documentation. But, only add those stories you actually implement to your documentation of the web version of the software.
Here's where things get kind of flipped on their head and become more "Agile". During development, and after development, revisiting the documented requirement and adding changes/modifications/improvements made by the team edits are made (without having to go through a documentation-only CCB). The ability to edit/update the documentation and related assets without going through all the review boards and whatnot - or throwing the document "back over the wall" when we find out during development that the document is incomplete in some way makes us able to adapt to the unknowns - therefore, Agile.
This documentation should have some form of version control or history, which allows us to describe the system we desired, but also describe the system that was actually implemented - noting another answer/suggestions regarding documentation being part of the Definition of Done (something I also do). (Wikis are good for this; however, a fully integrated concept is a little more desirable - e.g., being able to relate a ticket to a file in trunk in the version control system would be nice.)
To kind of conclude. Creating exhaustive documentation up front, which cannot be altered during and/or shortly after the development effort, will keep you from being agile - able to quickly adapt to unknowns. However, to reference Leading Lean Software Development, wherein they mention that if policies do not allow for certain practices/processes to be used properly, then it doesn't matter if you say you are lean (or scrum, or agile).
One way to make sure you are not being overly exhaustive - probably could've used this mindset on this answer - is to only write what you need to when you need to (similar concepts exist in development in general). Another would be to get everyone to understand that you don't need to try and figure everything out up front (the biggest transition from Waterfall to Agile) - we will document every idea and it may or may not end up in a release. And, finally, deprecate (and remove) anything that no longer applies...I remember seeing documentation for a system once and, when I reviewed the system, half the document didn't actually apply to the system anymore.
Since you have a document describing what the product should do, I would use it as the initial backlog and start splitting the work in bite size pieces ordered from highest to lowest priority. Each set of pieces would then be handled during an iteration. In brief, use Scrum with your initial document as the backlog.
I would not go straight to the implementation without doing this prioritization work. It does not require a lot of writing but more referencing the pieces you want to tackle.
I would not document the whole thing upfront.
In addition, you will have some tasks directly related to the platform your tackling and those tasks need to be captured and added to the sprint backlog.
Also, you may realize that you don't want to implement all the requirements after a few iterations.
Agile has a Functional Specification document in the form of the agile Features list, Product Backlog and even as far into the sprint as tasks in the sprint Backlogs too. The fact they are not called documents doesn't make them any less. And the difference from the Functional Spec in waterfall?...Agile Functional Spec only contains what is required (lol) therefore is less voluminous, remember your "Working software over comprehensive documentation"?