Got 10 minutes? Get prequalified now—it's easy!
Whether you're buying a new home or refinancing your mortgage, it's easier than you think to find the right loan for you. Chase is here to help you do just that.

Choose from a broad range of loans to suit for your needs
Rates tailored to your specific situation
Get your prequalification letter the same day

About E-LOAN

E-LOAN is a nationwide financial services company that is dedicated to providing consumers with a simple, easy and open way to obtain high yield savings accounts and CDs. Our web site also provides access to several preferred, nationally recognized lending partners that may be able to assist you in obtaining a loan that meets your financial needs. Since its launch in 1997, E-LOAN has drawn upon its pro consumer values to deliver our customers the best online experience possible.

Whether you want to buy a new home or refinance your current home, you'll need to choose the home loan that's right for you. Let HomeLoan.com help you save time, stress and cash with our easy-to-access home loan options. Choose from a First Time Buyer Loan, a Secured Home Loan and a Home Equity Loan or just compare your loan to ensure you've got the best deal possible. HomeLoan.com can guide you through the process of making the largest purchase of your life with complete confidence.

Get a great rate and payment and purchase a home of your own with the best mortgage loan. Refinance to lower the payments on your existing mortgage and get more cash and add to your savings. Use your home equity to get cash and make improvements or pay for those big-ticket home expenses. Check out a reverse mortgage that equals zero out-of-pocket payments as long as you live in your home. HomeLoan.com is your full-service loan headquarters.

A mortgage loan is a loan secured by real property through the use of a mortgage note which evidences the existence of the loan and the encumbrance of that realty through the granting of a mortgage which secures the loan. However, the word mortgage alone, in everyday usage, is most often used to mean mortgage loan.

A home buyer or builder can obtain financing (a loan) either to purchase or secure against the property from a financial institution, such as a bank, either directly or indirectly through intermediaries. Features of mortgage loans such as the size of the loan, maturity of the loan, interest rate, method of paying off the loan, and other characteristics can vary considerably.

In many jurisdictions, though not all (Bali, Indonesia being one exception[1]), it is normal for home purchases to be funded by a mortgage loan. Few individuals have enough savings or liquid funds to enable them to purchase property outright. In countries where the demand for home ownership is highest, strong domestic markets have developed.

The word mortgage is a Law French term meaning "dead pledge," apparently meaning that the pledge ends (dies) either when the obligation is fulfilled or the property is taken through foreclosure.[2]

As a Homeloans customer*, you are entitled to a range of sensational benefits when you take out your mortgage with us. From discounts on grocery shopping and fuel, to great deals on dining and entertainment.

Fantastic deals are available with some of Australia's leading brands, including Coles, Woolworths, Caltex, Europcar and many more!

As well as affordable home loans, we pride ourselves on our customer service. This saw Homeloans recognised as Australia’s Best Non-Bank Lender at the 2011 Australian Lending Awards, and as the 2010 Mortgage Manager of the Year by the Mortgage and Finance Association of Australia

A unique opportunity for individuals to operate their own business either as a Broker or Franchisee with Aussie. We also recruit for corporate roles nationally.

Lends a Hand to Local Sport

This program offers local sporting clubs who get involved $100 for every club member who attends a home loan appointment with an Aussie Broker. Click below to find out more.

First home buyers

Buying your fist property is pretty daunting - after all, it's probably the biggest investment you'll make in your life. This guide will get you prepared with valuable information, tips and checklists on everything from how to find the right home loan, create a budget, to making an offer and organising your move. All you need to do is follow these 7 steps into your new home:

refresh
Compare Home Loans

Choosing the right home loan will be one of the most important decisions you make, make sure you compare and save today!
MORE
compare-lenders
Home Loan Comparison

When comparing home loans it is crucial to understand all the differences between lenders so you can save, check out the differences now.
MORE
calculator
Home Loan Calculator

Home loan calculators help make the job of comparing home loans a lot easier so you can save money faster. Calculate and compare today.

Get the most from your home loan

Whether you're a first home buyer, upgrading to your next home, getting into property investment, or wanting to refinance and pay off your existing home loan sooner, we can help you make the right move and stay on top - whatever your needs.

We'll compare over 20 leading banks and lenders, as well as hundreds of home loan options to find one that's right for you.

Trusted experts

No matter what kind of mortgage you're interested in, you'll enjoy expert home-buying advice from the award-winning home loan broker you trust. We've helped over 300,000 Australians find a suitable mortgage for their needs - let us help you too. Find your local mortgage broker.

Personalised support

Choosing suitable home loans is easier than you think. From comparing lenders and interest rates to completing the paperwork with a minimum of fuss, our practical, professional support means you get more than just a mortgage. Read our tips and checklists.

Helpful advice

As Australia's number 1 mortgage broker*, we have access to hundreds of different home loans from our panel of banks and lenders. So, if you're looking for friendly guidance based on what's right for you, and your future, we can support your goals. Find out why we're different.

Informed choices

If you're wondering how much you can borrow and what your repayments will be, take a look at our great range of calculators. From the home you have to the home you want, we make it easy to assess your property dreams. Try our home loan calculators.

*as chosen by The Adviser magazine

Test Smarter, Not Harder

Introduction: Complexity Leads to Futility

Imagine we are developing a web page for customizing a laptop purchase.
If you've never configured a laptop online before, take a look at Dell's "customize it" page for an entry level laptop. The web page presents eleven questions to the user that have from two to seven responses each. The user has to choose from two options in the first control, two in the second, and so on. The user has seven possible choices for the last control.
When we look at all of the controls combined, the user has to make (2,2,2,2,2,3,2,2,3,4,7) choices. This is a simple configuration problem. The number of possible laptop configurations that could be requested by the user is the product of all of the choices. In this very simple page, there are 32,256 possibilities. At the time of this writing, the page for customizing Dell's high-end laptop has a not dissimilar set of controls, with more choices in each control: (3,3,3,2,4,2,4,2,2,3,7,4,4). The user of this page can request any of 2,322,432 different laptop configurations! If Dell were to add one more control presenting five different choices, there would be over ten million possible combinations!
Creating a test suite that tries all two million combinations for a high end laptop could be automated, but even if every test took one tenth of second to run, the suite would take over 64 hours! Dell changes their product offerings in less time than that.
Then again, if we use a server farm to distribute the test suite across ten machines we could run it in about 6 hours. Ignoring the fact that we would be running this type of test for each customization page Dell has, 6 hours is not unreasonable.
Validating the two million results is where the really big problem is waiting for us. We can't rely on people to manually validate all of the outputs–it is just too expensive. We could write another program, which inspects those outputs and evaluates them using a rules-based system ("If the user selects 1GB of RAM, then the configuration must include 1GB of RAM" and "The price for the final system must be adjusted by the price-impact of 1GB of RAM relative to the base system price for this model.")
There are some good rules-based validation tools out there, but they are either custom software, or so general as to require a large investment to make them applicable to a particular customer. With a rules-based inspection system, we have the cost of maintaining the rules. The validation rules are going to have to be updated regularly, as Dell changes the way they position, configure, and price their laptops.
Since we aren't Dell, we don't have the scale (billions of dollars of revenue) to justify this level of investment. The bottom line for us is that we can't afford to exhaustively test every combination. Dell's shareholders require them to grow their business, and these configuration pages are the vehicle by which Dell generates billions of dollars in revenue. They have to test it. The cost of errors (crashes, lost sales, mis-priced items, invalid combinations of features) is too high. With this level of risk, the cost of not testing (the cost of poor quality) is extremely high.

We Can't Afford to Test It

I was able to attend a training session with Kent Beck a few years ago. I was also honored to be able to enjoy a large steak and some cold beer with him that night after the training. When asked how he responds to people who complain about the cost of quality, Kent told us he has a very simple answer: "If testing costs more than not testing then don't do it."
I agree. There are few situations where the cost of quality exceeds the cost of poor quality. These are situations where the needed infrastructure, test-development time, and maintenance costs outweigh the expected cost of having a bug. (The "expected cost" is the likelihood (as a percentage) of the bug manifesting in the field, multiplied by the cost of dealing with the bug.)
The techniques described in this article are designed to reduce the cost of quality, to make it even less likely that "not testing" is the best answer.

Just Test Everything, It's Automated!

Two "solutions" that we have to consider are to test nothing and to test everything. We would consider testing nothing if we can't afford to test the software. When people don't appreciate the complexities of testing or the limitations of automated testing, they are inclined to want to "test everything." Testing everything is much easier said than done.
Have you ever been on a project where the manager said something like, "I demand full testing coverage of the software. Our policy is zero tolerance. We won't have bad quality on my watch."?
What we struggle with here is the lack of appreciation for what it means to have "full coverage" or any other guarantee of a particular defect rate.
There are no absolutes in a sufficiently complex system–but that's ok. There are statistics, confidence levels, and risk-management plans. As engineers and software developers, our brains are wired to deal with the expected, likely, and probable futures. We have to help our less-technical brethren understand these concepts–or at least put them in perspective.
We may get asked, "Why can't we just test every combination of inputs to make sure we get the right outputs? We have an automated test suite–just fill it up and run it!"
We need to resist the urge to respond by saying, "Monkeys with typewriters will have completed the works of Shakespeare before we finish a single run of our test suite!"

Solving the Problem

There are a lot of applications that have millions or billons of combinations of inputs. They have automated testing. They have solutions to this problem. We just finished discussing how impractical it is to test exhaustively, so how do companies test their complex software?
In the rest of the article, we will explore the following approaches to solving the problem.

• Random sampling
• Pairwise testing
• N-wise testing

We will also explore the impact that changing the order of operations has on our testing approach, and the methods for testing when the sequence matters.

Random Sampling

Early on in the software testing world, someone realized that by randomly checking different combinations of inputs, they would eventually find the bugs. Imagine software that has one million possible combinations of inputs (half as complex as our previous example). Each random sample would give us 0.000001% coverage of all possible user sessions. If we run 1,000 tests, we would still only have 0.001% coverage of the application.
Thankfully, statistics can help us make statements about our quality levels. But we can't use "coverage" as our key measurement of quality. We have to think about things a little bit differently. What we want to do is express a level of confidence about a level of quality. We need to determine the sample size, or number of tests, that we need to run to make a statistical statement about the quality of the application.
First we define a quality goal–we want to assure that our software is 99% bug free. That means that up to 1% of the user sessions would exhibit a bug. To be 100% confident that this statement is true, we would need to test at least 99% of the possible user sessions, or over 990,000 tests.
By adding a level of confidence to our analysis, we can use sampling (selecting a subset of the whole, and extrapolating those results as being characteristic of the whole) to describe the quality of our software. We will leverage the mathematical work that has been developed to determine how to run polls.
We define our goal to be that we have 99% confidence that the software is 99% bug free. The 99% level of confidence means that if we ran our sample repeatedly, 99% of the time, the results would be within the margin of error. Since our goal is 99% bug free code, we will test for 100% passing of tests, with a 1% margin of error.
How many samples do we need, if there are one million combinations, to identify the level of quality with a 99% confidence, and a 1% margin of error? The math for this is readily available, and calculators for determining sample size are online and free. Using this polling approach, we find that the number of samples we require to determine the quality level with a 1% error and 99% confidence is 16,369.
If we test 16,369 user sessions and find 100% success, we have established a 99% confidence that our quality is at least at a 99% level. We only have 99% quality, because we have found 100% quality in our tests, with a 1% margin of error.
This approach scales for very large numbers of combinations. Consider the following table, where our goal is to establish 99% confidence in a 99% quality level. Each row in the following table represents an increasingly complex software application. Complexity is defined as the number of unique combinations of possible inputs).

We can see that the very few additional tests have to be run to achieve the same level of quality for increasingly complex software. When we have a modest quality goal, such as 99/99 (99% confidence in 99% quality), this approach is very effective.
Where this approach doesn't scale well is with increasing levels of quality. Consider the quest for "five nines" (99.999% bug free code). With each increase in the desired level of quality, the number of tests we have to run grows. It quickly becomes an almost exhaustive test suite.
Each row in the following table represents an increasingly stringent quality requirement, with the complexity of the software staying constant at one million possible input combinations.

The random sampling approach does not provide a benefit over exhaustive testing when our quality goals are high.

Pairwise Testing of Input Variables

Studies have shown that bugs in software tend to be the results of the combination of variables, not individual variables. This passes our "gut-check" since we know that conscientious developers will test their code. What slips through the cracks is overlooked combinations of inputs, not individual inputs.
Consider a very simple laptop configuration page, having three selectable controls: CPU, Memory, and Storage. Each control has three possible values as shown in the table below.

We successfully pass tests of each of the different values available in the CPU control. However, we discover that our test fails if the user selects a CPU value of "Consumer" and selects a Storage value of "Huge". This highlights an unknown dependency between the CPI and Storage controls.
Pair-wise testing is designed to get coverage of every possible combination of two variables, without testing every possible combination of all the variables. For this example, there are 27 unique combinations of all of the selections. The following table shows the first 9 combinations. An additional 9 combinations are needed for each of the other CPU selections.

Exhaustive pair-wise testing will make sure that every unique combination of any two variables will be covered. The next table shows the combinations for this example.

With just 9 tests, we are able to exhaustively cover every unique pair of CPU and Memory, CPU and Storage, and Memory and Storage. Pair-wise testing allows us to get full coverage of the combinations of every two variables, with a minimal number of tests.
Pair-wise testing not only gives us full coverage of every pair of values, it also gives us (redundant) coverage of every single value for each control.
If we look back at our previous examples of laptop-configuration, we can calculate the numbers of tests required to get full pair-wise coverage. For the entry level laptop configurator, there are 32,256 possible unique combinations of inputs. We can test every unique combination of two variables with 31 tests. For the high-end laptop configurator, there are 2,322,432 unique combinations of inputs. We can test every unique combination of two variables with 36 tests.

N-wise Testing

The concept of pair-wise testing can be extended to N-wise testing–looking at every combination of N possible inputs. This is a simple extension of the idea behind pairwise testing. Good developers will catch the bugs caused by the combination of two variables. Even the best developers will overlook the three-variable (or four or more variable) combinations.
The following table shows how many tests are required to get full coverage of each N-wise combination of inputs for both the low-end and high-end laptops configurators.

This is a much more manageable situation. Exhaustive coverage required us to use 2.3 million tests, where using N-wise testing with N=3, yields only 179 tests! Existing studies have consistently shown that N=3 creates on the order of 90% code coverage with test suites, although the number will vary from application to application. We will use N=3, based on practical experience that N=4 tests rarely uncover bugs that were missed with N=3.
This approach only works when users are forced to enter values in a proscribed sequence and in cases where the sequence of entry is irrelevant. This set of tests won't give us representative coverage of what the users will do when they are allowed to make selections in arbitrary but relevant order. If order doesn't matter for us (for example, most API signatures have a fixed order, and many websites will process multiple inputs in a batch), then we have our desired methodology.

Order Relevance and Statistical Testing

There's been an assumption implicit in all of our calculations so far: that the order of selection in the controls is irrelevant. The available N-wise test calculation tools do not incorporate order of selection in their permutations–explicitly, they assume a fixed order of operations. When we test an API we have control over the order of processing–there are a fixed number of arguments, in a fixed order. People, however, do not always interact with the controls in a fixed order. And web service architectures may not be able to depend upon a predetermined sequence of events.
With 5 controls in an interface, we have 5! (factorial) or 120 possible sequences in which selections can be made by a person. Although the user interface may incorporate dynamic filtering that prevents some subsets of out-of-sequence selection, N-wise testing is blackbox testing, and will not have access to that information.
For an interface with M possible controls, each script created by an N-wise test generator will have to be tested in M! sequences to get exhaustive coverage. If the controls are split across multiple screens, then we can reduce the number of sequences. For example, if there are 5 controls on the first screen, and five controls on the next screen, instead of considering 10! (3.6 million sequences), we can consider all first-screen-sequences in combination with all second-screen sequences (5! * 5! = 120 * 120 = 14,400 script sequences).
In our example laptop configurators, there are 11 and 13 controls (all on the same page) for the low-end and high-end laptops respectively. This would imply 11! and 13! possible sequences (40 million and 6 billion).
We do not need to do exhaustive coverage of the sequencing permutations. An N-wise test is specifically analyzing the interdependence of any combination of N controls. As a lower-bound, we would only need N! sequences for each generated script. So our 179-script suite for the high-end laptop (with N=3) would need 3! (6) * 179 = 1,074 scripts to cover the product.
Here's the table for the lower-bound of scripts required to account for different values of N for both laptop-configurators.

This is a lower bound, because it assumes a perfect efficiency in combining unique sequences of each group of N controls. Existing N-wise testing tools do not (to the author's knowledge) take order of operations into account. For N=2, this is trivial–just duplicate the set of tests, in the exact reverse order.
We can take order of operations into account by treating the sequence as an additional input. We use the mathematical formula "X choose Y" which tells us the number of different combinations of Y values from a set of X values. The formula for calculating "X choose Y" is X!/(Y!*(X-Y)!) where X is the number of inputs and Y is the dimension of the desired N-wise test.
Here's the table of the number of combinations for each N, for both the low-end and high-end laptop configuration screens we've been discussing.

Here are the values, generally, for varying numbers of inputs.

We would then calculate the N-wise testing using a value of N+1 as an input to the test-generation tool, and include the number of unique sequences as if it were a control input.
Unfortunately, we don't have a solver capable of handling single dimensions larger than 52. This limits our ability to create a test suite for N=3 to a maximum of 7 controls.
To show the impact of sequencing on the test suite, consider an interface with 7 controls, each having 5 possible values. N=3 would require 236 tests if order is irrelevant. We then include sequence of selection as a parameter (by adding an 8^th control with 35 possible values, and testing for N=4), In this case, N=3 (with sequencing) requires 8,442 scripts. Our theoretical lower bound would be 236 * 35 = 8260.

How to Make it Even Better

When we don't know anything, or don't apply any knowledge about our application to our testing strategy, we end up with far too many tests. By applying knowledge of the application to our test design we can greatly reduce the size of our test suite. Tests that incorporate knowledge of the application being tested are known as whitebox tests.

Map out the control dependencies

In our previous examples, we applied no knowledge of the interactions of controls, or the interactions within the program of having made selections in the controls. If we consider a visual map of the controls and their possible relationships, it would look like the following diagram.
There is a possibly-relevant connection between the selections in every pair of controls. We have designed our testing around the lack of knowledge that is clearly visible in the diagram.
It is likely that we can rule out some of the dependencies, but possibly not all of them. Our approach should be conservative; only remove those dependencies that we know don't exist. This knowledge comes from an understanding of the underlying application. Once we remove these links the diagram will look like this:

This clarified mapping allows us to reduce the size of our test suite dramatically, because we've identified the independence of many controls. In an ideal case, the result will be two or more completely disconnected graphs, and we can build a set of tests for our suite around each separate graph. As the diagram above shows, we do not have two completely independent graphs. We can take a testing approach as shown in the following diagram:

We've grouped all of the controls on the left in a blue box. These controls will be used with the N-wise generation tool to create a set of tests. The grouping of controls on the right will also be used to generate a set of tests.
In this example, we reduce the number of tests required by a significant amount when order matters.

Also note that we increase the number of tests required when order doesn't matter, if we have any overlapping controls (if the graphs can't be separated). When the graphs can be separated, this reduces the amount of testing even if order is irrelevant.
The key to separating the graphs is to make sure that all controls only connect to other controls within their region (including the overlapping region).

Eliminate Equivalent Values from the Inputs

When we know how the code is implemented, or have insights into the requirements, we can further reduce the scope of testing by eliminating equivalent values. Consider the following example requirements for an application:

The next table shows two variables that we are evaluating in our testing–imagine that they are controls in a user interface (or values imported from an external system).

If we did a pairwise test suite without knowledge of the requirements, we would have 18 tests to evaluate. We get 18 tests by finding all of the unique combinations of the two controls (6 order-quantity values * 3 account status values = 18 combinations). However, with knowledge of the requirements, we can identify that some of the values are equivalent. The highlighted regions represent equivalent values (with respect to the requirements).

Which we can collapse for testing purposes into:

This consolidation of equivalent values reduces the number of tests we need to run. For our simple pairwise test, we reduce the number from 18 to 12. The number is reduced because now we have 4 order-quantity values * 3 account status values = 12 combinations. When there are more controls involved, and when we are doing N-wise testing with N=3, the impact is much more significant.

Conclusion

When we're testing any software, we are faced with the tradeoff of cost and benefit of testing. With complex software, the costs of testing can grow faster than the benefits of testing. If we apply techniques like the ones in this article, we can dramatically reduce the cost of testing our software. This is what we mean when we say test smarter, not harder.
Summarizing the techniques covered in this article:

• We can test very complex software without doing exhaustive testing.
• Random sampling is a common technique, but falls short of high quality goals–very good quality requires very high quantities of tests.
• Pairwise testing allows us to test very complex software with a small number of tests, and reasonable (on the order of 90%) code coverage. This also falls short of high-quality goals, but is very effective for lower expectations.
• N-wise testing with N=3 provides high quality capable test suites, but at the expense of larger suites. When the order of inputs into the software matters, N-wise approaches become limited in the number of variables they can support (fewer than 10), due to limitations of test-generation tools available today.
• We can apply knowledge of the underlying software and requirements to improve our testing strategy. None of the previous techniques require knowledge of the application, and thus rely on brute force to assure coverage. This approach results in conceptually redundant tests in the suite. By mapping out the grid of interdependency between inputs and subdividing the testing into multiple areas we reduce the number of tests in our suite. By removing redundant or equivalent values from the test suite we also reduce the number of tests required to achieve high quality.

Testing smarter, not harder.

Success/Failure Criteria: Some Surprises

Editor’s Note: the following article originally appeared in the July 2006 issue of The Software Practitioner, which is edited and published by Robert L. Glass. developer.* is grateful to Mr. Glass for allowing us to republish it here.

Brisbane, Australia - At a breakfast seminar here June 6 on "Factors for IT Project Success and Failure," Prof. June Verner of NICTA (the National Information and Communication Technology institute of Australia) provided a fascinating mix of surprises and predictables related to her subject topic. The findings came from NICTA’s study of 400 projects in the U.S., Australia, and Chile, using questionnaires and interviews to discuss success and failure factors with practitioners.
What were the surprises?

• Most projects that had no schedule were successful
• Requirements are needed for project success, but not necessarily early in the project
• Projects often continue successfully for some time with unclear requirements
• The choice of requirements methodology does not matter; UML was "no help"
• Using a development methodology was a success factor, especially when it was "appropriate to the application"
• Very few projects use risk management, and those that do rarely manage those risks
• Post mortem reviews are rarely held, and when they are it is almost always on successful projects
• In the U.S. (but not elsewhere), developers are involved in project estimation only when there are poor requirements (Verner speculated that this is because the powers that be were looking for someone to blame!)

And the predictables?

• Success comes from a culture that investigates and deals with problems
• The vision for the project (its business goals) must be shared among all project personnel, especially the project manager
• Project managers should be involved in the estimation activity
• Project managers should be good at customer and developer communication; they need not be good at the technology

There was some interesting data from the study, as well:

• 60% of organizations have no process to measure benefits
• 86% of projects had a business case, but 60% ignored it
• 33% of projects said they had no risks, but 62% of those failed
• 49% or organizations have had (one or more) project failures
• In one-third of the projects, the project manager had no say in schedule/budget targets
• 75% of projects were underestimated, none were overestimated
• 5% of projects had no project manager; 16% changed project manager at least once (and that was correlated with project failure)

Verner also asked developers what their criteria were for project success. They said:

• They had a sense they had delivered a quality product
• They had a sense of achievement
• They had enough independence to work creatively
• The requirements were met and the system worked as intended

### Please visit this page for more information about The Software Practitioner.

Discussion  -  Printable  -  PDF

Robert L. Glass held his first job in computing in 1954. Author of over 25 books, he is one of the true pioneers of the software field. He is the editor and publisher of The Software Practitioner, and also writes regular columns for Communications of the ACM and IEEE Software. In 1995 he was awarded an honorary Ph.D. from Linkoping University of Sweden, and in 1999 he was named a Fellow of the ACM professional society. His unique viewpoint and timeless writings have for decades offered insights to practitioners, managers, professors, entrepreneurs, researchers, and students alike.

Career Paths for Programmers

I recently interviewed for a Business Analyst position with the CIO of a large multi-national software development firm. This man was in charge of the company's worldwide IT operations, including offshore development projects, for which he was searching for qualified Business Analysts. The interview quickly became a casual conversation about current trends within the IT service sector, how the company was planning to take advantage of those trends, and, most importantly, how I could fit into those plans. It was during his evaluation of my skills that I asked how I fit and whether it was technical or business skills that were most valuable to his projects. The CIO summed up his advice about my career path with one small sentence: "Stay on the business side."
Business skills, in this CIO's view, were most important to his future projects and the industry as a whole. His reasoning was that he could train anyone in the technical skills he needed for a project, but finding those people with the necessary business skills to guide an IT project to success was something that could not easily be obtained. He went on to say that he found it difficult to find people who could communicate on even the most basic of levels. I asked if my background as a developer would help in getting a business analyst job, and he conceded that although it's not a requirement, it certainly would help matters as long as I could prove that I wasn't "too technical."
His comments are consistent with the trend that all US-based programmers have observed since the late 1990's: global salary competition amongst programmers, and a growing view in big business of programming as a commodity skill. It's hard to compete with a developer in Russia or India who can work for a fraction of what I make minus benefits. The CIO managed to reaffirm the subtle, but major, shift from technical skills to business-technical skills in today's labor market. I gave weight to his viewpoint since the people in his position are the trendsetters of the technology industry. They are the ones who set the directives for a company's IT needs, and often, the requirements desired for the higher-paying positions.
I did a little research and found that the US Bureau of Labor Statistics Occupational Outlook Handbook predicts that computer systems analysts are expected to be among the fastest growing occupations through 2012. The Handbook describes a systems analyst as someone who may plan and develop new computer systems or devise ways to apply existing systems' resources to additional operations. It describes a computer programmer as someone who writes programs according to the specifications determined by systems analysts. (The book does not separately list business analyst as an occupation.)
According to the Handbook, in the US systems analysts held an astounding 487,000 positions in 2004 (up from 468,000 positions in 2002) compared with 455,000 jobs in 2004 for computer programmers (down from 499,000 in 2002). The Handbook also states that employment for computer programmers is "expected to grow much more slowly than that for other computer specialists." And recent estimates by the Economic Policy Institute have put the number of jobs being offshored at approximately 330,000 to 500,000 jobs. About 100,000 of those were full-time computer programming jobs.
The key to maintaining a good employment outlook in IT, it seems, is to move out of programming and up into more business-oriented IT positions such as systems analyst, business analyst, project manager, or systems architect. However, a computer programmer can't just decide to become a systems analyst or project manager overnight. The journey takes time and requires the right amount of experience and learning to be successful.

Making the Shift

So you've seen the statistics and watched as the jobs in your market slowly disappear. You want to move more to the "business side," but you don't quite know how to do it. As I'll describe next, making the shift can be done on-the-job by gaining more responsibility, polishing up your problem-solving skills, and using creativity in your work.
I began my journey into systems analysis and design by accepting more responsibilities throughout the project I was on when things proved too overwhelming for my superiors. I gradually accepted more of the project management and business analysis responsibilities when the opportunity presented itself. For example, I would walk to Suzy in accounting and work out a new enhancement with her one-on-one rather than wait for my manager to do so. Over time, as my manager's confidence in my abilities grew, these responsibilities became a part of my job. It wasn't long before I became the Programmer Analyst, and ultimately the Project Manager, as new positions were created to fulfill demand for our work.
When the need arises, I recommend walking to the end user yourself and working with her one-on-one. Your manager will be relieved when he discovers that you are capable of communicating with his end-users, identifying their issues, and resolving those issues before they are brought up in the weekly manager's meeting. Even the best IT managers need a subordinate who is visible to the users who they can trust to get the job done. If a manager is slowly factoring himself away from the day-to-day workings of the project, welcome it. The higher visibility that you are obtaining can be translated into higher value—and that can result in a promotion. Over time, your increased interactions with more business-oriented people will make you more sensitive to business concerns.
A good subordinate has to be open-minded and creative. When solving problems, one has to always believe that there is a way to accomplish something, even if it's never been done before. Sometimes, just listening to the user will produce an idea. A lot of issues may come down to the business process that the system is attempting to replicate. I have had users actually solve a business problem for me just by listening to what they had to say!
Whether you're open-minded and creative or not, you can still work towards more business-oriented positions. After all, business systems analysts and project managers are only a small subset of the many positions opening up each year to address the issues of complexity through simplicity. If you love programming, you don't have to necessarily give it up.

Jobs To Pursue

Senior Technical Positions

Developers will often find that they may have to work side-by-side with the users to iron out difficult bugs. It can be difficult, if not impossible, to fix these problems when both parties can't communicate effectively. There was always a time in most of my work situations when the developer had to talk with the users or other developers directly to fix difficult issues. This is the programmer's chance to show management that he or she is someone who can communicate and utilize analysis methodologies—otherwise known as a "programmer analyst." A programmer analyst is also usually someone who has some years of technical experience, and a certain depth of technical knowledge.
Programmers who seek advanced technical skills without too much end-user interaction may find themselves gravitating toward the design & architecture side of the business. Although these types of positions are still relatively technical, they often involve making key decisions to address how the new system will fit into the organization's overall IT plans. In order to be successful, the architect needs to understand and control the elements associated with the utility, cost, and risk factors of the proposed solution.
System architects must make very educated decisions about how to decompose and isolate the different components that will be required, how to fit these components into the existing infrastructure, and in what order to implement each component. It can be a disaster to implement an online ordering system that isn't compatible with the organization's current accounting packages. The architect must identify these types of issues and present them to non-technical management in words they can understand.

Business and Systems Analysts

My job searches have suggested that business and systems analysts with a good programming background and a high-level of "business savvy" are becoming the next hot ticket. More and more organizations are finally hiring business analysts to explore, record, and recommend systems that fit the business—as opposed to the other way around.
The business analyst must often work with project managers, systems architects, and systems analysts, all of which are growing occupations that can make the difference between success and failure. In some cases the business analyst's responsibilities are being combined with that of the systems analyst or the project manager under the guise of "business analyst" or "business systems analyst." A quick search on Dice.com will reveal that many business analyst jobs have hidden deep within their job descriptions requirements to develop technical specifications or to guide and manage projects. My first business analyst job required both project management and systems analyst skills. These positions are sure to become more common as organizations struggle to reduce project failure and development time.

Project Management

According to the Bureau of Labor Statistics' Occupational Handbook, employers prefer project managers who possess advanced technical skills that have been acquired through work experience. The project manager is often responsible for hiring the staff, setting the schedule, and keeping track of the progress through every phase of development. This person is also responsible for assigning the work, dealing with everyday problems affecting that work, and making sure each analyst or programmer is carrying his own weight. The project manager can best carry out this function if he truly understands the work he is managing.
The project manager must also be a "people person" as well as a "technical person" in order to succeed. This individual must work with technical and non-technical staff at every level of the organization in order to succeed in his goals. Additionally, the project manager has to manage his team effectively to produce the desired product on time.

Management

The ultimate assignment for many IT professionals looking to move up the IT food chain is to become the manager. The Occupational Handbook explains that "employment of computer and information systems managers is expected to grow faster than the average for all occupations through the year 2014." These job opportunities are best suited for applicants with computer-related work experience and often require an advanced degree, such as an MBA. And of course, strong communication skills are a requirement for any management job in IT.

Skills To Develop

Okay, so you've heard all about what's required and where IT is going, but how can you capitalize on this new information?
My interview with the CIO and my experience in the field have shown me that companies want IT professionals who can understand what their business is and how to apply technology to make it better. Being able to follow directions is important, but being able to take some initiative and make your own judgments without handholding is equally important. The solution is to differentiate yourself from the traditional developer.
We have already discussed two ways of building up your current skills—acquiring business knowledge and advanced technical knowledge—but two other areas are important as well: communication and leadership.
Whether that CIO I interviewed with believed that communication skills could be learned or not is irrelevant. Everyone can learn to be a better communicator with practice. The difference is that communication skills take much longer to develop. Communication takes the right mix of experience and training to become effective. I have worked on this since my college days and have had great success in my career as a result.
I learned to communicate more effectively by dealing with those who couldn't. Many software users can't understand the technical side enough to describe any of their requirements in any type of detail regardless of their background. On the other hand, many technical people don't understand the intricacies of the business processes they are implementing because they can't openly communicate with the users. Learning to communicate, and having the patience to gain knowledge from the user, is an essential skill that many of my former and current coworkers don't have.
To add to your problem solving skills, instead of asking your superior or a more experienced programmer to help with a problem, take it upon yourself to find the answer to that complex problem. Before too long, you can be the one who others consult when there is a problem to fix or a new project to complete. Gaining problem-solving experience not only improves communication, it also improves your chances of moving into analyst and management positions. Eventually, you can do as I did and get your own project to manage.
The key to moving up the ladder at any company is to let them know what you know. Answer those questions, solve those problems, accept those new projects, and don't be too shy to share a better solution. It could mean the difference between being "just another programmer" or being the top candidate for a promotion.

Interface Oriented Design Book Excerpt: Inheritance and Interfaces

Copyright ©2005, Pragmatic Programmers, LLC. Published by Pragmatic Bookshelf. Published on DeveloperDotStar.com with permission. Purchase from directly from the publisher, Amazon US, Amazon UK, or wherever books are sold.

Finding commonality among classes makes for effective object-oriented programming. Often, programmers express that commonality using an inheritance hierarchy, since that is one of the first concepts taught in object-oriented programming.
We're going to go to the other extreme in this chapter to explore the difference between using inheritance and using interfaces. An emphasis on interfaces guides you in determining what is the real essence of a class; once you have determined the essence, then you can look for commonalities between classes.
Creating an inheritance hierarchy prematurely can cause extra work when you then need to untangle it. If you start with interfaces and discover an appropriate hierarchy, you can easily refactor into that hierarchy. Refactoring into an inheritance hierarchy is far easier than refactoring out of an existing hierarchy.
We will look at examples of alternative designs that emphasize either inheritance or interfaces, so you can compare the two approaches. An interface-oriented alternative of a real-world Java inheritance hierarchy demonstrates the differences in code.

5.1 Inheritance and Interfaces

You probably learned inheritance as one of the initial features of object oriented programming. With inheritance, a derived class receives the attributes and methods of a base class. The relationship between derived and base class is referred to as "is-a" or more specifically as "isa-kind-of." For example, a mammal "is-a-kind-of" animal. Inheritance creates a class hierarchy.
You may hear the term inherits applied to interfaces. For example, a PizzaShop that implements the PizzaOrdering interface is often said to inherit the interface.[1] However, it is a stretch to say that a PizzaShop "is-a" PizzaOrdering. Instead, a more applicable relationship is that a PizzaShop "provides-a" PizzaOrdering interface.[2] Often modules that implement PizzaOrdering interfaces are not even object-oriented. So in this book, we use the term inherits only when a derived class inherits from a base class, as with the extends keyword in Java. A class "implements" an interface if it has an implementation of every method in the interface. Java uses the implements keyword precisely for this concept.[3]
Inheritance is an important facet of object-oriented programming, but it can be misused.[4] Concentrating on the interfaces that classes provide, rather than on their hierarchies, can help prevent inheritance misuse, as well as yield a more fluid solution to a design. Let's look at some alternate ways to view example designs using both an inheritance-style approach and an interface-style approach. Both inheritance and interfaces provide polymorphism, a key feature of object-oriented design, so let's start there.

5.2 Polymorphism

A common form of polymorphism consists of multiple classes that all implement the same set of methods. Polymorphism of this type can be organized in two ways. With inheritance, a base class contains a set of methods, and derived classes have the same set of methods. The derived classes may inherit implementations of some methods and contain their own implementations of other methods. With interfaces, multiple classes each implement all the methods in the interface.

Figure 5.1: Shape hierarchy

With inheritance, the derived classes must obey the contract (of Design by Contract) of the base class. This makes an object of a derived class substitutable for an object of the base class. With interfaces, the implementation must also obey the contract, as stated in the First Law of Interfaces (see Chapter 2).
An example of an inheritance that violates a contract is the Shape hierarchy. The hierarchy looks like Figure 5.1.

class Shape
    draw()
class Rectangle extends Shape
    set_sides(side_one, side_two)
    draw()
class Square extends Rectangle
    set_sides(side_one, side_two)
    draw()

A Rectangle is a Shape. A Square is a Rectangle. Square inherits the set_sides() method from Rectangle. For a Rectangle, any two positive values for side_one and side_two are acceptable. A Square can accept only two equal values. According to Design by Contract, a derived class can have less strict preconditions and stricter postconditions. This situation violates that rule, and thus the hierarchy is not ideal.

Figure 5.2: Diagram of interfaces

Although a Square is a Rectangle from a geometric point of view, it does not have the same behavior as a Rectangle. The error in this example comes from translating the common statement that "a square is a rectangle" into an inheritance hierarchy.
An alternative organization (Figure 5.2 ) using interfaces is as follows:

interface Shape
    draw()
Rectangle implements Shape
    set_sides(side_one, side_two)
    draw()
interface RegularPolygon
    set_side(measurement)
Square implements Shape, RegularPolygon
    set_side(measurement)
    draw()
EquilateralTriangle implements Shape, RegularPolygon
    set_side(measurement)
    draw()

With these interfaces, Square provides the Shape methods, but it also provides the methods in RegularPolygon. Square can obey the contract in both of these interfaces.
One difficulty with interfaces is that implementations may share common code for methods. You should not duplicate code; you have two ways to provide this common code. First, you can create a helper class and delegate operations to it. For example, if all RegularPolygons need to compute the perimeter and to compute the angles at the vertices, you could have this:

class RegularPolygonHelper
    set_side(measurement)
    compute_perimeter()
    compute_angle()

Implementers of RegularPolygon would delegate operations to this class in order to eliminate duplicate code.
Second, you could create a class that implemented the interface and provided code for many, if not all, of the methods (such as the Java Swing adapter classes for event listeners shown in Chapter 3). You would then derive from that class instead of implementing the interface. For example:

interface RegularPolygon
    set_side(measurement)
    compute_perimeter()
    compute_angle()
class DefaultRegularPolygon implements RegularPolygon
    set_side(measurement)
    compute_perimeter()
    compute_angle()
class Square extends DefaultRegularPolygon, implements Shape
    set_side(measurement)
    compute_perimeter()
    compute_angle()
    draw()

In the case of single-inheritance languages, you need to decide which of the two potential base classes (Shape or RegularPolygon) is the more important one. If you decide on Shape, then you'll still need RegularPolygonHelper. Determining which one is important can be difficult until you have more experience with the classes. Starting with interfaces allows your to postpone that decision until you have that experience.
   USING INTERFACES
      Advantage-delay forming hierarchy until usage known
   USING INHERITANCE
      Advantage-less delegation of common operations

5.3 Hierarchies

The animal kingdom is a frequently used hierarchy example. The hierarchy starts with Animal on top. Animal breaks down into Mammals, Fishes, Birds, Reptiles, Amphibians, etc. The relationships parallel those of an object-oriented hierarchy: a cow "is-a" Mammal. The subclasses (derived classes) have attributes in common with the superclasses (base classes). This zoological classification is based on characteristics used to identify animals; Figure 5.3 shows a portion of the standard hierarchy.

Figure 5.3: Mammalian hierarchy

The animal hierarchy is useful for identification, but it does not necessarily represent behavior. The hierarchy represents data similarities. Mammals all have hair (except perhaps whales and dolphins), are warm-blooded, and have mammary glands. The organization does not refer to services-things that animals do for us. Depending on your application that uses animals, a service-based description of animals may be more appropriate. The service-based description cuts across the normal hierarchy. Looking at what these animals do for us, we might have the following:

• * Pull a Vehicle: Ox, Horse
• * Give Milk: Cow
• * Provide Companionship: Cat, Dog, Horse
• * Race: Horse, Dog
• * Carry Cargo: Horse, Elephant
• * Entertain: Cat, Dog, Tiger, Lion, Elephant

We could organize these methods in the same way we did printers in Chapter 3; e.g., each animal could have a "can you do this for me" method, such as can_you_carry_cargo(). Alternatively, we could have a set of interfaces as shown in Figure 5.4. Animals would implement only the interfaces they could perform. The methods in the interfaces might be:

interface Pullers
    hook_up
    pull_hard
    pull_fast
interface MilkGivers
    give_milk
    give_chocolate_milk
interface CompanionshipGivers
    sit_in_lap
    play_for_fun

Figure 5.4: Animal interfaces

interface Racers
    run_fast
    run_long
interface CargoCarriers
    load_up
    get_capacity
interface Entertainers
    jump_through_hoop
    stand_on_two_legs

Depending on the application, you may employ both a hierarchy and service-based interfaces. For example, you might have a Dog hierarchy whose base class implemented the methods for CompanionShipGivers, Racers, and Entertainers. Particular breeds of dogs could inherit from Dog to obtain a default implementation.
You might also have a need for interfaces based on common characteristics that cross hierarchies, such as LiveInWater, Vegetarian, etc. These interfaces could each have a helper class that provided common implementations. Classes such as Cow, Horse, and Ox could delegate to a VegetarianHelper class.
   USING INTERFACES
      Advantage-can cross hierarchies
   USING INHERITANCE
      Advantage-captures common attributes

Inheritance and Methods

Inheritance delineates a hierarchy of classes that all implement methods of the base class. The base class represents a general type, such as Mammal. The derived classes represent more specialized types, such as Cow and Horse. The derived classes may not necessarily offer additional methods.
On the other hand, derived classes can extend the base class and offer more methods. For example, for the Printer class in Chapter 4, a ColorPrinter represents more services than a Printer. When a derived class adds more methods to the base class, those additional methods can be considered an additional responsibility for the derived class. An interface could represent this additional responsibility.
For example, GUI components are usually organized as an inheritance hierarchy, like this:

class Component
    set_position()
    abstract draw()
class TextBox extends Component
    draw()
    set_text()
    get_text()
class CheckBox extends Component
    draw()
    set_state()
    get_state()

Here TextBox and CheckBox have additional methods that represent additional services for each derived class. Those additional methods could be denoted as interfaces, like this:

class Component
    set_position()
    abstract draw()
interface Textual
    set_text()
    get_text()
class TextBox extends Component, implements Textual
    draw()
    set_text()
    get_text()
interface Checkable
    set_state()
    get_state()
class CheckBox extends Component, implements Checkable
    draw()
    set_state()
    get_state()

If each derived class has its own unique set of additional methods, there is no advantage to organizing the hierarchy with interfaces. However, if many of the derived classes do have a common set of services, you may make those commonalities more apparent by using interfaces.
For example, a drop-down box and a multiple selection list are usually on one branch of a GUI hierarchy. Radio buttons and check boxes are on another branch of the hierarchy. These two separate branches are based on their relative appearances. Another way to group commonality is to put radio buttons and drop-down lists together and multiple selections lists and check boxes together. Each of those groups has the same functionality. In the first group, the widgets provide selection of a single value. In the second group, the widgets provide the option of multiple values.[5] In this organization, they are grouped based on behavior, not on appearance. This grouping of behavior can be coded with interfaces:

interface SingleSelection
    get_selection()
    set_selection()
interface MultipleSelection
    get_selections()
    set_selections()
class RadioButtonGroup implements SingleSelection
class CheckBoxGroup implements MultipleSelection
class DropDownList implements SingleSelection
class MultipleSelectionList implements MultipleSelection

   USING INTERFACES
      Advantage-can capture common set of usage
   USING INHERITANCE
      Advantage-captures set of common behavior

Football Team

The members of a football team can be depicted with either inheritance or interfaces. If you represented the positions with inheritance, you might have an organization that looks like this:[6]

FootballPlayer
    run()
DefensivePlayer extends Football Player
    tackle()
DefensiveBackfieldPlayer extends DefensivePlayer
    cover_pass()
Offensive Player extends Football Player
    block()
        Center extends OffensivePlayer
            snap()
        OffensiveReceiver extends OffensivePlayer
            catch()
            run_with_ball()
        OffensiveBackfieldPlayer extends OffensivePlayer
            catch()
            receive_handoff()
            run_with_ball()
        Quarterback extends OffensivePlayer
            handoff()
            pass()

An object of one of these classes represents a player. So, Payton Manning would be an object of Quarterback. Based on the methods in the hierarchy, Payton can run, block, hand off, and pass. This hierarchy looks pretty good. On the other hand, we can make our organization more fluid by using interfaces, like this:

interface FootballPlayer
    run()
interface Blocker
    block()
interface PassReceiver
    catch()
interface BallCarrier
    run_with_ball()
    receive_handoff()
interface Snapper
    snap()
interface Leader
    throw_pass()
    handoff()
    receive_snap()
interface PassDefender()
    cover_pass_receiver()
    break_up_pass()
    intercept_pass()

A role combines one or more interfaces. We might come up with the following roles for team members:

Center implements FootballPlayer, Blocker, Snapper
GuardTackle implement FootballPlayer, Blocker
EndTightOrSplit implements FootballPlayer, Blocker, PassReceiver
RunningBack implements FootballPlayer, BallCarrier, PassReceiver
Fullback implements Blocker, FootballPlayer, BallCarrier, PassReceiver
WideReceiver implements FootballPlayer, PassReceiver
Quarterback implements FootballPlayer, Leader, BallCarrier

Now along comes Deion Sanders, who plays both offense and defense. To fit Deion into the previous hierarchy, you need to create two objects: one an OffensivePlayer and the other a DefensivePlayer. Or you'd need to come up with some other workaround that does not fit cleanly into the hierarchy. With interfaces, Deion simply fulfills another role, like this:

SwitchPlayer implements FootballPlayer, PassReceiver, PassDefender

Roles can even be more fluid. For example, in one professional game, a backup quarterback lined up as a wide receiver.7 Trying to fit such a role into a hierarchy can be daunting. With interfaces, he would have simply implemented PassReceiver, or he could take on a role like this:

ReceiverQuarterback implements FootballPlayer, PassReceiver, Quarterback

   USING INTERFACES
      Advantage-give more adaptability for roles that cross hierarchies
      Disadvantage-may have duplicated code without helper classes to provide common functionality

Footnotes

1. Using a single term to represent two different concepts can be confusing. For example, how many different meanings are there for the keyword static in C++?
2. You may see adjectives used for interface names, such as Printable;. With an adjective, you may see a reference such as a Document "is" Printable. The "is" in this case really means that a Document "provides-a" Printable interface.
3. See the examples in Chapter 1 for how to code interfaces in C# and C++.
4. See Designing Reusable Classes by Ralph E. Johnson and Brian Foote.
5. You might also put a list that allows only a single selection into this group.
6. The services listed for each position are the required ones for each position. You could require that all FootballPlayers be able to catch and throw. The base class FootballPlayer would provide a basic implementation of these skills.
7. This was Seneca Wallace in a Carolina Panthers/Seattle Seahawks game, for you trivia buffs.

###

This excerpt is published by developer.* with the express permission of the publisher of the book Interface Oriented Design, The Pragmatic Programmers. developer.* is grateful to the publisher for granting permission for this publication, and to the author, Ken Pugh. If you enjoyed this excerpt, you will likely enjoy the book also. Purchase from directly from the publisher, Amazon US, Amazon UK, or wherever books are sold. (c)2005 Pragmatic Programmers, LLC. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form, or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior consent of the publisher.

Printable  -  PDF

Ken Pugh has worked on software and hardware projects for over thirty years, from requirements gathering through testing and maintenance. He has a wide variety of experience and has presented at numerous conferences seminars on software development processes, programming techniques, and system architecture. Ken has written four books on

7 Great Computer User Tips - For Windows® Users Only

An Easy Performance Enhancement

If you’re using the NTFS filing protocol on your system, instead of FAT32, you can get a bit more speed by disabling Windows® Indexing. The downside to this is that searching your drive for a specific file might take a moment or two longer, but everything else shTo disable this feature open My Computer and then right click on the drive you wish to reset – usually C-drive. Now click on Properties and then uncheck “Allow Indexing Service.” It will take Windows® a few moments to accomplish this task, based on your processor speed. If you have other hard drives, perform the same process for them. After this is done, it’s a good idea to empty the Recycle Bin and then Defragment your hard drive(s).

FREE Software

If you have a system and it does not have an office suite, such as Microsoft Office, and you don’t want to pay several hundred dollars to have one, try Open Office. This is a great alternative to other suites, and it’s free! Simply direct your browser to www.openoffice.org and follow the instructions for downloading and installation. Make no mistake, this free office suite is an extremely powerful set of software tools – easily a match for any competitor.

Internet Explorer (Microsoft’s Internet browser) is unarguably the standard in computers. This is why hackers develop so many malware applications to invade it. If you use a different browser, you have much less chance of an invasion by malicious software. There is a great alternative available, and it’s free. You can download a copy of Firefox at www.mozilla.org/products/firefox. You can even move your Internet Explorer settings into Firefox automatically – so you don’t lose your Favorites, etc.

Laptop Printer Fix

If you’re using a laptop that is running Windows® ME, and you’re having trouble printing through the USB, try this simple fix. Go to the website for the company that manufactures your printer. If you use a Hewlett-Packard, for example, go to www.HP.com and download the appropriate drivers and install them. ME has drivers that recognize the USB printer is present and attached, but not the drivers needed to make it print. Which drivers you download and install will be dependant on your printer. After installing new drivers, update the printer as necessary in the Control Panel.

Save $$$ When Shopping On-line

If you’re making a purchase on-line, and you know the item you want to buy, you can easily compare pricing all across the Internet. This can amount to a very substantial savings.

At this writing, I went to www.mysimon.com and typed in that I wanted to buy a printer: a Canon PIXMA iP4000. The service instantly checked the Internet and returned prices ranging from $62.00 up to $286.00. This kind of price spread is not at all unusual, especially for computers and electronics.

The My Simon website service only checks pricing, it does not provide a platform for purchasing anything, though it does link to such places. It also gives a rating for the sellers and other users’ input regarding their experiences with the company. You can order the results of the search for your product by price, so that you can quickly find the lowest price from the highest rated dealer.

Windows® XP Professional Only

A feature of Windows® XP Professional, that is not available in the Home Edition, is the ability to encrypt files. This encryption prevents others from opening the files in the folder you encrypt. To encrypt one or more a folders, follow these easy steps.

Click Start, then My Documents. Now locate the folder you wish to encrypt and right click on it and choose Properties.

On the General tab, click on Advanced. Put a tick mark in the box for Encrypt Contents to Secure Data. Click okay two times and the confirmation dialog box will appear allowing you to select the folder, the folder and all files, and/or the subfolders within it.

Now you'll be able to place files in this folder (or folders) and since they're encrypted, others will not be able to access them.

Internet Safety

You should never reveal your username or password to anyone who e-mails you and asks for it. This information is frequently asked for by an Internet scheme called “phishing.”

In a common phishing scam, you receive an e-mail that looks quite official. It usually appears to come from a bank or credit card company. A common title for these e-mails is “We need to verify your account information.” Another is “Please logon to your account and verify your settings.” If you do click where instructed, you’ll end up on a site that appears to be the real one. If you fill in the username and password for of your on-line banking account, you can expect serious problems within twenty-four hours.

If you believe that a company or business that you do on-line business with really does require your information, then simply contact them. This way, you will know where you are sending your information, and what it will be used for.

CD Burning Error Fix

Burning music, video, and data CDs has become quite popular over the past few years, and the evolution of the supporting technology has yielded hardware and software that is better than ever – and very reasonably priced. CDs offer a great place to store substantial amounts of data in a small, easily retained format. They also give us new control over aspects of our entertainment.

A relatively common error received during CD burning informs you that the CD cannot be burned, or that there was an error during burning. Of course, you could actually have a defective CD drive, but this is usually not the case.

If you receive a message indicating that your CD cannot be burned, go to the website of your CD drive manufacturer. Look for the list of CD types (manufacturers/numbers) that are compatible with your device. Most often, you’ll find that your CDs are not listed. The two types that seem to have the least difficulty being burned are manufactured by Sony and TDK. These cost a bit more, but they burn very reliably.

Along the same lines – H-P has introduced a new CD burner. This new burner requires the use of special CD blanks, but after you burn your data into the CD, you can flip it over and close the drive again. Then you can use the laser to burn a title for the CD directly onto the CD itself. It’s new technology, but perhaps it will catch on and we’ll see newer, better such devices in the near future.ould run faster.

5 Minute Guide to ERP

Information technology has transformed the way we live and the way we do business. ERP, or Enterprise Resource Planning, is one of most widely implemented business software systems in a wide variety of industries and organizations. In this short article, we’ll try to concisely explain the basic yet important concepts relevant to ERP.

What is ERP - ERP is the acronym of Enterprise Resource Planning. ERP definition refers to both ERP software and business strategies that implement ERP systems. ERP implementation utilizes various ERP software applications to improve the performance of organizations for 1) resource planning, 2) management control and 3) operational control. ERP software consists of multiple software modules that integrates activities across functional departments - from product planning, parts purchasing, inventory control, product distribution, to order tracking. Most ERP software systems include application modules to support common business activities - finance, accounting and human resources.
ERP Systems - ERP is much more than a piece of computer software. A ERP System includes ERP Software, Business Processes, Users and Hardware that run the ERP software. An ERP system is more than the sum of its parts or components. Those components interact together to achieve a common goal - streamline and improve organizations' business processes.
History of ERP - Enterprise Resource Planning (ERP) is the evolution of Manufacturing Requirements Planning (MRP) II in 1980s, while MRP is the evolution of Inventory Management & Control conceived in 1960s. ERP has expanded from coordination of manufacturing processes to the integration of enterprise-wide backend processes. In terms of technology, ERP has evolved from legacy implementation to more flexible tiered client-server architecture.
Benefits of ERP - ERP software attempts to integrate business processes across departments onto a single enterprise-wide information system. The major benefits of ERP are improved coordination across functional departments and increased efficiencies of doing business. The implementation of ERP systems help facilitate day-to-day management as well. ERP software systems is originally and ambitiously designed to support resource planning portion of strategic planning. In reality, resource planning has been the weakest link in ERP practice due to the complexity of strategic planning and lack of adequate integration of ERP with Decision Support Systems (DSS).
ERP Failures - We couldn’t conclude our brief guide to ERP without mentioning ERP failures. The failure of multi-million dollar ERP projects are reported once in a while even after 20 years of ERP implementation. We have identified the four components of an ERP System - 1) ERP software, 2) Business Processes that ERP software supports, 3) Users of ERP systems, and 4) Hardware and Operating Systems that run ERP applications. The failures in one or more of those four components could cause the failure of an ERP project.
Copryright @2006, 4th-Media Corporation
Natalie Aranda writes about business and technology. ERP is the acronym of Enterprise Resource Planning. ERP definition (what is ERP) refers to both ERP software and business strategies that implement ERP systems. ERP software attempts to integrate business processes across departments onto a single enterprise-wide information system. The major ERP benefits are improved coordination across functional departments and increased efficiencies of doing business. The implementation of ERP systems help facilitate day-to-day management as well.

Photoshop Tutorial Secrets From the Trenches: Seven Essential Steps to Digital Workflow

I've been shooting with digital cameras in my portrait and wedding photography studio for about five years now, and in that time I've taken well over 50,000 exposures.

Our studio has been around for about twenty five years, and it is busy, so creating a digital workflow that made sense was essential to not only our sanity, but our bottom line as well. After all, we're in business to turn a profit, and time is money.
One of the reasons this is so important is because so many photographers get bogged down and stuck in time wasting systems, systems that are over complicated and too "perfect'. In the real world, where real clients pay the bills, and making them happy on a consistent daily basis is critical, getting the job done as fast as possible is essential.
Let give you a "snapshot" overview of our digital workflow. You should know that all the stratgies we've created in our studio are not new. They are essentially the same as when we shot film. Nothing has changed, except the media, the turnaround times (faster, much faster!), and, of course, the huge learning curve. Which we've over-complicated beyond anything that makes sense.
Funny thing is, I've come to realize that the learning curve is quite small when you do only the things required and when you use only the essential tools.
Here are the seven steps to digital photography workflow:
1-Good capture: This is the starting point. Without a properly exposed file and good color balance, you are in the "taking corrective measures" mode. You don't want to be there. In time you would go crazy if you had to "fix" every file, so you need to master these two basics. Good photography and fast, painless workflow starts with good exposure and good white balance. A good exposure means you have as many of the tones, from the blacks all the way to the whites, in the image. The middle tones are exactly where you want them to be, in the middle. How can you check this? Shoot a grey card, and check your histogram of that grey card image in Photoshop. The levels should show you most of the data in the middle, or very close. If you are off, you are either over or under exposing your files and you are asking for trouble. Your white balance should be neutral, with no color cast. How can you verify? You should first of all should be creating a custom white balance for each lighting scenario. In our studio I created a custom white balance and never change it. It works all the time because the lights and the studio setting is consistent. On location each scenario requires a custom white balance. It's very easy when you get the hang of it.
To check that you are getting a fairly neutral image from you custom white balance, again, shoot a grey card, in Photoshop use the color picker, and the RGB numbers should all be very close together. This means your image is neutral. If any of the RGB numbers are way off, you have a color cast in that direction. Master this and you are 90% of the way to success.
2-Adjust contrast: For many images we hardly do much contrast adjusting. Sometimes we slightly "tweak" the file in levels, but you can easily get carried away here and 'over process' the image. When you do that, there's no turning back. It's like over-cooking a steak. Too late, once it's cooked. So be careful here.
My rule of thumb? Less is more. If you have to ask yourself "Does this need more contrast?," then you're done. STOP! But I do a step before anything else, and it does adjust the contrast as a side effect. You will never hear about this in any digital photography course or book. As a matter of fact, they will ("they", being the "experts") likely frown upon this step. Try it anyhow. We do, on every sinlgle image we work on. And that's a lot of images. Here it is: In Photoshop go to Filter/Sharpen/Unsharp mask. Apply the following settings: Amount 60 Radius 20 Threshold 0. See how it removes the haze? Cool uh? And it just beefs the image up a bit. Now this filter is also used to sharpen image, but this step is not a sharpening step. We call it the de-fog step.
3-Enhance the skin tones: For all you nature and scenic photographers this step may not apply. But try it anyhow, it may help. The idea behind it is to bring out the reds in our skin tones, for all skin types. In the good old days of retouching by hand, we used to finish the print off with a layer of red.
This always brought the final steps of those long tedious retouching by hand steps together just nicely. How do we do this? Simple. In Photoshop go to Image/Adjustements/Selective Color. You will notice that the red channel is the default chanel. This is the one we want so don't switch. Pull the top slider, Cyan, over to the left, and watch the colors, especially in the skin, warm up. Adjust it to your taste. We find that most images are within the -20 to- 40 range. That's it! Assuming you have a good exposure and good white balance, this is the only color "enhancing" you will need to do.
4-Adjust the saturation: When I shoot I turn the cameras' sharpening, contrast and saturation features off. I don't want the camera doing any of these important steps for me, since every image requires a different amount in order for it to be optimum. The images that come off the camera tend to look a little flat, dull and sometimes not sharp. But that's good! I get to adjust these myself.
The saturation will add a whole lot of life to your images, if done properly. Again, less is more. Here's how: In Photoshop go to Image/Adjustements/HueSaturation and pull the middle saturation slider over to the right. It helps if you enlarge your image so you can really see this effect and not over do it. This works very well on scenics and underwater images as well. But be careful not to over process. Remember, less is more.
5-Burning and Dodging: Over and over, I see it all the time. Using the right amount of good old fashioned burning or dodging and you will take your images to whole new level. It isn't easy to master however. Way back when I started out in photography, my mentors and early instructors were well versed and skilled in the ways of this traditional application. They knew and valued the importance of an image that was properly worked. The rookie mistake I see over and over is either not using enough (or none at all), or using too much. It takes some doing but this skill is worth mastering. Here's how: On the toolbar in Photoshop, click on the dodge/burn tool. It has both. Burning is by far the one you will use the most. When you select burn, the control bar accross the top will allow you to set the brush options. These settings are vital to your success. First, select a soft brush. The size will depend on the area you are burning. When I am burning all around an image, I generally choose a larger than the image area size. Next, choose Highlights in the range options. Next, bring your exposure down, way down to about 20. Now you are are ready to do the first step. Burn all around a few times, and stop after you notice a very slight darkening. Next, switch the Range to midtones. The first step, in highlight mode in the Range bar, gives your image some teeth for the next step. Now burn around again, careful not to over do it. The success of proper burning will depend on how well you can achieve an almost imperceptable dark vignette look to the image. If it's too obvious, then you've over done it. I should point out that this is not recommended for white or very light images.
6-Sizing: Almost done. We size two ways. For prints smaller than 11"x14", we use the crop tool and simply crop and save as required. For larger prints we use a technique that will magically increase your images to just about any size without any virtual deteriotion. Here's how. In Photoshop go to Image/Image Size. In Document Size, switch the option in the drop down menu from inches to percentage. Only do this on the top "witdh" option: replace 100% with 110% and click okay. Make sure Constrain Proportions and Resample Image options on the lower left are clicked on. The image will increase in size by 10%. Do this until you have reached the size you want. It's amazing! Virtually no deteriotion at sizes up to and beyond 40 inches. Try it.
7-Sharpening: This is the last step, well, almost. My sharpening approach is not something you will hear about in any course or book. Again, I figured out what works, and what works best. I was able to get tack sharp images from file sizes as small as 3.4 MP. Here's how: Go to Filter/Sharpen/Unsharp and start with these settings: Amount 500%, Radius .2, and Threshold 0. Click on preview. Highlight the Radius number and start to increase that number (I use the "up" arrow on my keyboard) one step at a time until the image slightly "pops". That's when it's done. If it pops too much, bring it back one number in the radius. I don't even touch the other two settings. They will not recommend this technique in any course or book, but it works in the trenches. I'm sure it breaks all sorts of rules. The final step for all images is by to Filter/Noise/Add Noise, and set the amount at 1. Why do I do this? It gives the image a slight texture, a little bit of "love".
That's it! In a nutshell. From the trenches. There are more technical and highly advanced ways of getting these steps done, but frankly, in the end, you won't see the difference. I know, I tried em all! Fact is the only expert in the game of portrait photography is the client. All she cares about is great looking images. She doesn't care if I shot using RAW mode (which I don't by the way, always JPEG). She doesn't care how many megapixels I use. She doesn't care what kind of lights I use, how I workflowed my images, whether I did them on a MAC or a PC (PC by the way). She ultimately is the final judge and jury.

The importance of shareware submission

The first step to increase your shareware sales is submitting your product to the top ranked download sites and directories. Tips on how to promote your software using shareware submission.
Submit shareware for higher sales
The first step to increase your shareware sales is submitting your product to the top ranked download sites and directories. You can do this yourself, but beware that it takes time and effort to get listed. The alternative is to request a professional's help. There are many companies offering the service, some are specialized in software submission, others offer several marketing services or even entire ecommerce solutions.

Major advantages of shareware submission:

• More visibility and downloads, which in the end means more shareware sales;
• Targeted traffic, one of the main purposes of shareware promotion;
• More back- links and increased link popularity, which enhance your website's page ranking and position in the main search engines;
• Easy way to promote your software - some sites include new shareware submissions in the most visible part of their home page, others may also include these in their newsletters;
• The chance to improve your software, based on users' feedback. Many of these sites and directories provide real-time feedback from users in the form of rates or comments.

For a successful shareware submission focus on the following steps:

• Create a good PAD file. PAD (Portable Application Description) is a new XML - based standard helping authors provide product descriptions and specifications to online sources in a standard way, using a standard data format that will allow webmasters and program librarians to automate program listings.
  PAD usage has become very popular because it simplifies the entire submission process - both for authors and webmasters. Basically it allows you to register your programs quickly, using only the URL of the PAD - file.
• Try to find the appropriate category for your site – this will improve your targeting.
• Write a high-quality site description. Some sites require a short description, others a more elaborate one. Be prepared for both situations.
• Provide correct information. Double check any piece of information you submit.
• Get listed in as many download sites and directories as possible.
• Keep track of all the sites and directories you have submitted your software to.
• In order to continually promote your shareware, don't neglect to submit new or modified versions. Many sites sort the information by the date of the last update.
• Analyze the traffic you get from these sites and concentrate on those who really bring you customers.

Shareware submission is all about including your product in as many download sites and directories as possible. Always keep in mind that downloads, targeted traffic and most important, sales, come from a sustained presence on the internet.