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 6 years ago.
Improve this question
I'm looking for a consensus for one or the other
Beta; Release software that is semi-
functional to a limited audience and let users guide the
process until an application is
complete.
No Beta; Define all functionality
based on previous user-feedback
and/or business logic, build the
software, and test it with whatever
time you give yourself (or are given).
Hmmm...Beta is for a product you think is finished...until you give the Beta users to play with it and they break it in ways you haven't thought of.
So, yes, go with Beta, unless you want to burn your product on many users.
I disagree with both of your cases.
How about internal QA? They find bugs too, you know. Only release a beta to customers when you have no known serious bugs.
Also, always test adequately. If time is pressing and you haven't finished all your tests, then that's just tough. Finish testing, whether you have time or not.
My answer is that there are many factors that would determine which makes more sense:
1) Consequences of bugs - If bugs would result in people dying, then I think a beta would be a bad idea. Could you imagine running beta software on a nuclear reactor or on a missile system? On the other hand, if the consequence is fairly minor like if there is a temporary outage on some fantasy sports site, that may not be so bad to put out in beta.
2) Expectations of users. Think about the users of the application and how would they feel about using something that is a "beta"? If this would make them scared to actually use the software and be afraid that it is going to blow up on them regularly and be riddled with bugs, that may also play a role.
3) Size of the application. If you are going to build something very large like say an ERP to handle the legal requirements of 101 countries and contain hundreds of add on modules, then a beta may be more sound than trying to get it all done and never get to where you have customers.
4) Deployment. If you are setting up something where the code is run on your own machines and can easily be upgraded and patched, then a beta may be better than trying to get it all done right in the beginning.
5) Development methodology. If you take a waterfall approach, then no beta is likely a better option, while in an agile scenario a beta makes much more sense. The reason for the latter is that in the agile case there will be multiple releases that will improve the product over time.
Just a few things I'd keep in mind as there are some cases where I easily imagine using betas and in other cases I'd avoid betas as much as possible.
Undoubtedly beta!
Some benefits of running a beta period ...
Improve product quality, usability, and performance
Uncover bugs
Gain insight into how customers use your product
Gauge response to new features
Collect new feature requests
Estimate product support requirements
Identify customers
Earn customer testimonials
Prepare for final release
Generate buzz for product release
Launch quickly and iterate often.
Without knowing what the app is and what it's audience will be, I think that would be a hard choice to make. However if it's an Open Source project, it seems like the consensus is usually "Release Early and Release Often".
The real question is this: Do you know exactly what your users what?
If you answer yes, then design and build everything and launch it with no Beta.
If you answer no, then Beta is the way to go - your users will help define your software and they will feel more a part of the process and have some ownership.
I say Beta. But I disagree with your premise. You should never release semi-anything software. The software released as Beta should at least be feature complete. This way your users know what they're getting into.
As far as finding bugs. Internal testing is best. However, anyone that has released software knows that no matter what the user will find a new and interesting way to break it.
So Beta 'til your hearts content.
I would suggest alpha testing first, to a select group, that is not feature complete, so they can help you find bugs and determine which features are needed.
Once you get what is thought to be feature complete, then release it to a larger group, mainly to find bugs, and to get comments on feature changes, but you may not make feature changes unless there is something critical.
At this point you are ready for release, and you go back to step (1) for the next release.
After finishing (you think) your software, and believe that there are no serious bugs, conduct alpha testing. Make the software available within the test staffs of your company, fix the bugs reported.
Next, release the software to customers as beta testing, collect comments, fix bugs & improve features.
Only then you're ready for release.
Neither.
You shouldn't release a beta until you feel that the product is bug-free. And at that point, the beta users will find bugs. They will, trust me. As far as letting the beta users 'guide the design', probably not a good idea - you'll end up with software that'll look like the car that Homer Simpson designed. There's a reason why beta users aren't software designers.
As far as the second option - unless you are an extraordinary tester, you will not be able to test it as well as end-users (they will do the silliest things to your software). And if you "test it with whatever time you give yourself (or are given)", you will not have enough time.
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
We are in the process of reviewing scrum and seeing how we can implement it in our product. Since it's fairly new to us and most examples follow a very straightforward cycle we have some questions on how it would apply to our situation.
We are one single team of a few developers. We have 1 product that has several parallel product versions. Example:
Foo/
/version_1
/version_2
/fork_a
/fork_b
Version 1 is our legacy version, which mostly receives bug fixes, but we need to back port the occasional feature from our main development: version 2. Both fork_a and fork_b are special versions of our product, Foo, which can go from an alternative UI to a small extra feature. At the moment, when a fork is made and completed it's treated as closed and nothing is back ported to that branch.
Our problem is that all of these product versions are developed parallel, and we can't visualize how to maintain this. (We are planning to use TFS 2010 as our tool, so any direct examples are useful.)
We though of treating everything as a different product, each with it's own releases and sprints. But that means a developer who needs to do work on feature A in version_1 and feature B in version_2 can be booked in parallel sprints. We basically need to manually manage that. Which means that we cannot properly generate reports to visualize this.
An alternative idea was to treat everything as a single product and drop the release term. Or use quarterly releases and have the sprints of all products under those. But that means that we can have a product release in the first week of a one-month sprint. How do we coop with that? Or how do we then properly view what has been done for a single product release? Because the work developer X did in sprint 1 and 2 can be of no use to the product release we're targeting.
Any real-world examples and ideas on how to manage this are greatly appreciated.
We deal with a similar situation with our Scrum team. We have an even wider range of products that we develop with one team (internal desktop app, web apps, web services). The all have a common technology base (C# .NET), but a wide array of clients and presentation technologies. We actually have enough software developers to break up into separate teams, but we don't have a large enough supporting cast (QA, DBA, BA) to do so. So we end up modifying the classic Scrum approach a little in that not all of our stories can be worked on by the entire team, some are more web dev and some more desktop. We are still having a lot of success with getting feedback on all of our products every 2 weeks in a combined demo to the stakeholders. We release all of the products in sync as well.
I think the best thing to do is just get started with whatever process seems to fit and adjust along the way in your retrospectives. Don't get too hung up on being textbook as all agile processes are meant to be tailored to your specific situation. Doing some things "right" is better than doing nothing while trying to make up your mind.
To see work done on a specific release, use work item association upon checkin, that way you can simply query which items went into which branch.
Use automated builds to automatically associate changesets (and thus work items) to built versions of the product. That way it is easy to figure out which changes have gone into which binaries.
Then finally just let the marketing people decide how to name/number each the release, the technical version number doesn't have to match the marketing version, most Microsoft products are a great example of this, Windows 7 doesn't have a version number of 7, internally it uses 6.1, build 7600.16385.090713-1255.
I have worked in team that runs trunk and branches like what you have. At the time we didn't practise Agile but that didn't stop us using our common sense to pull through. If I was to do it again now I would have a main board for all the work that needs to happen in a sprint but also have sub board for each of the different fork/branches. The main board and sub boards are updated at the same time each day. The sub boards just provide a visualization of the stories and progress specific to each of the forks/branches. Everything on the main board are still completed to done criteria every sprint. Releases need to be synced to the same sprint intervals (time can be different) to keep the team together (no parallel sprints).
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 6 years ago.
Improve this question
Lately I have seen our development team getting dangerously close to the 'second system syndrome' type ideas while we are planning the next version of our product. While I'm all for making improvements and undoing some of the mistakes of our past, I would hate to see us stuck in an endless loop of rewriting and never launching anything.
Is there a good design / development method that lends itself to building a better version 2.0 while avoiding second system scenarios?
I have experience the second system syndrome from both sides as a customer/sponsor and part of a development team.
A root cause for problems is when the team latches on to an Utopian vision of version 2, such as the desire to make the new software "flexible". In this scenario everything is abstracted to the nth degree. For example, instead of data objects that represent real-world entities a generic "item" object is created that can represent anything. One flawed idea is that we can build in so much flexibility into the software to anticipate future needs, that non-programmers will be able to just configure new capabilities. Often one goal such as "flexibility" overshadows the effort to a point that the resulting software doesn't work.
A balanced practical consideration of usability, performance, scalability, features, maintainability, and flexibility goals can bring the team back to earth. "It would be great if..." should be prohibited from the vocabulary of the team. The Scrum backlog is a good tool and the team should be heard saying often... "Let's backlog that...we don't need that for version 2."
"I would hate to see us stuck in an endless loop of rewriting and never launching anything."
Which is why people use Scrum.
Define a backlog of things to build.
Prioritize, so that things which lead to a release are first. Things which should be fixed are second.
Execute sprints to get to the release. Execute a release sprint.
Get someone who has written at least three systems to lead the project.
Try to focus on short delivery cycles, i.e. force yourself to deliver something tangible and useful to the users every few weeks or month. Prioritise the tasks based on their value to the customer. This way you always have a usable, functional application with satisfied users, while under the hood you can refactor the architecture in small steps if you wish (and if you can justify the need for it - that is, towards management / the customers, not just teammates!).
It helps a lot if you have a stable build process with a good suite of automatic (unit / integration) tests.
Agile development methods like Scrum do this, and they are warmly recommended. But of course it is not always easy or even possible to adapt such a method in your team. Even if you can't, you can still take elements of it and apply it to your project's benefit (maybe without even mentioning the words "agile" or "Scrum" publicly ;-)
Make sure you document the requirements as well as possible. While obviously you need to also manage what gets into the requirements to avoid over-designing, having a fixed scope helps prevent developers from running off with ideas or gold-plating what needs to be done and it helps keep management or clients from introducing scope creep. Define all requirements and how scope changes will be addressed.
I'm all for short development cycles (make sure you're writing tests) and agile methodology, but neither of those is a shield against second syndrome system. In some ways it's easier to keep adding on feature after feature if you're working in short sprints without stopping to look at the overall picture. Use agile practices to build the simplest thing that works, then keep adding your other requirements as simply as possible. Remember YAGNI, because when you build a system a second time, that's when you're most likely to build something you're sure you'll need at some point, something that will make the system "extensible" so there never has to be a third build. It's the best of intentions, but the road to hell and all that.
You can't get close to second system syndrome. Either you're in it, or you're away from it. You'll know when you're in it, but only after wasting a lot of resources.
Tips are: know about it (so basically we got that covered already). It's invaluable information to know what a "second system" is, and even more to have some experience with that. I think we all have some experience with that, hopefully benign.
That knowledge will often make you think twice and you'll find a solution without venturing into second-system limbo.
PS: Also know how to use your current system, that includes, maybe documented solutions, and other documentation.
Focusing on the system architecture should help e.g.
Having documented interfaces which support "loose coupling" between sub-systems
Having documented design decisions (avoid re-hashing previously beaten paths)
Hence, without going for an all out swap, the current system can be "upgraded" with more appropriate interfaces to help future growth.
Another good way to focus: assign a $$$ figure to each feature and prioritize accordingly ;-)
Anyhow, just my 2cents
I up-voted S. Lott's answer and would like to add some more suggestions:
Deliver a working product to your customer as frequently as possible. Iterations lasting between a few weeks and 2 months are ideal. Agile methodologies, such as Scrum, lend themselves well to this.
Use FogBugz for feature and bug tracking. Its features are very practical for agile projects. FogBugz allows easy prioritization according to releases and priorities. If your team enters their estimated levels of effort for each task, you can also use this to calculate reasonable ship dates.
Prioritize which features you will develop according to the 80/20 rule (20 percent of the features will be used 80 percent of the time) and the most bang for the buck. This helps keep the system as simple as possible, helps prevent feature bloat, and saves development and testing time.
Give similar thought to both new features and bugs when you determine the priority of an issue. One point of the Joel Test is "Do you fix bugs before writing new code?". In most shops this doesn't happen, but do not make debugging the system an afterthought. Also, keep a working copy of the old system to compare against when bugs are found on the new system.
Also factor in the level of effort required to maintain, and if necessary rewrite, existing code. If you have not already done this, give the team some time to code review whole files that they find troublesome to change. If the system's code was difficult to maintain the first time, this will only get worse and cause your team to spend more time on new features down the road.
It can never be avoided at its entirety. But being cautious could alleviate the problem.
You should formulate some thumb rule based on the vital parameters (scarcest resource) that define the success of the system. For example, reducing potential number of bugs might directly decrease operational cost (potential service calls to support center). But this might not be the case in every other systems. Another example, scarce use of CPU, memory and other resources might be beneficial in some cases but there could be environments where they could be available in abundant.
So simply to avoid "temptations", identify the scarcest resource (time, effort, money$ etc) and consider implementing only those that exceed threshold value.[f(s1,s2...) > threshold]
Despite the iterative development, I would emphasize on how technical debts are handled.
Links that are related to this:
Tech Debts: Effort Vs Time
Tech Debt Quadrant
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 months ago.
Improve this question
I've been working as a software developer for almost a year (not much though) in a corporate environment but all I've done so far is a raw software implementation of company needs. Senior coworkers don't seem to be doing some fairly different stuff. In fact their "benefit" for being experienced is simply an app design and getting their hands on new projects first. My elder software developer friend's jobs don't seem to differ from the overall picture.
Currently I'm a student of a CS department and what I really want to bring in this world is some innovative(not new but innovative) stuff that haven't been there. Something as great as google wave or JARVIS (if that can be done at all) or even much better, but yet it looked like that's not possible. The question is: when do people in a corporate environment choose to create something innovative? (from your experience/thoughts)
These are your options:
A) find a company that does something that you like
B) Find a company that gives you time to do your own thing
C) do your own thing at home
Notable innovation usually only occurs at a few select companies (Google, as others have said, Microsoft, though they're not doing it as much, and Apple). However, the main thing for an innovative program comes from just an idea.
Can you think of something others haven't done? Can you do it? Will you do it?
If the answer to any of these is no, then you're not going to be the guy coming up with "The Next Big Thing". It only comes from having an idea, and doing something with it. (I read something about this recently, I think from Joel, but not on his blog. Anybody know the article I mean?)
Unfortunately, working in a corporate culture, unless that corporation promotes new ideas (see above), you're going to be stuck doing the same crap as everybody else. I know for myself, I spend all day in front of a computer, looking at code. When I get home, I keep meaning to work on my own "innovative" idea, but I play video games, drums, with my dogs, go to the gym, hang with friends, whatever. I have no desire to spend yet another few hours in front of a computer working on more code.
The same thing happens to a lot of people, and unless you can get past this, you're never going to build something.
So, simple answer: When you have an idea, and actually do something with it.
Most of the time, the answer to your question would be never.
The motivation to go off and do something innovative is entirely dependent on the person. When it comes to typical corporate America, I wouldn't expect to be creating anything innovative and amazing. I would say the majority of anything truly interesting and innovative happens after hours on their own time if the person in question has a real job.
what I really want to bring in this world is some innovative(not new but innovative)
Don't we all. Sigh.
If you're actually brilliant, you'll have opportunities to do this. "working as a software developer for almost a year" Remain calm. The "long run" is 30 or 40 years of a working life.
If you're like the above-average people I've met, you'll be just able to produce software that's good enough to help your company get ahead. Until dumb management subverts things.
If you're like the rest of us, you'll spend your career struggling to chase after the above-average folks.
For the most part, software innovation doesn't happen very much in environments such as yours, and when it does it is usually done as a "skunkworks" project without official management approval. If you want to be involved in innovative work your goal should be to eventually work for a software technology company like Google or the like, or you can just join one of the many open source projects out there. Doing the latter is a good way to build credentials to get a job with a more interesting employer.
It shows when you can prove you have a market for your innovative software. Have a proof of concept ready and be prepared to defend your idea. If it can really bring in the cash, it will catch someone's eye. Ideas that are provocative yet fail to gain any financial support remain to be followed in your own spare time.
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 3 years ago.
Improve this question
I work as a lone developer in a very small company. My work is quite chaotic and I'm looking for ways to make it more organized.
One problem is that my projects have practically no management. Rarely anyone asks me what I'm doing, or if I have any problems. At some point there was talk about weekly status meetings, but that's some time ago. Seems that if I'd want something like that, I would have to arrange those myself.. Sometimes I'm a bit lost on what I should do next because I don't have tasks or a clear schedule defined.
From books and articles I have found many things that might be helpful. Like having a good coding standard (there exists only a rough style guide which is somewhat outdated in my opinion), code inspections, TDD, unit testing, bug database... But in a small company it seems there are no resources or time for anything that's not essential. The fact that I work in the embedded domain seems to make things only more complicated.
I feel there's also a custom of cutting corners and doing quick hacks on short notice. This leads to unfinished and unprofessional products and bugs waiting to emerge at a later date. I would imagine they are also a pain to maintain. So, I'm about to inherit a challenging code base, doing new development that requires learning a lot of new things and I guess trying to build a process for it all at the same time. It might be rewarding in the end, but as not too experienced I'm not sure if I can pull it off.
In a small shop like this the environment is far from optimal for programming. There's many other things needed to be done occasionally like customer support, answering the phone, signing parcels, hardware testing, assembly and whatever miscellaneous tasks might appear. So you get the idea about the resources. It's not all bad (sometimes it's enlightening to solve some customer problems) and I believe it can be improved, but it's the other things that I'm really concerned.
Is it possible to have a development process in a place like this?
Would it help to have some sort of management? What kind of?
Is it possible to make quality products with small resources?
How do I convince myself and others that the company which has worked successfully for decades needs to change? What would be essential?
Maybe there's someone working in a similar shop?
Use Source Control for EVERYTHING
Develop specifications and get signoff before starting - there will be resistance, but explain it's for their own good.
Unit tests! It hurts because you just want to get it done, but this will save you in the long run.
Use bug tracking - Bugzilla or FogBugz if you can afford it.
My advice is not to be extreme. From my experience, pure agile or pure traditional will not work. Before you use any process, know what it mean to solve.
I personally use a variation of Agile RUP. I do some upfront effort such as investigate the actual needs, do high-level design with possible extension. And ask customer to sign-off some major high-level requirements.
If you work in small group, detail design or specification may not worth. Of course, if there is some libraries that are shared by many, it will be worth the trouble.
Deciding what to invest in up-front depending on its risk (likelihood and effect).
Moreover, many SW best practice is really 'best' like version control, automatic testing (to me I only used it way to early detect regression as I do not believe in TDD as driven force of the development). I suggest you read 'Pragmatic Programmer' it presents many of those techines.
As to answer you questions:
(1). Is it possible to have a development process in a place like this?
Yes, but as I say, trailer it to fit your organization.
(2). Would it help to have some sort of management? What kind of?
Management helps but no control freak. Plan what to do when: integrate, resolve conflict, dead line of some mile stone. And roughly keep them on schedule (I particularly like Scrum's sprint).
(3). Is it possible to make quality products with small resources?
Definitely as soon as the size of the work, the time to develop and the size of the team is balance. If you definition of Quality is the same with me. To me, Quality means: solve the problem it set out to in an efficient and reliable fashion.
(4). How do I convince myself and others that the company which has worked successfully for decades needs to change? What would be essential?
Point out the problems. If there are none, why change? If you want to change, you should be able to identify the problem OR potential problems. Point out the problem.
Some big one are:
Without any process, it is harder for new recruited to blend in as they must learn from observing other how to deal with things.
Without process, it is harder to work in stress.
Without schedule, it is hard to determine the progress.
Without automatic testing, it will takes more time to identify problems and regression.
Without version control, it will be harder to roll-back mistake and separation of work to each team members will be mess.
Just my though.
You need to work with the owner and setup short medium and long term goals. You will want to let them know progress even if only through email.
You will need to enforce some order on your workday or you will never get anything done (those long term goals).
Divide your day up into chunks when you can code, when you are working on hacks to keep it togther, when answering emails etc.
Definitely setup a bug tracker. This can help keep your email clean. You can even setup an email address to forward bugs to be categorized later. This is good because the bug reporters will eventually tire of the bug tracker and want to just email you the bugs anyway.
edit
And as lod3n said, source control, but you are using that already right???!!?!
Been there, done that.
The book Planning Extreme Programming helped a lot. I used 3x5 cards stuck on a wall. This kept my boss informed of my progress, helped with estimates and planning, and kept me on track. The Planning Game gives good ammo if your boss's expectations are unrealistic.
Unit testing, as others have stated, helps even if you're a sole developer. I find the TDD style valuable.
lod3n is absolutely right about Source Control.
I've gone with XP-style iterations before; you may want to establish a backlog of items (even something simple like a spreadsheet or 3x5 cards) as well.
Avoid deathmarches. Stick to 40 hours in the sense of not working overtime 2 weeks in a row. Spend extra time outside of work learning new skills - not just technologies, but principles and best practices.
Have a bug tracking system, both for defects and new features. Don't rely on your memory.
Continuous integration and an automated build can help even a single developer.
Can't emphasize the recommendation for source control enough.
I've decided I don't need unit tests because I can have automated functional/integration tests instead: because with incremental development there's no need to test before integration.
as crazy as this sounds I use scrum just because I like the concepts of sprints, and backlogs. It makes it easier to set realistic goals. Of course the idea of scrum master and team is all you but if you are working on outside projects where it is possible that you may pick up an extra team member with your backlogs it will be easy to distribute work. Maybe I just like backlogs. With scrum you will need to get someone to be the product manager to talk about the features of the product. Version control is a must at probably should be implemented b4 even worrying about a software development process. I have worked in a company that started from 2 developers and went to 12 in a year. We started with no version control and low coding standards. The changes you will need to make will be gradual so don't worry about rushing to do a 180. Set a goal to change one thing a month and find supporters of your changes to make things go smooth.
As well as the recommedations of others I'd say that if you are tight on resources but have more say over how things get done you should make good use of off the shelf and open source products and libraries. This leverages the efforts of others, saving you time, ensures your code base doesn't become too esoteric and adds to your skillset so you don't end up being an expert in something that's useless everywhere else.
First, lets make a distinction between a development process and best practices. Best practices like source control, defect tracking, unit testing, etc. are an given.
Then there is the actual development processes. I would always recommend having a process, no matter small or large the team is. The trick is finding the right process. You have a process now - it is just an ad-hoc process that doesn't seem to be working out too well for for you. Rarely can you take a textbook development process and directly apply it. What you need to do is tailor the process to your companies needs and culture. Look at as many development paradigms as you can and try to find something that is a good fit and them start molding it to your needs. You may have to try and fail with a number of different processes. Perhaps the Personal Software Process will be a good starting process, maybe an agile process, a variant of RUP? You have a lot of options, start trying them out.
You are also going to have to work with the rest of your organization - they need to be a part of the process. You may be the lone developer, but a development process involves more than the developer, it involves ever person that has a say or impact in the product.
This may not be a specific answer, but my point is that you will need some kind of process. So start researching them and trying them out and molding them to your needs until you have something that works.
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
I'm writing a new project, and I have a choice between using a library that only exists in OSX 10.5 and later (We're on 10.6 now), but makes my life much easier, and using a library from earlier versions, but I have to a lot more of the work myself.
How does one make this decision? How do you balance new/better technology vs customers on old systems?
ETA: does anyone know of a site that compares market share by precentage of a specific OS? Since this is a consumer product, if only 2% of mac users are still on 10.4, that sort of makes my life easy. Similarly, if 25% are still on 10.4... (I know, it's almost guaranteed to be somewhere between...)
Ask your clients - how many are on older versions of the OS?
Can you afford to lose them?
Edit: (following comment)
If you don't know what your target audience is using, you have a problem. You need to get an idea of the magnitude of how many potential customers you will not be able to serve if you go with your new library.
Having said that, shipping is a feature, so if you get the product out much quicker, you can always refactor the code to use the old libraries if you think it will gain many sales.
In general you should base your decisions like that around the interests of your paying customers. You should present the issues to them and the risks involved in each alternative and let them make the decision.
Depending upon your particular application and requirements, I would personally ship this as a major update (i.e. version 2 compared to version 1) and explicitly state that a minimum of OSX 10.5 is required.
You could still support your previous version with bug fixes, just not new features that depend on library X.
Another way to think about it is that if someone is on 10.4, then they likely haven't been an active upgrader / software purchaser for the last 3 years. So the likelihood that they will want to spend money on your software is low.
Additionally, if they really want your software, they'll upgrade to 10.5 or 10.6 and gain loads of other advantages at the same time. While that OS upgrade won't be free, it will come with so many other advantages to the customer, they might not mind.
It's also important to consider how much time and effort it will take to develop your software. If these newer libraries mean that you ship the product months earlier, or with better features, that will also pay off.
As others have said, this really boils down to whether you can afford to lose customers who aren't on 10.5 yet. That said, lots of companies seem to support the two most recent versions of OS X in their new major releases, although older versions are often available for people with older systems.
If software ownership is stable and software vendor is not pushing too hard in phasing out their own obsolete software, then there are no reasons to not support.
The problem is much worse, when vendor is passively aggressive or committed the phasing out: dead download links, dead 3rd party companies, who made the hardware/drivers/compilers/libraries, unobtainable documentation, incompatible media/installer to recover/reinstall the product.
My example: pre-2000 vs 2005, it is nearly impossible to reconstruct say.. the build process of 1 mln lines of 100% saved and mothballed Visual Studio 6.0 projects from year 1999-2001, obtain all 3rd party libraries from the era, prepare proper SDK, platform itself, all patches, make results binary identical. No way.
But it pretty much works for Studio 2005.
You need to talk to both sales and support, and let them judge what the impact will be.