Related
I am joining a company, they dont have any formal testing setup. They expect me to start a testing department. I have good understanding of manual and automated testing. Not sure about how to start or which tools to use for document sharing, bugs tracking.
please guide as much info you can provide.
thanks
This is a very broad question and almost impossible to answer without significantly more knowledge of your companies products, quality goals and existing tooling... But I've got some Opinions :tm: that might help, starting with some philosophy (sorry).
What You're For
The function of a testing department isn't to test; the goal is to help the company be confident in its delivery of products. Your customers want to know that your software is accurate and stable. Your Operations team wants to avoid Production going down. Your Developers want to feel confident that their changes work and don't have any negative side effects.
I personally feel that the best way for a testing team to provide that confidence is not by writing tests; It's by editing them. The testing team provides the tooling, guidelines and expertise to help the rest of the Engineering departments make testing an integral part of the process.
It's like cooking. You don't make a well seasoned meal by chopping and sautéing and stirring and then giving it to a head chef to taste. You taste continually while you go because you're the one who knows what the food should be like. The head chef trains you and provides feedback on the final dish so that you learn how to season correctly.
Choosing Tools
Irrelevant. Mostly.
Your tools need to give you what you're after and then get out of your way. At the moment, the company barely knows what it's after, so you could even use a Google Doc to track defects.
You don't want to get in anyone's way to begin with, or they'll start to resent you. Your team needs to provide value and start to earn the social capital to change the Engineering processes to help deliver your goals.
So, use whatever document sharing tools are already in use; Whether that's a Wiki, Google, Dropbox etc. If you're choosing a new one because there's no collaboration, I'm partial to Notion.
If your team already has a collaborative build tool (eg Jenkins, Travis) it's probably best to stick with that, adding in testing steps. Again, the less friction you introduce, the better your initial outcomes.
I wouldn't bother building and maintaining a test grid; Instead, lean on a vendor like Sauce Labs for infrastructure and expertise. That way you've got easy parallelisation, wide platform coverage, test asset collection, insights, as well as their experience in supporting Testing teams. Disclaimer: I'm the Manager of Developer Relations at Sauce Labs, so I'm probably biased ;)
As for testing tools; If you want your engineering teams to collaborate on test production, you need to stick with an ecosystem they can use. This likely means whatever they're already using.
How To Start Testing
Selecting What To Test
Your organisation wants testing so bad they're hiring you. That implies there's a traumatic event that they want to avoid happening again. So, start there. Find out what it is, and create a test for it.
If Black Friday overwhelmed their site, do Load testing. If their build is always breaking, concentrate on unit testing. If functionality doesn't work in Prod, add an integration test.
Test Coverage
There's a trap for new players, and you're likely to hear this from your devs:
We're so far behind on test coverage we'll never catch up
That is absolutely true.... if you never start! Add the tests that prevent the trauma that bought you on board and you're already adding value; You'll catch that problem next time.
Another trap is setting test coverage goals. Test coverage is a great way to monitor your process but a terrible way to improve it. Force your teams to increase test coverage (or not let it slip) and they'll start to resent the process... And write crap tests just to boost the percentage.
Instead, use coverage for feedback. If coverage goes down during a commit, discuss why and talk about how to improve it. if it drops way down you might want to do something, but a little dip while you're getting started is A-OK.
Assuming you've covered the trauma that got you hired, increasing test coverage is best done on an as-worked basis. If a developer is writing new code, it gets tests. If a developer is modifying old code, it gets tests to (at least) prove that the modifications work, and ideally to prove that they don't break the old functionality either.
You may come across old code that literally can't be tested. That's a good time to refactor that code. If people are scared of refactoring because it might break, point out that that's exactly what tests are for. Try to pull out to a level where you can test. If you can't test a unit, test the class. If you can't test the class, test the package. Then, go back in and start re-working. You have to do it some day.
Oh, no, we'll be replacing the Fizzwangle with a new Buzzshooper implementation soon; There's no need to take the risk of refactoring for testability.
This is a lie. Even if they mean it truthfully, it's a lie. Buzzshooper isn't coming any time soon. Refactor that shit.
Tests Are Code, Code Is Tests
Your tests need to be treated like high quality code. Use all the abstractions you use when writing code, like inheritance, polymorphism, modularisation, composability.
Look at techniques like the Page Object Model for front end testing. Your test code should restrict implementation detail knowledge (eg, element locators) to the least number of places, so that changes are easy to implement.
Oh, and also, your Code is Code. Learn about then help your teams write code for testability, and tests for code-ability. Structure your tests and app so you can test in parallel, reliably, as fast as possible:
Give HTML elements unique, simple IDs
Write tests that test a single thing
Bypass complicated test setup by doing things like pre-populating databases
Log in once, then use session management to avoid doing it again
Use data generators to create unique test data (including logins)
Other Resources
Check out past conference talks like SauceCon Online.
Testing Talks Online has some great discussions and is the closest thing I've found to a real-life meetup during Covid.
There's also a lot of great content over at Ministry of Testing.
My company recently did a POC and have decided to use an commercial CMS. It is being implemented and we have been asked to Test it. What is there to be tested in a 3rd party CMS that has already been tested and being sold in the market?. Any direction would be great!
I would recommend adjusting your mind-set. What do you know about the test regime of this product? To start from the point of view that it's a commercially shipped product, it must have been tested, so I don't need to test it, is deeply flawed thinking.
First, all software has bugs.
Second, in testing the product you could reasonably focus on your proposed usage scenarios. You may choose patterns of use that were not anticipated by the development and test teams. At the very least you gain experience of the product's capabilities and limitations.
Third, installation into your environment may impact the system in unexpected ways. So at the very least the product must be exercised in your environment before you start to trust it. You need to explore the operational aspects, backups and restores for example. Now, before the system is live, is the time to find out how to recover from a disk crash.
I would ask the vendor is they have a regression suite you can run in your environment. if not I would devise a quick check-list of my own, trying to think about corner cases. Then also start to explore how your teams will use the product. Presumably there will be a "Build Master" role? Work with the people in that role and walk through some common scenarios. The likelyhood is that you will uncover some ways of working that are better than others.
Summary: testing isn't just about finding bugs (though you may well find some) but it's also about understanding the product better and learning how best to use it.
Closed. This question is off-topic. It is not currently accepting answers.
Want to improve this question? Update the question so it's on-topic for Stack Overflow.
Closed 9 years ago.
Improve this question
One of our developers is continually writing code and putting it into version control without testing it. The quality of our code is suffering as a result.
Besides getting rid of the developer, how can I solve this problem?
EDIT
I have talked to him about it number of times and even given him written warning
If you can do code reviews -- that's a perfect place to catch it.
We require reviews prior to merging to iteration trunk, so typically everything is caught then.
If you systematically perform code reviews before allowing a developer to commit the code, well, your problem is mostly solved. But this doesn't seem to be your case, so this is what I recommend:
Talk to the developer. Discuss the consequences for others in the team. Most developers want to be recognized by their peer, so this might be enough. Also point out it is much easier to fix bugs in the code that's fresh in your mind than weeks-old code. This part makes sense if you have some form of code owneship in place.
If this doesn't work after some time, try to put in place a policy that will make commiting buggy code unpleasant for the author. One popular way is to make the person who broke the build responsible for the chores of creating the next one. If your build process is fully automated, look for another menial task to take care of instead. This approach has the added benefit of not pinpointing anyone in particular, making it more acceptable for everybody.
Use disciplinary measures. Depending on the size of your team and of your company, those can take many forms.
Fire the developer. There is a cost associated with keeping bad apples. When you get this far, the developer doesn't care about his fellow developers, and you've got a people problem on your hands already. If the work environment becomes poisoned, you might lose far more - productivity-wise and people-wise - than this single bad developer.
As a developer who rarely tests his own code, I can tell you the one thing that's made me slowly shift my behavior...
Visibility
If the environment allows pushing code out, waiting for users to find problems, and then essentially asking "How about now?" after making a change to the code, there's no real incentive to test your own stuff.
Code reviews and collaboration encourage you to work towards making a quality product much more than if you were just delivering 'Widget X' while your coworkers work on 'Widget Y' and 'Widget Z'
The more visible your work is, the more likely you are to care about how well it works.
Code review. Stick all of your dev's in a room every Monday morning and ask them to bring their most proud code-based accomplishment from the previous week along with them to the meeting.
Let them take the spotlight and get excited about explaining what they did. Have them bring copies of the code so other dev's can see what they're talking about.
We started this process a few months ago, and it's astonishing to see the amount of sub-conscious quality checks that take place. After all, if the dev's are simply asked to talk about what they're most excited about, they'll be totally stoked to show people their code. Then, other dev's will see the quality errors and publicly discuss why they're wrong and how the code should really be written instead.
If this doesn't get your dev to write quality code, he's probably not a good fit for your team.
Make it part of his Annual Review objectives. If he doesn't achieve it, no pay rise.
Sometimes though you do just have to accept that someone is just not right for your team/environment, it should be a last resort and can be tough to handle but if you have exhausted all other options it may be the best thing in the long run.
Tell the developer you would like to see a change in their practices within 2 weeks or you will begin your company's disciplinary procedure. Offer as much help and assistance as you can, but if you can't change this person, he's not right for your company.
Using Cruise Control or a similar tool, you can make checkins automatically trigger a build and unit tests. You would still need to ensure that there are unit tests for any new functionality he adds, which you can do by looking at his checkins.
However, this is a human problem, so a technical solution can only go so far.
Why not just talk to him? He probably won't actually bite you.
Make him "babysit" the build, and become the build manager. This will give him less time to develop code (thus increasing everyone's performance) and teach him why a good build is so necessary.
Enforce test cases - code cannot be submitted without unit test cases. Modify the build system so that if the test cases don't compile and run correctly, or don't exist, then the entire task checkin is denied.
-Adam
Publish stats on test code coverage per developer, this would be after talking to him.
Here are some ideas from a sea shanty.
Intro
What shall we do with a drunken sailor, (3×)
Early in the morning?
Chorus
Wey–hey and up she rises, (3×)
Early in the morning!
Verses
Stick him in a bag and beat him senseless, (3×)
Early in the morning!
Put him in the longboat till he’s sober, (3×)
Early in the morning!
etc. Replace "drunken sailor" with a "sloppy developer".
Depending on the type of version control system you are using you could set up check-in policies that force the code to pass certain requirements before being allowed to check-in. If you are using a sytem like Team Foundation Server it gives you the ability to specify code-coverage and unit testing requirements for check-ins.
You know, this is a perfect opportunity to avoid singling him out (though I agree you need to talk with him) and implement a Test-first process in-house. If the rules aren't clear and the expectations are known to all, I've found that what you describe isn't all that uncommon. I find that doing the test-first development scheme works well for me and improves the code quality.
They may be overly focused on speed rather than quality.
This can tempt some people into rushing through issues to clear their list and see what comes back in bug reports later.
To rectify this balance:
assign only a couple of items at a time in your issue tracking system,
code review and test anything they have "completed" as soon as possible so it will be back with them immediately if there are any problems
talk to them about your expectations about how long an item will take to do properly
Peer programming is another possibility. If he is with another skilled developer on the team who dies meet quality standards and knows procedure then this has a few benifits:
With an experienced developer over his shoulder he will learn what is expected of him and see the difference between his code and code that meets expectations
The other developer can enforce a test first policy: not allowing code to be written until tests have been written for it
Similarly, the other developer can verify that the code is up to standard before it is checked-in reduicing the nmber of bad check-ins
All of this of course requires the company and developers to be receptive to this process which they may not be.
It seems that people have come up with a lot of imaginative and devious answers to this problem. But the fact is that this isn't a game. Devising elaborate peer pressure systems to "name and shame" him is not going to get to the root of the problem, ie. why is he not writing tests?
I think you should be direct. I know you say that you've talked to him, but have you tried to find out why he isn't writing tests? Clearly at this point he knows that he should be, so surely there must be some reason why he isn't doing what he's been told to do. Is it laziness? Procrastination? Programmers are famous for their egos and strong opinions - perhaps he's convinced for some reason that testing is a waste of time, or that his code is always perfect and doesn't need testing. If he's an immature programmer, he might not fully understand the implications of his actions. If he's "too mature" he might be too set in his ways. Whatever the reason, address it.
If it does come down to a matter of opinion, you need to make him understand that he needs to set his own personal opinion aside and just follow the rules. Make it clear that if he can't be trusted to follow the rules then he will be replaced. If he still doesn't, do just that.
One last thing - document all of your discussions along with any problems that occur as a result of his changes. If it comes to the worst you may be forced to justify your decisions, in which case, having documentary evidence will surely be invaluable.
Stick him on his own development branch, and only bring his stuff into the trunk when you know it's thoroughly tested. This might be a place where a distributed source control management tool like GIT or Mercurial would excel. Although with the increased branching/merging support in SVN, you might not have too much trouble managing it.
EDIT
This is only if you can't get rid of him or get him to change his ways. If you simply can't get this behaviour to stop (by changing or firing), then the best you can do is buffer the rest of the team from the bad effects of his coding.
If you are at a place where you can affect the policies, make some changes. Do code reviews before check ins and make testing part of the development cycle.
It seems pretty simple. Make it a requirement and if he can't do it, replace him. Why would you keep him?
I usually don't advocate this unless all else fails...
Sometimes, a publicly-displayed chart of bug-count-by-developer can apply enough peer pressure to get favorable results.
Try the Carrot, make it a fun game.
E.g The Continuous Integration Game plugin for Hudson
http://wiki.hudson-ci.org/display/HUDSON/The+Continuous+Integration+Game+plugin
Put your developers on branches of your code, based on some logic like, per feature, per bug fix, per dev team, whatever. Then bad check-ins are isolated to those branches. When it comes time to do a build, merge to a testing branch, find problems, resolve, and then merge your release back to a main branch.
Or remove commit rights for that developer and have them send their code to a younger developer for review and testing before it can be committed. That might motivate a change in procedure.
You could put together a report with errors found in the code with the name of the programmer that was responsible for that piece of software.
If he's a reasonable person, discuss the report with him.
If he cares for his "reputation" publish the report regularly and make it available to all his peers.
If he only listens to the "authority", do the report and escalate the issue to his manager.
Anyway, I've seen often that when people are made aware of how bad they seem from outside, they change their behaviour.
Hey this reminds me of something I read on xkcd :)
Are you referring to writing automated unit test or manually unit testing prior to check-in?
If your shop does not write automated tests then his checking in of code that does not work is reckless. Is it impacting the team? Do you have a formalized QA department?
If you are all creating automated unit tests then I would suggest that part of your code review process include the unit tests as well. It will become obvious that the code is not acceptable per your standards during your review.
Your question is rather broad but I hope I provided some direction.
I would agree with Phil that the first step is to individually talk to him and explain the importance of quality. Poor quality can often be linked to the culture of the team, department and company.
Make executed test cases one of the deliverables before something is considered "done."
If you don't have executed test cases, then the work is not complete, and if the deadline passes before you have the documented test case execution, then he has not delivered on time, and the consequences would be the same as if he had not completed the development.
If your company's culture would not allow for this, and it values speed over accuracy, then that's probably the root of the problem, and the developer is simply responding to the incentives that are in place -- he is being rewarded for doing a lot of things half-assed rather than fewer things correctly.
Make the person clean latrines. Worked in the Army. And if you work in a group with individuals who eat a lot of Indian food, it wont take long for them to fall in line.
But that's just me...
Every time a developer checks something in that does not compile, put some money in a jar. You'll think twice before checking in then.
Unfortunately if you have already spoken to him many times and given him written warnings I would say it is about time to eliminate him from the team.
You might find some helpful answers here: How to make junior programmers write tests?
I'd be tempted to suggest elaborating a bit on what you've tried and what results you got as this may have changed a bit but here are my initial suggestions:
Is it any tests or comprehensive tests? Some may code blindly and do zero tests, but this is rather rare, IME. Usually there are some tests done but not enough to cover most of the cases that would be comprehensive testing.
Group dynamics may help. I'd assume he is part of a team and that the team's view may be of some help here. In a way this is trying to get peer pressure which is usually a bad thing but sometimes it can be used in good ways.
How well spelled out were the warnings? In a way this can seem childish but there is a chance that what you think of as testing may not be the same as his. Do you want nUnit tests, an excel spreadsheet, logs from his computer, or something else as proof of the existence and use of tests? From what you've described there isn't anything to confirm that he did understand what you meant, was going to use tests and provide evidence of doing so.
Check-in policy question. Some places, such as my current workplace, encourage committing often which can mean that one does commit code without tests. Is there a known, accepted and well-followed policy where you are? That's another aspect here.
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 4 years ago.
Improve this question
We're neck deep in a project right now, schedules are tight (but reasonable). Our general strategy is to get a strong beta done, release it for testing, and get feedback from our testers.
Quite frequently, we're being hit by small things that spiral into long, time-costing discussions. They all boil down to one thing: While we know what features we need, we are having trouble with the little details, things like 'where should this message go' and 'do they need this feedback immediately, or will it break their flow, so we should hold off'?
These are all things that our testers SHOULD catch, but
a) Each 'low priority' bug like this drains time from critical issues
b) We want to have as strong a product as possible
and
c) Even the best testing group will miss things from time to time.
We use our product, and we know how our users use the old version...but we're all at a loss as to how to think like a user when we try to use the new version (which has significant graphical as well as underlying changes).
edit - a bit more background:
We're writing a web app used by a widely-distributed base of users. Our app is a big part of their jobs, but not the biggest (and, of course, we only matter to them when it doesn't work). Getting actual users in to use our product is difficult, as we're geographically distant from the nearest location that serves as an end user (We're in Ohio, and I think the nearest location we serve is 3+ hours away).
The closest we can get is our Customer Service team (who have been a big help, really) but they don't really think like the users either. They also serve as our testers (it really motivates them to find bugs when they know that any they DON'T find may mean a big upswing in number of calls). We've had three (of about 12 total) customer service reps back here most of the week doing some preliminary testing...they've gotten involved in the discussions as well.
Watching someone using the app is a huge benefit to me. Possibly someone who is not entirely familiar with it.
Seeing how they try to navigate, how they try to enter information or size windows. Things we take for granted after creating/running the app hour after hour, day after day.
Users will always try and do things you never expected and watching them in action might bring to light how you can change something that might have seemed minor, but really makes a big impact on them.
Read Don't make me think.
Speaking generally, you can't. There's not any way you can turn off the "programmer" part of your brain and think like a user.
And you're right about (c), testing groups don't necessarily catch all the bugs. But the best thing you can do is get a testing group comprised of real, honest-to-goodness end users, and value their feedback. Draw further conclusions from their general comments.
If you want to know how your users will see your system, the closest you can get is usability testing with real users. Everything else is just heuristics and experience, and is also subject to error. There's no such thing as a bug-free product, but you should be able to get a "strong" product with usability testing.
Buy a cheap, easy to use video camera and record your testers using the app. Even better, get some people unfamiliar with the app. to use it and video them. It's relatively cheap, and you'd be surprised what it will highlight.
I like policy of "eating your own dog food"("http://en.wikipedia.org/wiki/Eat_one's_own_dog_food). It brings you one step closer, because you become a user, although you might think like one.
Try to use your app when you are very hurry (e.g. you have someone who waits for a dinner).
You will see all this little things because you have to wait, you have to go back to the mouse of the keyboard, etc.
And also, make your wife use it. Or your mother.
Another useful test : help someone to use it, by phone. If he can't find the button with your directions, that's probably a bug.
The important thing is to get enough information that you yourself can become a "user". Once you do that you can answer most questions yourself.
The way I always do this is to go talk with them about what they need to do, what they typically do, and how they use their current tools to do it. Then (very important) sit with them while they do it. Make sure you get on with them well enough that you can come back to them with questions about how they handle edge cases you think of later (often the answer will be the appalling "we go around the system manually for that").
I will almost always notice something they are doing that is a royal PITA that they didn't bring up because they are used to having to do that and don't know any better. I will always notice that their %90 typical workflow isn't the easiest workflow the tools provide.
You can't really rely on plain old-fashioned requirements gathering by itself, because that is asking them to think like a developer. They generally don't know what is possible to do with your software, what is easy, and what is hard. Also they typically have no clue on GUI design principles. If you ask them for design input they will just tell you to put any new control on their favorite page, until the thing looks like a 747 control panel.
The problem is often that even the users don't know what they want until they are actually working with the software. Sometimes, a small oversight can be a big usability problem, sometimes a well thought out function that was requested by many users sees only little use.
My suggestions to decrease the risk of not implementing the right usability features:
Take a look at users actually doing their day to day work. Even if they use another software or no software at all. You will be able to determine the artifacts they often need to get their job done. You will see what data they frequently need. Concentrate on the artifacts, data and workflows most used. They should be the most usable. Exotic workflows may be a bit more time consuming for the users than often used workflows.
Use working prototypes of the GUI to let users work through a realistic workflow. Watch them and note what hinders them and what works well. Adjust your prototypes accordingly.
If an issue arises in an often-used part of your software, it is time to discuss it now and in details. If the issue concerns a seldom used part, make it a low priority issue and discuss it if you have the time. If issues or suggestions are low priority, they should stay low priority. If you can't determine if solution A or solution B is the best, don't run in circles with the same arguments over and over. Just implement one of the solutions and see if the beta testers like it. The worst thing you could do is waste time over tiny issues, while big issues need to be fixed.
A software will never be perfect, because the viewpoints of users differ. Some users will think that a minor problem breaks the whole application. Others will live with even severe usability issues. People tend to lend their ear to those who argue the loudest. Get to know your users to separate the "loud" issues from the important ones. It takes experience to do this, and sometimes you will make wrong decisions, but there is no perfect way, only one of steady improvement.
If you can, set aside a certain amount of usability development resources for the rollout phase of your software. Usability issues will arise when people start working with it in a real production environment. Sometimes it is not important to present the perfect software, but to solve issues quickly as they arise.
The flippant (yet somewhat accurate) answer to how to think like a user is put a knitting needle in your ear and push really hard.
The longer response is that we as programmers are not normal and I mean that in a good way. I scratch my head at the number of people who still run executables they receive from strangers in emails and then wonder how their computer got infected.
Any group of people will in time develop their own jargon, conventions, practices and expectations. As a programmer you will expect different things from an operating system than Joe User will. This is natural, to be expected yet hard to work around.
It's also why BAs (business analysts) exist. They typically come from a business or testing background and don't think like programmers. They are your link to the users.
Really though, you should be talking to your users. There's no poitn debating what users do. Just drag a few in and see what they do.
A usability test group will help.. tests not focused on discovering bugs, but on the learning curve of the new design, made by a group of users, not programmers.
I treat all users like malicious idiots.
Malicious because I assume all users are going to try and break my code, do stuff that is not allowed, avoid typing in valid data, and will do anything in their power to make my life hell.
Idiots because again I can't assume they will understand simple stuff like phone formats, will run away screaming if presented to many choices, and will not make any leap of faith on complicated instructions. The goal is to hold their hand the entire way.
At the same time, its important to make sure the user doesn't realize you think they're an idiot.
To think like a user, be one. But are these actually bugs that your testers are reporting? Or are they "enhancement requests"? If the software behaves as designed per requirements and they just don't like the way it operates, that's not a bug. That's a failure of requirements and design. Make it work, make it rock solid, make it easy to change and you'll be able to make it what your users want.
I see some good suggestions here, especially observing people trying to use you app. One thing I would suggest is to look at the order in which things are presented to the user on paper forms (if they use these to do data entry from) and make the final data entry page mimic that order as closely as possible. So many data entry errors (and loss of data entry speed) are from them having to jump around on the page and losing their place. I did some work for a political campaign this year and in every case, entering data was made much more difficult because the computer screen did things in a differnt order than the paper inputs. This is particularly important if the form is one that can't be changed (like a voter registration form, a campaign has to use what the state provides) to match the computer screen. ALso be consistent from screen to screen if possible. If it is first Name last name on one form, making it last name first name on the next will confuse people and guanteee data entry errors.
If you are truly interested in understanding users though I strongly suggest taking a course in Human factors engineering. It is an enlightening experience.
The 'right' way to do this is to prototype (or mock up) your new interface features, and watch your users try to use them. Nothing is as enlightening as seeing a real user try to use a new feature.
Unfortunately, given most projects time and resources, this is not possible. If that is the position you are in I would recommend you discuss in the team who has the best grasp of usability, and then make them responsible for usability decisions - but that person will need to regularly consult real users to make sure his/her ideas are consistent with what the users want.
I'd suggest doing some form of usability testing; I've participated in such in the past, and found them quite useful.
If you were writing a ticketing system, for example, bring up tasks, and ask questions like "how would you update this ticket" or "what do you expect to happen if this button is clicked".
You don't necessarily need a full application, either, in some places screen shots can be used.
You could take the TDD/BDD approach and get the users involved before beta, having them work with you on refining requirements as you write your unit tests. We're beginning to incorporate some of those trends into our current project, and we're seeing fewer bugs in the areas where we have involved the users earlier.
There is no "think like a user" technique, get your hands on someone who knows nothing of the project and throw what you have done at them.
It's the only way to see how the look + feel + functionality present themselves to the end user.
Once you shocked that person who knew nothing of the product, listen to all of their idiotic (or so you think they are) complaints, fix them, arrange every silly cosmetic thing they point out (either by fixing the UI or by improving whichever documentation you had)..
and after you have satisfied the person you chose to look at your app from zero knowledge on the subject first round, pick another ...and another... until they stop being shocked when they see it, and they don't get stuck on.. "ok.. what does this do?" kind of phases.
You (as a member of the project, be it the project manager, developer, etc) will never think like a user is my answer to that question.
Old saying: You can make something "fool proof" but you can't make it "Damn-fool proof".
Additionally: When you make something "idiot proof" the world invents a better idiot.
Other than that, I agree with what everyone else said.
Ask someone with absolutely no knowledge, insight or programming experience to use the program and try to figure out every function of the program.
People who would NEVER use such a program are most likely to find bugs.
See it as a new Safari user (or FF) who tries to put the URL inside the search field...
As a programmer you guess no-one would be that stupid (or, well.. unknowing), but people actually sometimes find themselves in these situations. As a programmer, we miss these things.
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.
Does anyone use Accurev for Source Control Management? We are switching (eventually) from StarTeam to Accurev.
My initial impression is that the GUI tool is severely lacking, however the underlying engine, and the branches as streams concept is incredible.
The biggest difficulty we are facing is assessing our own DIY tools that interfaced with starteam, and either replacing them with DIY new tools, or finding and purchasing appropriate replacements.
Additionally, is anyone using the AccuWork component for Issue management? Starteam had a very nice change request system, and AccuWork does not come close to matching it. We are evaluating either using Accuwork, or buying a 3rd party package such as JIRA.
Opinions?
Sweet mother of god is Accurev awful. 300k lines of code? Try it with millions, with hundreds of developers working on scores of projects.
Continuous integration? Sure, that's something that developers can approximate by doing regular merges in, say, perforce, git, mercurial, or any of the countless other tools that actually gets the work done, but it becomes the choice of the developer as to how to proceed. For architects, leads, build engineers, or anyone who actually uses source control to slice and dice, Accurev is horrific.
I went to an "Advanced Accurev topics" talk, and the first tidbit was a large shell command for clearing out Accurev's client-side caching/sync mechanism to correct for when Accurev updates silently fail to pull down files that should be updated.
A Timestamp Optimization checkbox? Deep overlaps? Modal dialogs with only one background process? (That would be okay if those processes were anything other than glacial.) Cascading graphs of selectively configured streams put in place just to be able to pull off components and cross-merging? Updates aren't actually atomic without time-locking?! (honest answer: update again)
Every time I try and do anything serious in Accurev, I feel like I'm playing Russian Roulette at a table with HAL9000, Skynet, and a Speak & Spell. On the line? Four more hours of my life.
Why am I here, griping about Accurev? Because my other machine has taken a full four hours to try to update 10MB of files over VPN. Why? Because some other change has come up stranded and requires some sort of catastrophic resync scan for elements. The worst part? All of these files were on a workspace on the same computer. We're talking about several hours just to get a recently updated workspace to the point where I can put the right notches in the stream history.
One word Accurev review: Avoid
Honestly, I feel like I need to double check to see if I'm using the same tool as these folks that seem to like Accurev. I used Subversion in my previous job and liked it a lot. We never had any issues with it to speak of, and of course the price is right. My biggest problem with Accurev is that it seems they felt the need to be different for different's sake. It uses a completely different vocabulary to express versioning concepts, that even after using it for almost 6 months, feels very foreign to me. It has no fewer than 8 or 9 states any given file can be in, compared to about around 1/2 as many for Subversion. The GUI is crappy and slow, and the IDE integration plugins are sub-par. I had assumed that at some point I would "get" Accurev and see why it's so much better, but that has yet to happen. My advice is to stay away.
I have used AccuRev for nine months and I anxiously await the day I use it no more. My one line review is:
It's like source control written by developers who have read about it in a
book, but have never actually used it before.
Basic concepts are missing or extremely complicated. Example, I've just lost 8 hours work because there's no good way to "revert" a change once it's in a stream. You can "purge" that transaction - but thats it its gone, you can't then cherry pick the changes you really wanted.
The GUI is slow, bloated and inconsistent. Warnings are cryptic eg "error merging element id 1234556". Every single dialog box is modal. As one poster said, there are 9 states a file can be in - but what's more, you must manually click through a list box of 9 options to see the setting for each file.
The streams model sounds like a good idea, but the default behavior of "inheriting" changes from a parent stream is actually incredibly bad in practice. Just say the word "Deep Overlap" to anyone who has really used AccuRev and watch them shudder, turn pale, and/or faint. Making the streams is very easy, but actually merging them with any meaningful differences is arcane and non-deterministic.
No one has mentioned this, but the whole system of "include/exclude" rules to manage file and directory filters is completely broken. This system lives outside the transaction system so there's no way to revert, track history or reproduce changes to a live source stream - for example when Johnny Intern decides the "core" library isn't useful to the entire development team.
The only reason I can account for Accurev's popularity is that it is optimized for the "Demo to Management" case. We're using AccuRev for serious software development - dozens of projects and many more developers. The streams and the GUI look great but after a few weeks use varnish comes off revealing a old, busted, mechanical-turk like system.
Stay far away from Accurev - use Git or Mercurial if you want something modern and free, or Perforce if you want something rock solid, well-supported but expensive.
EDIT:
As a postscript here's one of the many examples of the lack of care and general shoddiness in the UI:
The default difference viewer has its numbering "off by one" - for example if you have 2 diffs in a file - the viewer shows diff "0 of 1" and diff "1 of 1". I mean, really, would you feel comfortable trusting your code to a system that exhibits such a stupid and easily fixable bug.
I worked on (and administrated) AccuRev for more than a year lately, and most of my impressions are very good.
We evaluated it alongside with "Plastic SCM", SVN and "ClearCase-UCM" (that we already owned and used), and decided to dump ClearCase and SVN (both were used in two different groups) and to purchase AccuRev.
First, the stream architecture is much more solid, easy and safe SCM method than the old branching architecture that all the other tools are tied to (yes even ClearCase's "streams" are eventually a wrapper of branches). There's a lot of articles about the differences in their site, you can search and read about it to make it understandable. (Try this link, and this one too)
The timesafe architecture - you can't delete anything from the depots (=repositories) database. I saw tools that this operation is possible with the proper admin permissions. In AccuRev you will use internal commands in order to change or fix a mistake you made, which in turn will be recorded as a new transaction also. Very smart very safe.
integrations! AccuRev integrates with so many tools (to give you ALM bundle) - bug tracking tools (like JIRA, ClearQuest), IDEs, testing tools (quality center), and if you can't find one you can write your own (they provide Java/Perl/XML/CLI SDKs)
Change Package, I don't know about you, but I can't stand SCM tools that doesn't supply change management (did anyone said SVN?), like ClearCase "activities", and AccuRev's "issues". It's a must for my opinion, and one of my CM "best practice". And they can be integrated with your bug tracking tool too, so your users can work on real tasks like features and defects.
the support is just amazing. As a former client of IBM (because of Rational ClearCase is now part of IBM), the shift to AccuRev was simply awesome. During the evaluation they gave numerous on-line support to understand how we want the tool to act for us, so we tweaked it together even before we payed a cent. And they kept that degree of responsiveness after that evaluation period too; We had some problem during an upgrade from 4.5.4 to 4.6, in just a couple of hours (while the upgrade is still in process) the support guy contacted me back, suggested a few tips, connected to my desktop and finally fixed the problem before any other company's support would even started to try to figure who you are. Of course that if you choose open source tool than you're on your own!
Also the tool comes with help system, which can be even too verbose sometimes. And don't forget the forums (especially on cmcrossroads) that are very good in supplying rapid answers too.
And there's so many more....
Of course there are also drawbacks (which software is perfect?) - I would like, for example, to see the file(s) <-> issue(s) association during check-in too, like in ClearCase, not just in "promotion" like it is today - but IMHO they are really minor.
So, as you can understand, if you read it all, I'm a big fan of AccuRev, and I'm highly recommending it. IMHO, it is today one of the best SCM tools you got the chance to work on; modern, wise, easy and strong.
My current client uses Accurev for SCM and after a few projects using a DVCS like Git or Mercurial, I can honestly say that using Accurev is about as enjoyable as closing your face in a car door.
The GUI for Mac and Linux is god awful slow. You can forget using the refactoring support in your IntelliJ or NetBeans IDE, if you use Accurev...that is unless you are going to write your own plugin.
Oh yea...let's not forget about this little chestnut ==> evil twin.
On a positive note, it could be worse...it could be Clearcase.
Accurev sucks! It's overcomplicated for the price of productivity of the team.
I've worked with several SCMs and the idea of accurev is great but not practical. It's Merge Hell with a hierarchy that looks good in the UI but is pain to deal with when it comes to real life.
Specially when you refactor your code (something that some people actually do everyonce in a while) and you get in a mess when a defunct file is not promote all the way up. Or even worse if somebody else overrides a defunct file and creates a new file with the same name....etc
The UI is incredible terrible. Which honestly doesn't matter how good you think the backend is. You will still use the UI (I use the VS plugin which is half decent except it freezes the IDE sometimes, nice huh!).
If you live in the 80's and are planing to use the command line for you day to day use, then i guess you can avoid the UI. If you have an integration build server then of course you have no choice but to use the command line (No native tasks for MSbuild/ANT/NANT that i know of). I just heard that they are doing some work with http://www.electric-cloud.com/. Don't know anything about it still.
Accurev is new therefore there has little resources available online as apposed to svn which you would find tons of integration work that was done by hundreds (with jira for example).
If you are a manager. Accurev will make you feel good looking at the streams, because it does look pretty as long as you dont have to deal with it..
If you are a developer, (a junior developer will not care much, he/she will do whatever you ask them to do)
If you are an architect, refactors a lot, re-addresses architecural descisions...etc you will find accurev as your worste enemy, moving stuff around is pain. Very anti-agile if you ask me. It's not fluid..
If you are a build engineer, you will find it PAIN to get all the developers into a procedure, which you will have to do if you use accurev (ex. promote their code to the agreed upon stream in preperation for a release)....
CRM is supposed to make things easier... I dont see Accurev at this point doing that.. It's still not mature enough, If you want to be a pioneer and strugle in the hope for things to get better..go for it..
Otherwise, don't re-invent the wheel and go with something more established with much more case studies and applications. Because to be practical, what accurev claims to offer that differs is not worth it when you deal with it's pains on a daily basis...
We've been using AccuRev for a few years now. It's a serious improvement over our last tool (Razor) and while I'd recommend it for others- it does have a few drawbacks.
Benefits:
The stream based interface is quite intuitive. I make snapshots every second week and have a number of ongoing development streams branching off the snapshot.
Moving changes between stream is really easy, just select the change, send it to the "change palette" and select the destination stream. It guides you through all the files that need to be merged.
The command-line utilities are great. We've managed to script most of our release generation around it.
Integrations for Visual Studio, Bugzilla, etc...
Drawbacks:
As monjardin pointed out, the client GUI can be slow. I use the windows version for all my history/stream searching since it's much faster than the X11 one. Of course, the GUI's written in Java so performance obviously wasn't their first concern.
It's starting to get slow for really large databases (I'm talking over 300,000 LOC), although they've apparently addressed it in today's release of 4.7.
We opted to go with the cheaper license and not get the change packages feature (I can't see them working that well anyways, as the entire idea of promoting individual changes flies in the face of continuous integration). So far it hasn't hurt us.
Overall, for the price you pay it's a nice tool. We evaluated ClearCase, MKS, Spectrum and Subversion during our trial period. Subversion may have been a good choice, but it was still pretty green when we were evaluating. I've never heard of Plastic before, but I regret not evaluating Perforce.
Also, I understand that the engineers over at Trolltech (makers of Qt) have recently switched to git. I'd be interested in checking that out as well.
We use AccuRev for 4 years already. I hate it very much, mostly because of its horrible GUI. Several years ago AccuRev sent a survey for their clients to fill and at the end of the survey there was a field with suggestions. I started collecting things which annoy me the most, and below you'll find what I have now. Unfortunately, it's full of AccuRev terminology, but I think you'll get the idea anyway.
Accurev GUI possible improvements
Working with history
When examining history, a developer most often wants to see diff to previous transaction/version. This should be as accessible as a double click. For example double-clicking on file in transaction log could open diff to previous version. Double-clicking on a file in Default Group filter could open diff to backed, double-clicking on a file in Modified search could open diff to most recent. That would save tons of time.
Common experience is that developers rarely open files for editing from within AccuRev. Rather they very often diff files, then revert or promote changes. So double click should not open files for editing, it should diff them instead. This may be an option in preferences, so different people may decide whether they want double click to diff files or open files.
It should be possible to select two transactions in stream or workspace history and perform a file diff between them.
Overlaps merging
Merging overlaps in a stream requires performing "Deep Overlap" search in a workspace that takes much more time than to search overlaps in specific stream. Then it is needed to sort overlaps by overlap stream and merge only those from specific stream. There should be more convenient way to perform merging overlaps in stream. For example ability to limit deep overlap search by specific stream and do not show overlaps in parent streams. Limiting Deep Overlap search by timelocked stream is not very useful if you are several streams under this timelocked stream or there is no timelock on parents at all.
Now there is a simplified way that involves creating change palettes, but it is still not convenient. Merge menu item should be available at stream level if there is a workspace under that stream that may be used for overlaps merge.
Annotate tool
Annotate tool is very awkward:
using slider at the top to browse different version resets position in the file that is VERY annoying for large files;
should be able to open history at the specific transaction directly from annotate tool. Now developer needs to remember transaction# and search for it in stream history (also need to search for the stream where transaction was made).
Stream Favorites
Context menu item "Add to stream filter" was removed when new stream favorites were introduced. It should be possible to right click on stream and add it to one of the stream favorites (2nd level context menu, or dialog may pop up). Now it is very annoying to edit stream favorites, particularly when you need to have 2 similar sets of streams.
Stream browser
It should be easy to copy stream name to clipboard. Now you need to open "Change stream" dialog for that. Ctrl+C in stream browser could copy the name of selected stream to clipboard.
There is no way to copy stream name from stream view. Right click on tab could copy stream name in clipboard, or show context menu with "copy stream name to clipboard" item in it.
Diff and merge tool
Shows only the first different character in line, not the whole line difference, does not highlight syntax. Luckily, diff tool may be easily switched to external tool, so this is minor.
Other suggestions
Option in preferences to enable Multiple columns sort mode by default.
It would be nice to save not only the latest keep/promote log, but at least 5-10 older ones.
File extension column in stream or workspace view with ability to sort on it would be great.
Reordering tabs would be nice.
Very small font in keep/promote/lock message under Windows, it's unreadable. Increase the font size or allow user to change it.
Implement more convenient way to locally ignore files, environment variable is not very useful (user may want to ignore different sets of files in different streams/depots).
For the last 3 years AccuRev added 3 things from this list (I removed them as they are already implemented):
Hardcoded (can't be customized) keyboard shortcuts for most actions
Made it possible to call diff for several files from transaction at once (before that one should have to right click on every file and call "Diff to previous version" from context menu.
Added search for text to Annotate tool. But because of the position reset when you try to switch to different version (see above) the Annotate tool is still unusable.
Besides GUI there are fundamental flaws in AccuRev in the whole:
Difficult to update backwards
You can't easily update backwards. There is accurev update -t <transaction-number> command, but if you updated to transaction 100, you can't update to transaction 95 using accurev update -t 95. In order to do that you need to set up time lock on your backed stream (which will introduce transaction in AccuRev) and update your workspace.
Deep Overlaps
When you update you may happen to have invalid state of sources without any notice. This is because Overlaps feature. Overlap is basically a conflict (when file is changed by both you and them). If you have overlap in your workspace, you'll need to merge it before you are allowed to update. But if you have overlap in the stream, under which you have your workspace, you won't have any notice about that, but overlapped file won't be updated in your workspace. Consider the following stream structure
[Depot Root] <- [Team stream] <- [Your stream] <- [Your workspace]
Let's say you changed foo.cpp and promoted it to [Your stream]. After that someone from your team changed both foo.h and foo.cpp, let's say added method to the class Foo, and promoted the files to [Team stream]. After you update your workspace, you'll get new version of foo.h (because you didn't change it), but you won't get foo.cpp because it's overlapped in [Your stream]. So, your update will go clean, but linker will complain about unresolved symbol Foo::NewMethod if you try to build after that.
I've been a long time Accurev user, and have recently moved to a job where I'm using Perforce. I gotta tell you, I wish I had Accurev back. I do agree - the UI is slow and has problems.
However there are some truly AWESOME visualization tools in there. I can't believe that anyone would look at the version history browser and not fall in love! The stream browser is a great simple tool to understand what is going on in your development organization.
Also, dirt simple to administer. Accurev is actually one of my favourite tools.
One of the best days I've ever had at my current job is they day we ditched Accurev and moved to Subversion. Accurev uses overly complicated concepts. Like one of the commenters above, after working with it for years, I still didn't understand the different states that artifacts could be in. It seems that Accurev's greatest asset is its whitepapers and stream visualization, both of which are v appealing to management but does nothing for developers. I use Subversion, Mercurial and Git for various projects and would recommend these tools over any other.
Accurev is anti-agile tool:
Main idea of Accurev is to use different streams for different teams, so, changes made by team1 won't affect team2.Sounds good, but in a real world we all know that at the end we have to merge the code from both teams and believe me it's nightmare in Accurev. The more changes both teams will do in their streams, the more time everybody will spend on merging at the end. It's the same if every team will do their development in the separate branch using SVN and trying to merge everything after 1 month of development....Basically Accurev creates late merge price and you are going to pay this price for ever if you will choose Accurev for more than 1 team.
In order to fix problem created by point 1 people decide to refuse from cross functional teams in favor of functional. They even provide argument to support this idea, like "knowledge expertise" principle. In other words when you don't have cross functional teams (and Agile as well) it's easier to have experts for particular part of the system, so they will perform code reviews better and act as "information/design/implementation experts". We all know that information expert is an anti-pattern not only in Agile, since it's better to spread the expertise in order to avoid knowledge bottlenecks in development.
Put me in the anti-Accurev camp. We moved to it recently, and it's been horrible. We have a number of quite large projects, and Accurev seems to be almost unusable for the quantity of files we have. Over a VPN, forget it. It takes forever to update, the cross-stream management doesn't work in any intuitive way, the UI is complex and slow.
Additionally, support for it in a number of tools we use is either non-existent or poorly implemented.
Add the various bugs that keep popping up, and I'd say we wasted a great deal of money for something that is done much better by open-source software, such as Subversion. We still use CVS for some projects, and even it is so much better for normal operations and workflow that I'd pick it over Accurev.
Another big thumbs down for Accurev. Every simple operation seems to become so horribly complex - cryptic error messages send you scattering to manual, only finding theoretical explanations about concepts that shouldn't have existed in the first place.
UI is so slow and unresponsive it makes you want to gouge your eyes out.
Stay away.
Accurev has some great concepts; but suffers from:
1) many many inconsistencies in the command-line interface.
2) many bugs and nuisances in the application/interface. E.g. their time-safe property is not actually time-safe at all because of several bugs that affect snapshots and pass-through streams.
3) major bugs in critically important features... As above; time-safe bugs; bugs in merging by issues.
3) they are a year behind where they should be, because they wasted a whole year on trying to move their backend to a database - this will be version 5 which may never see the light of day.
4) The marketing is excellent; but the product does not live up to the marketing hype
5) every release has had major critical bugs that has required them to release immediate hotfixes. This has been a major disruption for us. And these aren't minor bugs.
6) doesn't scale well... takes up a huge amount of disk space and gets slower over time
Having said all that; it's still a good product; but if I were to do it all again I'd consider git instead.
After 4 months, my very negative opinion hasn't changed at all. While Accurev has some very nice concepts, the slowness and complexity far outweigh the advantages, at least for us. Aside from the usual complaints about the GUI and the obscurity of a number of features, one of the absolutely most annoying faults is how many hoops you have to jump through just to update a workspace, made much worse by the inability to update only one directory (or directory tree).
A typical update consists of waiting a loooong time to be told you have overlaps. Of course, you aren't told what the overlaps are. So, you have to do an overlap search, wait another loooong time, resolve the overlaps, do another update, wait a looooong time, and hope it worked this time.
Some of our remote developers update as infrequently as possible because the update time over VPN is absurd. Granted, we have an enormous number of source files across a number of products, and if we reorganized everything we could probably improve performance.
However, we hired Accurev (at a significant cost) to come in and tell us how to set everything up. Still sucks. Aside from that, we really shouldn't have to reorganize the way we work with our sources to suit a source-code-control system. It's a tool, not a business model.
Lastly, we've been trying out an Accurev plugin for IntelliJ, written by Accurev. It works just as poorly as the rest, and, while Accurev has been very responsive about fixing the plugin, we aren't their QA group, nor did we sign up to be an alpha test site (yes, it's that buggy). We finally gave up and wrote our own plugin that actually works.
#Steveth
The Interface is lousy...However the streams model is very innovative.
Being able to create a stream for a new project off the trunk stream, and having 5 developers working on it, and not having any form of merge collisions when we merge that stream back into the main trunk is unheard of, yet it works well in Accurev.
At a previous employer we reviewed Accurev and Plastic SCM. At the end of the day, I was not impressed with Accurev's interface, or the so-called "streams". We went with Plastic, and nobody complained.
#Jonathan
The streams are interesting,but I don't see how any version control can magically avoid collisions when two people touch the same code in the same file. Accurev's model was intriguing, but at the end of the day, nice clean branching and merging with a drop dead easy interface made Plastic the choice for us. Plastic's timeline view (I forget the actual name), showing the branch/merge/check-in history made it very simple to review the history of the project from a bird's eye view.
Accurev is simply the worst tool I have ever used.
Subversion is very good, esp if you are migrating from cvs.
My company ha been using Accurev since early 2010, coming from StarTeam before that and CVS in the very distant past. I haven't used CVS (having been on a different team at the time) so I have no comparisons there, and I never bothered to learn StarTeam too intimately.
Since then I've also played with both the CLI and Tortoise versions of SVN, Git, and Mercurial (Hg) in my free time. I plan on giving Git a more thorough go at some point, but I found Hg to be much more intuitive and easy (at least under Windows). Anyway, like I said management saddled us with Accurev and after spending time to get fairly well acquainted with it (GUI and CLI both) as a developer... I absolutely hate it.
Someone earlier in the thread summed it up as software written by devs that had read about SCM in a book but never used it... I agree whole-heartedly but you also get the feeling that they had the same level of experience with GUIs, efficient processing, etc. (In fact, I see that Accurev has a new product called "Kando" based on Git...sounds like they've finally realized how bad their model is. But to quote a coworker "I wouldn't trust anything written by the same team at this point"... I have to wonder if it is a coincidence that there is a baby-wipe product named "Kandoo"...)
Ok, obviously I don't care for the product. If you've spent the time to read this thread, then obviously there are quite a few folks with similar views on it. But I wanted to share some of my own gripes that I've had with it over the last few years as well -- btw if it helps anyone, I think we were using v4.7 previously and have been on v5.3 (?) now for quite some time.
My biggest beef with Accurev is how horribly slow and inefficient it is. Notice I didn't use the word GUI -- I've tried both GUI and CLI-- the slow parts are on the server, so you're screwed either way. It seems like I see one of those damn modal dialog/status bars at every turn... I switch tabs -- bam!: processing, please wait. I reparent a stream -- oh wait just another minute. For "Updates" I expect it to be a little slow (although sometimes it gets annoying when it screams "Overlap" [aka a conflict] at me when I happen to have a file with IDENTICAL content to what it's pushing down). I change directories browsing to a path... processing, processing, "oh you want to go down one more sub-folder"... let me process that some more. You get the idea.
Is that my only beef? Hell no.
1) For the merge tool, I've had the "ignore white space" option checked for years, but I can only ever recall it working ONE time (for example, say we're talking about about comparing say 2 versions of a JSP where I converted spaces to tabs or trimmed some trailing white space or something). Why is this an issue? Because it becomes pure torture for every other developer that looks in the history and wants to see what REALLY changed. If they can't get implement this correctly, don't put the F***ING option there. (Note:using WinMerge as an external compare tool, with appropriate settings works fine)
2) I've had instances where checking a file into one stream and then needing to put an IDENTICAL copy of that same file into another stream (using the same issues #) causes it to throw a temper tantrum. If I use the wrong issue #, it goes in with no problem. This is probably an isolated case (and maybe due to other poor process decisions my company saddles us with) but I thought I'd mention it for completeness.
3) The history? All stored on the server. Translation: If you enjoyed waiting for it to switch tabs, create/reparent a workspace, and update then you're in for more of the same when you want to view history.
4) The way it's exclusionary rules are done is not only terrible but also pathetic. Under Windows, you actually have to create an environment variable where you can create some exclusions to files that you don't want to show up. IT DOES NOT SUPPORT REGEX. I've seen several other SCMs that offer much better approaches (I'm fond of the the ignore files used in Hg. I think there is something similar in Git too) -- not only are both regex and glob patterns supported, but defining this in a FILE is more system-friendly and much easier to edit that putting it into an Environment variable. Not only that, but it seems that the ignore filters are iffy at best. The way our projects are defined have the build folder under the project folder (which is source controlled) and trying to exclude all folders under the the build folder doesnt seem to work -- most of them still show up in my "External" filter even after setting up rules.
5) It's check-in process (a "Promote") also seems to run with the theme of slow and inefficient. We use an external ticket system (not AccuWork... our ticketing system has its flaws but after using AccuRev, I can't image that product to be much better). Anyway, when we say "Promote [this file]", first it pops up with another modal dialog (after the required waiting, while it does more stat processing), then it presents a list of ALL tickets it has pulled (there are a lot...too many to reliably find anything). Next, we must enter our ticket number from the other system, and wait some more while it takes forever to find a match (I thought it already pulled the list...geez). Finally, it will display the matches, then we pick one and tell it to promote using that ticket number. After yet some more waiting, we're finally done.
I could go on but I'll stop there.... this post is getting too long. Instead, let me sum up Accurev in my own way: After having to wait for all these slow annoying "Stat processing", etc dialogs during an issue where we were trying to quickly get a fix out, I came up with a new slogan for them: "AccuRev: when seconds count, your fix is only minutes away".
Since management won't get rid of Accurev (I know they won't go for anything without Enterprise support but I've begged for them to consider anything else: SmartGit...Kiln...Perforce...), I have been using TortoiseHg to locally version control my files (in addition to Accurev). It is a little more work. But for those saddled with Accurev, it makes life so much easier. You get: better diff management -- MUCH MUCH easier to see and review code changes after an "accurev update", the ability to view some history without waiting 10 years for the server, ability to share directly between you and another dev (assuming they also install it), ability to revert/restore your changes if you accidentally wipe something out while trying to get clear of Accurev's merge hell ("Overlapped" files), and even more if you can get the rest of your team using it.
EDIT: Forgot to mention, during a conversion with our build engineers I was told that while Accurev has a Java API that you can develop for, it apparently requires purchasing some sort of additional licensing. I can't confirm this since a) I can't find pricing anywhere on Accurev's website* and b) I doubt like hell they'd tell me at work...
*Kinda weird considering I can find some sort of rough pricing for Perforce, Kiln, StarTeam and SmartGit quite easily. I usually get a sketchy feeling when some product won't list any sort of price up front, guess it shouldn't surprise me too much that Accurev falls into that category...
Well, all I can say is that I completely agree. The back-end is great but the UI sucks. The stream functionality is great because it makes merging no brainier as all changes from parent streams are automatically propagated to all children. I wrote a post about Accurev UI that explains most of the shortcomings I've come across for last 2 years.
The sort answer:
Use the latest SVN server and SmartSVN (the community edition is free) as a client.
You will not pay anything and you can get everything you need.
The gory details:
BTW the feature of imposing the change management rules during checking is trivial to write as a SVN hook. We did it in a couple of hours, in one hundred lines (or thereabout) of code - it works wonderfully and never broke. It integrates SVN with Bugzilla and imposes rules such as:
In order to commit you have to enter a message
In order to commit you must have entered a Bugzilla ID that is in a "Valid" commit state.
... and so on, you can build your own rules to your heart's content
Accurev seems to be marketware to me ... lousy GUI client ... very slow (we had to upgrade the HW to make it actually work effectively), and of course ... you have to pay for it! Ah yes, if you do use it, I hope that you do not have to replicate your server between some place in the US and some place in India :)
Perforce is more robust but it is not very easy to administer. In any case, it is a superior product in comparison to Accurev.
VSS and stuff like that should not even be considered as "version control" systems when it comes to writing professional software (typically, enterprise software) in the 21st century. That's like writing your reports on a typewriter ;-)
If you know what you are doing (with your software) then SVN will be a robust and efficient solution for you. With (at least) two robust and efficient revision control systems in existence today (SVN/GIT) there is very little room to justify working with a proprietary solution; some reasons could be "inertia": you have it, you don't care paying for it, and you didn't have any major issues -- in other words, it works for you.
I use SVN everywhere, when it didn't exist I was using CVS, and before that ... no I am not going to tell you how old I am ;-)
Hope this helped ...
Ciao.
I've been the SVN and Accurev administrator for a time. Accurev took a long time to grow on me - about six months, but I like it now for a corporate enterprise environment. Here's a few things to consider.
Pros:
Personal code history
The code changes are kept on the server when the users performs a keep. The keep is personal to the user and doesn't distribute to other users until a promote command is issued.
The code performed by a keep is kept on the server and available even if the user performs a revert operation.
In most cases, promoting the code to higher streams for distribution is fairly simple.
Administration is fairly simple
Installation works well
Performance is much improved on version 5.3 which changed the backend to a PostGres database
The CLI is rich and extensive
Cons:
A real clunky user interface
Resolving overlaps can be complex, just like conflicts in SVN
However, like any complex tool, your appreciation will increase the more you understand and know about it.
I used AccuRev at a previous job and didn't have any problems with it, but I very much prefer Subversion (even without comparing the price difference). I remember the client GUI being pretty slow too. Also, I do recall that the GUI just called their command-line utilities to interface with the repository. So, it probably won't be that hard to use those interfaces for your DIY tools.
I have used Accurev for one year. I don't like it. Here are some problems I encountered:
1. Its GUI is terrible: it's so slow that each time I switch between tabs (streams and workspaces) or perform some actions I have to wait for several seconds. It sometimes gave you a confusing error message that could not help find what's wrong.
2. It has so many concepts that you have to spend much time learning Accurev itself.
3. I once encountered such a problem: I have a version controlled file modified by our build process. Later my teammate moved that file to other location in his workspace and promoted the change. When I run "accurev update" it simply told me "some file has been moved" and everything looked normal. But actually the command stopped at the moved file and no longer updated other files. It's very confusing - your update command did not update the worksapce but you have no idea about it. The only outputed message "some file has been moved" looked just like other verbose output. It did not tell me my update failed or aborted or something else.
Before that I used SVN and ClearCase. SVN is a great tool, simple and easy to use. And I did not have so many complaints about ClearCase. Accurev is really frustrating...
I've just come across this discussion and thought I would share our experiences with AccuRev.
We have been using the Dimensions SCM from Serena for around 8 years. Two years ago we had a major problem integrating our India based Development team with our UK Dev team. It was clear that we were not going to meet our needs with the current system and hence we set about evaluating a number of options. I discuss all of this in this article How We Integrated Our Offshore Dev Team.
Our experience of using AccuRev has so far been very positive.
It is easy to setup and administer.
Users are able to get going very very quickly (especially important for the India dev team)
We've never had a problem with speed (in fact this is one of the main plus points for us)
The replication works like a dream
I do agree that the UI can be a bit clunky (especially the Unix client). I am hoping that it will be better in the latest version when we update to that next month.
All in all I would say that this was one of the best decisions and purchases we have made.
Note: I am an AccuRev user and I like it very much. I have already upvoted a few answers here, and would like to add:
I've just recently stumbled over this "review" of AccuRev in the book Continuous Delivery by Jez Humble and David Farley:
[Chapter 14, p 385]
Commercial Version Control Systems
(...) the only commercial VCSs that we are able to wholeheartedly recommend are:
(...)
AccuRev. Offers ClearCase-like ability to do stream-based development without the crippling administrative overhead and poor performance associated with ClearCase.
(...)
To which I might add that I never have used ClearCase, but I am the AccuRev admin around here, and it is indeed very little work to administer. (WRT performance, this question might give more insight.)