Abstract:
Localizing a software product is improved. A plurality of attributes of a plurality of interface elements according to a specified type of user interface are retrieved. Responsive to user input, one or more countries in which the software product is to be localized are specified. An interface element for the user interface is selected. From the attributes of the selected interface element, it is determined whether the interface element is consistent with the specified countries. If not, an alert on a computer display is displayed, in the event the selected interface element is not consistent with the countries specified by the user. The invention also calculates a cost of localizing the selected interface element, wherein the projected cost of localizing the user interface is incremented with the cost of localizing the selected interface element. An alert for the projected cost of localizing the user interface is displayed on the computer display.

Description:
TECHNICAL FIELD 
     The present invention relates to a method, system and computer program for estimating the cost of localizing a software product. 
     BACKGROUND 
     The global nature of the web and the growing acceptance of electronic commerce have been instrumental in helping companies reach ever-wider markets. However, as their markets expand, it is becoming increasingly important for businesses to ensure that their products comply with local languages and customs. 
     Localization refers to the process of adapting a global product for the language and customs of a particular country. The localization of a software product embraces three components, namely, its graphical user interface (GUI), its online help system and its supporting documentation. A GUI typically comprises the menus, dialogue boxes, error messages, etc. that a user sees when using the software product. However, in practice, usually only a small portion of a GUI needs to be translated during localization (e.g., the text displayed in menus and dialogue boxes or error message boxes). In contrast, most of the content of an online help file must be translated (apart from hyperlinks etc). Supporting documentation includes user manuals, read_me files etc., wherein user manuals are usually highly formatted documents that must reach the target users and read_me files usually contain set-up information or additions to the user manuals. Normally, both forms of documentation must be almost entirely translated during localization. Localization also encompasses other issues apart from translation. For example, in the case of Arabic localization, some of the graphical elements (e.g., text fields or selection lists) in a GUI may not comply with Arabic textual rules (i.e. Arabic text is typically written from right to left rather than the Western approach of writing from left to right). 
     In view of the broad range of translatable components in a software product, localization costs can range from $50,000 to half a million dollars per language. This is clearly a significant expenditure for any product or marketing budget. Thus, before embarking on localization, it is necessary to calculate localization costs and expected revenue from a localized product to determine whether localization is, in fact, economically justifiable. Apart from purely financial considerations, it is worth bearing in mind that translation can take a considerable amount of time, which must be taken in account when planning a software development project. Thus, a project manager also needs an indication of the required time frame for localizing a particular design. 
     Furthermore, a project manager often has to calculate localization costs several times during a product development life-cycle, when, for example, the project manager receives product change requests from different stakeholders. In this case, the impact of the requested changes on the localization cost and time frame must be carefully evaluated. 
     In order to calculate the likely cost and time frame for localizing a software product, it is necessary to obtain a precise and reliable analysis of the quantity and the type of text to be translated therein. However, whilst there are a number of automatic tools currently available for calculating the localization cost for rendering GUI panels, there are, at present, no tools available for accurately and automatically determining the overall cost of localizing a software application. Thus, in the absence of such tools, project managers must use their own personal techniques for performing these calculations, a process which is both time-consuming and imprecise. 
     Furthermore, the process of designing a GUI is normally completely decoupled from that of determining localization costs. In particular, developers typically design their own GUIs (using for example Microsoft Visio®) and subsequently write the code therefore. It is only when the overall software product has been fully developed, that a resource file (containing the words to be translated) is created and a separate application used to count the words therein. 
     US Patent Application No. US20040167768 describes a parser that parses web pages in order to count the translatable words therein. However, the parser described in US20040167768 focuses on assessing web pages that have already been developed. This provides no assistance to a project-manager in making design decisions during the development phase of a software product. 
     SUMMARY 
     The invention provides a method, system and product for localizing a software product. A plurality of attributes of a plurality of interface elements according to a specified type of user interface are retrieved. Responsive to user input, one or more countries in which the software product is to be localized are specified. An interface element for the user interface is selected. From the attributes of the selected interface element, it is determined whether the interface element is consistent with the specified countries. If not, an alert on a computer display is displayed, in the event the selected interface element is not consistent with the countries specified by the user. The invention also calculates a cost of localizing the selected interface element, wherein the projected cost of localizing the user interface is incremented with the cost of localizing the selected interface element. An alert for the projected cost of localizing the user interface is displayed on the computer display. 
    
    
     
       BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS 
       An embodiment of the invention is herein described by way of example only, with reference to the accompanying Figures in which: 
         FIG. 1  is a table of an exemplary profile of a GUI element; and 
         FIG. 2  is a flow-chart of the method of the preferred embodiment; and 
         FIG. 3  is a block diagram of a computer system configured to allow the method the preferred embodiment to be operated thereon. 
     
    
    
     DETAILED DESCRIPTION 
     For simplicity and clarity, individual elements (e.g., Header, Text Field, Drop Down list, Checkbox, Radio Button, Table, Tree or Message etc.) in a GUI will be known henceforth as “widgets”. As discussed above, localization costs are dependent on inter alia the number of words and nature of words/text, etc. (e.g., Arabic/Chinese characters etc.) to be converted. Thus, for simplicity, the features of a GUI having an impact on its localization cost will henceforth be generically known as “resources”. Similarly, the number of these features in a GUI will be known henceforth as the GUI&#39;s “resource count”. 
     Central to the present invention is the direct association of each widget in a GUI with a profile listing the widget&#39;s attributes. Take, for example, a text field having a label associated with a fly-over (i.e. text shown when a mouse is passed over the text field). Referring to  FIG. 1 , the text field&#39;s profile may comprise attributes such as the maximum and minimum limits on the label, the length of the flyover text, and the countries with whose languages and customs the label and flyover text comply. While the present invention provides the attributes with default values, the user may alter these values. For example, the user can set the profile of the above-mentioned text field to indicate that the text field is compliant with the languages and customs of all countries apart from Arabic countries and China. 
     The specific association of a profile with a widget, enables each widget to be uniquely identified, this in turn provides a simple, reliable and controllable mechanism for calculating and updating the overall resource requirements of a GUI. More particularly, the developer is provided with a real-time evaluation of the resource cost incurred by the addition of each new widget to a GUI. The unique identification of a widget by its profile also prevents text in a widget that appears in several panels of a GUI from being repeatedly counted when estimating the overall localization requirements of a software application. 
     When assessing localization costs, it is important to know the nature of the text to be translated. In particular, since help files typically comprises text including complete sentences, they are usually more easily translated than labels whose meaning depends on the context in which they are used. For example, the translation of the label of “Group by” differs according to whether “Group by” refers to a main name, product name etc. To overcome this problem, the present invention includes additional information about each widget in its associated profile. In particular, the present invention provides contextual information about text to be translated, indicating the kind of widget in which it appears (e.g., the “Group by” label is the header for a table). Using this information, the present invention can provide an itemised summary of the resource counts of the different types of widgets in a GUI (e.g., the word count of labels, messages, help text etc.). Similarly, since widgets in web GUIs or standalone java GUIs may have different resource counts, the preferred embodiment includes an indication of a widget&#39;s context in its profile. 
     The preferred embodiment enables a profile to be retrieved from an archive of widgets and their profiles. Alternatively, the preferred embodiment allows a user to customise or design a profile a widget. Similarly, the preferred embodiment includes a mechanism for retrieving a widget&#39;s profile from a web service and updating the preferred embodiment&#39;s own archive of profiles with the retrieved profile. 
     The preferred embodiment also provides an interactive facility for warning the developer of potential problems with a GUI and enabling the developer to take remedial steps to correct the problem. For example, if a developer has specified a list of countries in which a software application is to be sold, the preferred embodiment can alert the user if a widget in a GUI (or a built panel) of the software application does not comply with the languages or customs of any of the countries specified by the developer. Similarly, the preferred embodiment can alert the user if a change to the widget changes the PII estimate beyond a pre-defined threshold. 
     The preferred embodiment also provides a mechanism for updating a widget&#39;s profile and using the updated widget profiles to update the overall projected resource count of the software application. 
     Similarly, the preferred embodiment includes a recalculation mechanism which on receipt of a request for changes to the design of a GUI, re-calculates the overall projected resource count of the changed GUI and advises the project-manager of the cost of implementing the requested change to the GUI and identifies the files that must be re-translated to accommodate the request. 
     In a first form, a preferred embodiment is a complete stand-alone software application which:
         enables a planned rendering of a GUI to be built therein;   completely manages the process of ensuring the GUI&#39;s compliance with the local requirements of its target markets; and   provides a detailed estimate of the cost of localizing the GUI.       

     In another form, a preferred embodiment is a plug-in, which (during the design phase of a software application) can be integrated into an existing modelling package (e.g., Microsoft®Visio®) for the GUI. 
     Referring to  FIG. 2 , in use, the method of the preferred embodiment checks  10  whether a GUI opened by a user is a new GUI or an existing work in progress. If the GUI is new, the preferred embodiment requests  12  the user to specify the type of GUI (i.e. web or java or others). Using this information, the preferred embodiment retrieves  14  (from a first database) a library of widget profiles appropriate to the GUI type specified by the user. The preferred embodiment also allows the user to define  16  profiles for widgets that do not currently have a profile or for custom widgets not present in the retrieved library. The preferred embodiment then allows the user to specify  18  the countries in which the new GUI is to be localized. In the event the GUI opened by the user is an existing work in progress, the preferred embodiment simply retrieves  20  an appropriate library of widget profiles for the GUI. The preferred embodiment also retrieves  22  the current overall projected resource count of the GUI. 
     The preferred embodiment allows a user to add  24  a widget to the GUI, by selecting the required widget from the retrieved library (or a custom designed widget) the preferred embodiment. The preferred embodiment then checks  26  the profile of the selected widget to determine if it is consistent with the countries of localization previously specified by the user. In the event the selected widget is not consistent with the countries specified by the user, the preferred embodiment issues  28  an alert to the user and allows the user  24  to select another widget. 
     In the event the selected widget is consistent with the countries specified by the user, the preferred embodiment uses the data in the widget&#39;s profile to calculate  30  the widget&#39;s resource count. The widget&#39;s resource count is added to an existing overall projected resource count for the GUI (which includes the resource counts of any previously included widgets to the GUI) to thereby update  32  the GUI&#39;s overall projected resource count. Thus, each addition of a widget to the GUI progressively increases the overall projected resource count of the GUI. 
     The preferred embodiment also allows the user to amend  34  the widget&#39;s profile. In which case, the overall projected resource count for the GUI is updated  32  accordingly. On receipt  36  of a request for changes to the design of a GUI, the preferred embodiment re-calculates  38  the overall projected resource count of the changed GUI and advises  40  the project-manager of the cost of implementing the requested change to the GUI. The preferred embodiment also identifies the files that must be re-translated to accommodate the requested change. In the event the project manager decides to implement the requested change, the preferred embodiment updates  44  the overall projected resource count of the GUI to reflect the changes made thereto. 
     Finally, once all the translation tasks are completed and all the resources bundle are released, the preferred embodiment recalculates  48  the overall resource count of the application and provides a report to the developer. The overall resource count in this case is not a projected overall resource count. Instead, it is a precise count of the words that were translated in the final software application. Thus, for the sake of clarity and brevity, this resource count will be known as a “real overall resource count” (to distinguish it from the projected overall resource counts calculated as the software application is developed). The preferred embodiment then updates  50  the GUI profile (defined at the start of the product development) with the real overall resource count, so that the updated profile can be used for the next release of the product. 
     Referring to  FIG. 3 , a generic computer system  50  adapted to support the preferred embodiments is formed by several units that are connected in parallel to a system bus  52 . In detail, one or more microprocessors (XP)  54  control operation of the computer  50 ; a RAM  56  is directly used as a working memory by the microprocessors  54 , and a ROM  58  stores basic code for a bootstrap of the computer  50 . Peripheral units are clustered around a local bus  60  (by means of respective interfaces). Particularly, a mass memory consists of a hard-disk  62  and a drive  64  for reading CD-ROMs  66 . Moreover, the computer  50  includes input devices  68  (for example, a keyboard and a mouse), and output devices  70  (for example, a monitor and a printer). A Network Interface Card (NIC)  72  is used to connect the computer  50  to the network. A bridge unit  74  interfaces the system bus  52  with the local bus  60 . Each microprocessor  54  and the bridge unit  74  can operate as master agents requesting an access to the system bus  52  for transmitting information. An arbiter  76  manages the granting of the access with mutual exclusion to the system bus  52 . 
     Similar considerations apply if the system has a different topology, or it is based on other networks. Alternatively, the computers have a different structure, including equivalent units, or consist of other data processing entities (such as PDAs, mobile phones and the like). 
     Alterations and modifications may be made to the above without departing from the scope of the invention.