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 3 years ago.
Improve this question
I'm working on a new project and we're using a pretty nice stack. NHibernate, Spring, MVC... the list goes on.
One thing I've noticed tho is that in the 6 months since we've started we've had a new release of NHibernate, a new release of a third party control toolkit and Windows 7 is on the horizon.
We've had problems before where being stuck on an old version of a technology has cost us dearly, so I'm wondering what are some techniques we could use to help ensure that our transitions to the latest versions of things are as painless as possible?
Quite simply make it a priority and upgrade as you go along. If you keep up-to-date with the latest version, there will be less breaking changes than if you have to update 5 versions at a time.
Perhaps create a branch and do a test update to betas so that you are aware of forthcoming problems when that version RTMs (if using betas is a concern to you).
I agree with the other comments here about updating often. If you wait too long it will be enough work that you will notice it in the project productivity.
The way we do it is the following.
One person on the team, gets the latest version, and makes sure that all tests run.
That person the upgrades whatever dll's / tools are to be upgraded
He also documents the upgrade.
Build all code make necessary changes for it to build
Run all tests, make sure they run.
Manual smoke test of UI
Send info to rest of team with doc of upgrade
Checkin / make sure it builds on build server
This way we do not loose productivity of the team during the upgrade. Note this would be much more difficult without unit tests.
"update early, update often"
if you wait it will be more and more difficult so put high priority on updating the system. Developers mostly like to be on the bleeding edge so they will not mind too much, key challenge is to sell this idea to management.
It is always good to do step by step approach where you upgrade one by one tool. Then it is also easier if you need to roll back to older version. Big bang approach is more difficult and lots of things can go wrong.
Lets be realistic, every update will cost you time and also your team to do the switch to the new tooling version but after some time team learns to deal with it and level of stress when switching the versions is much less.
Speaking from a management point of view, don't upgrade unless there is a compelling reason. You have to look at what the upgrade brings to your project. If there are no benefits to the upgrade, don't do it. Obviously this isn't a hard and fast rule, but most teams I know don't have time to spend upgrading systems for no reason, they are too busy with feature requests and bug fixes. I recommend working in upgrades on the following basis:
The new version runs
[significantly] faster or more
efficiently and your
customers/clients will see this
improvement or it will reduce your
immanent hardware needs.
Features
have been added that you or your
customers/clients want and can take
[immediate] advantage of.
Security enhancement for a security
flaw that affects your current or
immediate future architecture.
License/support reasons. If you are
at the end of your contract then you
will probably want to make the final
jump to the last version of the
software that you are entitled to
while you still have support for the
upgrade. Alternately if you are on
such an old version of the software
that finding support documentation
for it is difficult then upgrading
is certainly called for.
Some aspect of the project that you are
working on is directly impacted by
the software that could be
upgraded. If you are already going
to be working with it and testing
the functionality, it is probably a
good time to upgrade and [probably]
won't add significant load to the
project.
Major changes. If your
project or the software it relies on
have undergone major changes then it
is probably a good time to add the
update(s) into your project plan.
Major changes implies a more
difficult upgrade path and should be
persude on a scheduled basis rather
than having to be shoe horned in at the last minute due to a needed fix or enhancement.
Specific reasons not to upgrade:
Software, installation, and regression testing costs money. Hence the need for a compelling reason to upgrade.
New software is often buggy or has unknown "features." For this reason many choose to stay one version behind the latest release.
Newer versions can often be slower than previous versions, this is especially true for small updates and patches.
Compatibility issues. Upgrades break things, it is better to skip as many incremental upgrades as possible in order to avoid updates that break compatibility, compatibility that may be fixed in the next update.
I recommend keeping a list of all software that your project utilizes along with their version and last upgrade date (along with other important information such as licensing info, support info, etc.). Evaluate every item on this list once a year in order to insure that you don't miss any updates that match a reason to upgrade that you may have missed. Software on this list with an old version/date and a newer version available may be incentive enough to convince management that an upgrade should be done.
Related
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
Do you know of any agile process that is created for code releases? One of the main theme of agile is frequent releases and each company/client would have their own test/approval processes that control code releases. Most of the time these slow down the pace of "frequent releases"
Currently we have a proprietary tool based workflow. The team who needs a code promotion needs to create a promotion request to one of the final UAT servers. Once this is complete, and once tests are done, certain customers, technical/non-technical managers need to approve, then it goes in to production deploy stage. Meanwhile no sprint planning meeting or anything of that sort.
What is the code release process (Which is agile) that has worked for you?
Why is there no sprint planning meeting of any sort while the workflow proceeds? Tag your repository and get on with the next release straight away. If you need bug fixes on the candidate release, branch from the tag and fix them. The approvals workflow and final UAT testing should not either involve or delay the development team. (Excuse non-distributed SCM terminology if you are actually on something like Git or Mercurial.)
If you take an Agile process like Scrum, the release output is "releasable software" not "released software". If you have an overhead getting stuff released to production, then it can just happen in parallel. I should add that the majority of the testing should have been as part of the sprint - perhaps you need to revisit exactly what testing is done when in your cycle?
If you are having problems testing "big" releases then your release cycle is to long. The underlying principle of release often is that often == smaller releases. If you are having problems and you are only releasing small sets of features that don't take long to test then it is your release engineering team that is the bottleneck, their waterfall approval process needs to change.
Release into a common dev environment all during the sprint, release to a QA environment during the sprint.
Release into a reference environment at the end of the sprint for the demo of only the completed ( and tested ) features.
Release to production whenever the product owners want.
Risk of bugs should not be an issue, since bugs should not have any correlation to the frequency of the releases, actually more releases should actually mean less risk and less bugs. Testing should be done during the sprint, not after. If something isn't fully tested and might be buggy then it isn't done and should not be demoed, much less released to production.
In the end release to production should be the product owners call. A politicized waterfall release engineering process almost never keeps bugs out of production, it just makes the show up later rather than sooner. Managers ticking a check box on a form with their "ok" isn't keeping buggy code out of the customers eyes. Frequent releases to QA during development will. Testing should not be part of the release engineering cycle, it should be part of the development cycle.
This depends on how mission-critical your product is. By "release", do you mean launching your life-critical software to a hospital? Or is it a casual gaming website?
If your work is mission-critical or life-critical, agile may not be able to work for you. In that case, you may need to do more formal testing before deploying.
If you work on a website that isn't mission-critical (and this is often better than not!), you have the freedom to be a little buggy. This helps you iterate faster and re-release again and again.
For that kind of product, which agile is perfect for, let developers test themselves, let clients see the results, then launch to a small group of users (hopefully randomly selected active users -- hallway testing) as soon as possible -- if it's a small thing, even to your whole userbase. On a web service, you can do this quickly and fix it without going through much pain.
i wonder if Doctrine 2 is stable enough to use for a production project?
i guess the project will be finished 3 months from now so maybe then Doctrine 2 will be released in a complete version.
i'm wondering if its smarter to use learn and use doctrine 2 right away instead of learning the current version and then convert everything to version 2. cause i've read that the difference is huge between them.
thanks
I've been using Doctrine 2 in production for a few weeks now. Performance wise, it is much speedier than Doctrine 1. And it's much easier to develop with. I've had a few minor issues with bugs, or unimplemented features, but nothing that I couldn't work around.
Honestly, I don't think learning Doctrine 1 is terribly worth your time. Development for it will stop in 2011. And the two framework are so different, you're going to need to teach yourself twice.
As mentioned elsewhere, there have been some backwards compatibility API changes between the last Alpha release and the upcoming Beta (which is slated for the end of April), but they haven't been huge.
It's very possible by the time you're really picking up speed with a project, it'll be into the Beta phase.
The difference is huge, but one additional concern is API stability. I think they've stated in some blog posts that the API won't be considered final until a beta release (so far everything's been alpha). So, there's a chance you'll still have to refactor some code to fit any API changes they may make before beta.
I doubt they change anything earth-shattering, but not being able to say so definitively means that it's a little disconcerting for production use. My suggestion would be to at least wait until the first beta release, which should mark the API freeze.
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 9 years ago.
Improve this question
I work at a software company where most of the people are afraid to install new tools to increase productivity. They give me excuses like:
I don't need to install something else.
I can do this myself.
etc...many other baseless arguments.
In an ecommerece business, the end-users should not have to install anything, everything should be managed by them from the web, and the developers should be the ones installing things to increase productivity and teamwork i.e.:
Version Control Systems
Build Tools (ANT, NANT, Maven, continuous integration, CSS Frameworks)
Integrated Development Environments
Frameworks (Unit testing, etc)
Etc...
How else can I get my point across without sound crass?
Your point of persuasion depends on your position in the company. If you're the newly installed manager of the programming team, get your budget approved and start implementing.
If you're a team lead, then start by picking whatever's most painful and asking for the resources to resolve for at least your team. 2 or 3 months in, show your boss tangible improvements, let them buy in from that perspective and push down to the other teams. Rinse, repeat with next pain point. It may take you a year or more, but just like with iterative development, so must changes to environment (esp. when you're not in direct charge) must be iterative and just practicing what you preach is most powerful influential force when you excel while the others flounder.
If you're not on version control, that's the most critical to get implemented the soonest.
The order I typically implement is:
version control (git, subversion)
bug tracking (trac)
morning scrum meetings
new feature tracking, documenting, and estimating tools (pivotal tracking, mingle)
testing frameworks
continuous builds
I would position every tool in terms of how much time/money/... does the tool save. What does it mean to use it and what does it mean not to use it.
Emphasise the negative impact on their work if not using the tools.
When you're trying to convince management of something, give advantages AND disadvantages. Try to stay objective, and give figures where possible. This will help you convince management (and indeed yourself). It gives management (and your team) confidence if they know you've actually thought something through.
For instance, I worked at a place, and we were looking at improving the speed of the ANT build. It was 8 minutes. I changed it a bit, and it was 3 minutes afterwards. Was it worth it?
We had 8 developers. Lets say they do 3 builds a day.
That is 8 developers * 3 builds per day * 200 days a year = 24000 minutes = about 50 man days.
That is, for a team of 8, if you save them 15 minutes a day, you'll get an extra two man months work from the team each year.
This not only helps you convince people/managers of the worth of what you're doing, but also helps you convince yourself.
P.S. About 6 months previously, we didn't have ANT, and the build was a series of 12 .bat files which had to be run in order. It tooks about 2 hours to correctly build. THAT change was easier to sell to the management.
My two pence of advice - if you need to persuade anyone in management or business for use of something new or different, you need to tell them that it result in increased income (due to the benefits like productivity gains or hours of business manual effort saved etc).
But certainly, in today's environment its really sad to hear that the working population or devs in your organisation are not enthusiastic to try and use new tools/tech. You should also try putting your case with your head of technology - I am sure they will take it seriously.
I'll play the devil's advocate for a minute, and say that sometimes, installing the latest shiniest tool probably isn't the best solution.
Eg:
when you're just about to release a product, and can't afford to spend time fixing your configuration if something breaks, or just learning to make it work the way it used to.
when you know your IDE really well, you've configured it perfectly, and it's still doing everything you need. (I'm thinking of die-hard vi and emacs users here)
when you see your collegues spending more time managing/upgrading/fixing their tools then actually producing results
when the tools are immature/unstable/unsupported
...
That said, there's no excuse for not using version control.
A key point is how well can you rationalize away someone's excuse? If someone says they don't need it, that is correct. However, there may be benefits gained from using the tool but there also has to be guidance, understanding and someone prepared to endure the pain of learning to use the tool. This is where I'd suggest understanding that someone may be afraid of wanting to try something new or not see the benefits from it. Is it so hard to see that someone else may have feelings that are driving what they are saying?
While you may see the argument as baseless, try to see things from their perspective. If they have never done unit tests before, how are they supposed to know why they are good? Same can apply to build tools and other areas of things that others may view as basic if they have had them for years and years.
Seems to me as if you had a lot of Morts in your company. A very sad situation.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 8 years ago.
Improve this question
I am interested in how much of your daily work time do you spend on implementing new features compared to fixing bugs.
I don't code any new features as long as there are some unfixed bugs in my software.
The only reason I can think of to let a bug unfixed in my software is that it's definitely to costly to fix. In this case, we may choose to change this from 'bug' to 'known limitation' or 'known bug', and we fix the feedback we give to the user accordingly, so that the user knows exactly what's going on and why it's not fixed (see my edit below)
So typically, I spend all of my time bug fixing as long as the QA is complaining about something, and all of my time coding when it's not ! :)
I do that because :
When a software does a lot of things, but crashes randomly, the user will get a feeling that he cannot rely on the software, and there's NOTHING you can do to fix this. ever.
When a software lacks some features, but is good at doing what it does, the user rather thinks "That may be a great software, too bad it doesn't support X and Y... I'll check the next release in 6 months".
Joel Spolsky has written an interesting post on that question in his
12 steps to better code.
Edit to answer comments : If I'm experiencing random crashes, that's definitely a bug, not a "known limitation". Once I know exactly what is going on, and only then, I can decide whether I can fix it or not.
I was rather thinking of the following situations :
the bug is provoked by code that doesn't belong to me (typically a third party library). If implementing a workaround is very complicated, it might be OK to wait for the third party vendor to fix it. Real world example : Clickonce doesn't work in some proxy situations... I expect Microsoft to fix it, eventually.
If the bug is that a specific feature doesn't work in all situations, and that this feature is too difficult to implement for those specific situations, I think it's ok to warn the user before he uses the feature that what is trying to do is not implemented, rather than just crashing.
I work for a group inside my company that is suppose to both create "featurettes" and respond to customer issues. I tend to spend more time on high priority customer issues (read: bugs). So I would say my time is nearly 100% spent on fixing bugs.
That said, lets read between the lines a bit. It seems that this question is a way of saying "ugg, I spend so much time on bugfixing...wish I could do more feature development". If that is the case, I think you need to look inward a bit.
As I said, I spend nearly all my time on fixing bugs for customer issues, but I have also written a ton of tools to help with that process. I have everything from specialized log analyzers to generic visualstudio solution file error checkers. Not to mention some of those sweet wndbg scripts I have written for esoteric breakpoints!
It is by doing stuff like that where I fulfill that desire to work on "something new". And in a way, it is much more rewarding than implementing some new small cog in a huge enterprise application.
Since I don't get paid to maintain any project, most of the time i'm working on new projects, hence adding new features all the time.
However, each feature needs to be tested and debugged thoroughly, so you can say that 30-40% of the time spent implementing a feature will go into debugging it.
Many projects have a development phase ("code thaw") where active adding of new features occurs concurrently with bug fixes, and a "code freeze" stage where feature set is frozen and 100% of the work goes towards bringing the critical bugs count to 0 (or fixing as many bugs until a fixed deadline as possible), so the answer would depend on the stage your project is in.
When I "do bugs," I also make my best effort to claim at least one feature to work on at the same time, or (when encountering a particularly buggy block of code) request a mandate to refactor the entire block. Thus I get to do some new development (and, face it, most of us prefer to write new stuff to fixing the old) while reducing the bug count.
There's a broad spectrum of priorities I have in my head when I'm triaging my work:
Bugs affecting a customer's ability to do their business or access their data. No work is done until any bugs like this are taken care of.
Other high priority bugs or features. These are usually "known issue" type bugs or enhancements that have become to painful to deal with anymore and now require a code change. Also, features requested by big customers or prospects generally fall into this category.
Everything else. This includes maintenance, nice-to-have features and just general itch-scratching-type maintenance on our code base.
As you can imagine, #3 category work doesn't get worked on all that often, which is a bit frustrating from an engineering perspective. But, our customers love us since they get an engineer working on their issues almost immediately after they call our support line and generally have a resolution within 24 hours, regardless of their size or importance.
It depends on the project, if there is a show stopper bug I focus on it but sometimes when I'm not motivated enough I just add one new cool feature so I can at least work on it instead of not doing anything.
This is for personal projects or before pre-release / research products
It all depends on kind of project I am working upon currently.
If the project is new then we do have a phase called bug fixing after the testing phase. Most of the bugs get fixed there. (!)
If the project is maintainance project then fixing bugs is a daily routine.
It depends on the bug.
Is it a minor cosmetic issue such as mislaigned label or a huge knock out bug that corrupts data?
Even if it is minor or cosmetic, is it causing user headaches, like a pop-up opening up in the wrong place? Is the data corruption bug only in Firefox 2 with a full moon (and your corporate intranet is IE 6)?
Good question though...
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
We have MS Sharepoint -- which isn't all bad for managing a task list. The data's publicly available, people are notified of changes and assignments.
I think that Bugzilla might be a little easier for management and reporting purposes. While there are some nice Open Source Scrum management tools, I've used up a lot of my political capital and can't ask for too much more than what we've got now. Money isn't the object -- obviously -- it's the idea that my team has too many specialized tools.
Will Bugzilla work out as a more general project management tool -- outside the bug fix use cases?
Will I be bitterly disappointed and wish I'd downloaded something else and made my case for a better project management tool?
Bugzilla Is a great bug tracking system. We have tried to use it for other project management tasks and the results are less then stellar. I would recommend finding something designed with your goals in mind.
Try it for yourself.
Get a $15/month account at wush.net and use it yourself for a while (no business relationship besides satisfied customer).
Bugzilla is powerful and has a lot of configuration options, which can be confusing.
I personally used it three years ago on a project I was working on. I had no project manager and I was the developer, so I needed a very-light-overhead systtem. Bugzilla gave me that. I put my main goal as an enhancement "productionalized system" and then I made dependencies to reach that point. I ended up having 160 nodes all dependent on each other. This essentially was a work breakdown structure. I didn't bother with time estimates, and I didn't bother with creating any other kind of project documentation.
A cool advantage was that as I coded, if I noticed something needed to be done, I would just pop it into bugzilla (20 second process once it's set up), tie it as a dependency, and go back to what I was doing.
Whenever I completed a task, I would look at the dependency diagram and find the outermost leaves (bugs that blocked other but weren't themselves blocked), and work at it.
The advantage of this method for me is that if a task had looked simple and had one node associated with it, but when doing the thing itself I realized it was more complex, I would just split it into different subtasks. This took only a minute and absolutely didn't involve a meeting with a project manager.
Other people on the team could track my progress by looking at open bugs, closed bugs sorted by dates, etc. They saw action, they left me alone. When I had external dependecies, I would make a bug, detail the work, and send that person a link via email. They could then see why this was needed by looking at the dependency diagram.
Note that unless previously agreed upon, I did not assign them the bug.
It worked really well and the system was ready one month early.
How will it work with SCRUM? Having only had a cursory glance at scrum I can't tell you. But that was my experience.
Using a dedicated host will allow you three things:
support
easy upgrades (unless you got gurus in-house, bugzilla management ain't easy--for me at least)
users across organizational boundaries.
Note that bugzilla has all sorts of security features, so it's easy to lock-down the users to what they need to see.
My stand-alone solution is DokuWiki + MantisBT + Subversion + Review Board, which can be integrated with relative ease. Hosted alternative is Bitbucket.org. The rationale is you write user stories on Wiki and can reference them specific tasks. Larger bugs can be collaboratively designed and the "wiki" link is provided on the bug report by Mantis. Review board lets you do peer code reviews against svn diff before change is committed.
We've used Trac and Subversion very successfully for several projects.
The main advantage here is being able to tailor reports, some very Scrum specific, to provide information to management.