Once you have designed the high-level layout of your application's visual parts, try to identify common elements. These common elements tend to be good opportunities for reuse, and therefore can be made into reusable parts and added to the parts palette.

For example, let's return to the application that maintains the customer, order, product, inventory, and employee information of a business. Consider the visual part for the order-taker who enters orders into a database. Along with such information as the types and quantities of products ordered, an order address and a ship-to address need to be entered. The common address elements can be made into a reusable composite visual part that might look like this:

The same address form visual part can then be used in other places where an address is needed in the order-entry visual part. The part could also be used in a customer-entry visual part and possibly additional places in the application.

By reusing parts, you increase productivity. For example, you have to lay out the form and set the field formats for USA State and Zip Code only once.

You also get the potentially more important benefit of improved maintenance. For example, if an error is discovered, you only have to fix it in one place. Or later, if the business decides to start using an Auxiliary address field, you would only have to make the change once to your address form part, and the changes would automatically be reflected everywhere the part is used in the application.

Likewise, if the business grows into worldwide sales, then you could change State to State/Region, add a Country field, and change Zip code to Postal code (provided you are using a database that can also accommodate such changes). Having to make such a change only once is a tremendous benefit.

Reusable parts aren't just visual parts either. You can create reusable nonvisual parts that contain database queries and their tear-off attributes, for example. This way, the programmers who are skilled at creating database queries can create certain parts, and the programmers who are skilled at creating user interfaces can create other parts. Even if you use these parts in only one application, you still benefit by optimizing each programmer's skills