Patent Publication Number: US-2017371687-A1

Title: Automated globalization enablement on development operations

Description:
BACKGROUND 
     The present disclosure relates to software development, and more specifically, to providing dynamic globalization enablement in a software development environment. 
     Globalization enablement relates to adapting computer software to conform to requirements of a given locale. The requirements may include adherence to languages and cultural conventions, such as code sets, character classifications, character comparison rules, character collation order, monetary formatting, numeric punctuation, date and time formatting, and the like. Many businesses that provide applications to international markets use some form of globalization enablement to adapt the applications for those markets. Applications that include globalization functionality typically invoke application programming interface (API) methods at initialization to localize the application to be specific to a target region, e.g., such that the language is set to that of the users of the region, numbering conventions adhere to that of the region, currency symbols are set to that of the region, etc. 
     Including globalization features in an application is typically complex. During the development phase of a given application, a developer needs to know where in the application source code to insert appropriate API calls to provide certain globalization features. For example, in some development environments, a specific sequence of API calls is necessary to insert the globalization feature into the application. In some cases, a developer may call a given API method at an ineffective location or in the wrong sequence, which may result in the globalization feature being non-functional at runtime of the application. Further, in other cases, developers may directly hard-code message string literals in a given language (e.g., English, Chinese) for user interface components (e.g., error messages, status messages, menu items), rather than calling the appropriate API methods to determine an appropriate language that a given user interface component should display. 
     Consequently, providing globalization enablement to a given application is prone to errors. Typically, to address such errors, the application may undergo global verification testing to ensure that such errors are identified prior to deployment. However, as many businesses adopt modern software development operation paradigms, such windows for testing have grown smaller. And as a result, the application may be deployed with globalization feature-related errors intact. Therefore, more reliable methods for globalization enablement in software development are desirable. 
     SUMMARY 
     One embodiment presented herein discloses a method. The method generally includes retrieving source code for developing an application. The application is assigned to support a plurality of specified globalization features. The method also includes evaluating the source code for each of the plurality of specified globalization features. Upon determining that the source code does not include at least a first specified globalization feature in the plurality of specified globalization features, an application programming interface (API) associated with the at least the first globalization feature is identified. Source code associated with the API is inserted into the source code for the application. 
    
    
     
       BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS 
       So that the manner in which the above-recited features of the present disclosure can be understood in detail, a more particular description of the disclosure, briefly summarized above, may be had by reference to the embodiments, some of which are illustrated in the appended drawings. It is to be noted, however, that the appended drawings illustrate only exemplary embodiments and are therefore not to be considered limiting of its scope, and may admit to other equally effective embodiments. 
         FIG. 1  illustrates an example computing environment, according to one embodiment. 
         FIG. 2  further illustrates the globalization development operation information system manager described relative to  FIG. 1 , according to one embodiment. 
         FIG. 3  illustrates a method for evaluating developer source code for globalization features, according to one embodiment. 
         FIG. 4  illustrates a method for formatting developer source code to conform to globalization enablement standards, account to one embodiment. 
         FIG. 5  illustrates an example of converting hard-coded messages in developer source code to conform with globalization enablement standards, according to one embodiment. 
         FIG. 6  illustrates an example computing system configured to provide globalization enablement, according to one embodiment. 
     
    
    
     DETAILED DESCRIPTION 
     Embodiments presented herein disclose techniques for providing globalization enablement features and verification testing to an application. In particular, techniques provide a globalization development operation information system (GDOIS) that interfaces with an integrated development environment (IDE) tool, e.g., executing on a developer system. The GDOIS assists the IDE tool in developing applications that use globalization features to adapt the application to a given region (e.g., regional language support, adherence to numerical, naming, and unit conventions of the region, and the like). 
     In one embodiment, the GDOIS evaluates developer source code for an application project in real-time or check-in of the source code to a repository. The GDOIS does so to determine whether the source code conforms to globalization enablement requirements associated with the application project, such as whether application programming interface (API) method calls associated with globalization features are made in a correct sequence. For example, some software development environments require that to provide translatability functionality (e.g., to translate user interface components at runtime initialization to a language associated with a target region), the source code should first call an API method that sets the default locale for the application. Next, the source code should then call a method for opening a category descriptor, a method for retrieving a category descriptor, a call to the globalization feature method, and then a call closing the category descriptor. In this example, if a developer calls the methods in a manner that deviates from this order (or neglects to include one of the methods), the globalization feature might fail to function correctly. Further, the GDOIS may scan the developer source code to check for hard-coded string literals that correspond to some component of the application that should instead be an API call to some globalization feature (e.g., a translatability-related method). For instance, a developer might hard-code “Accept” and “Reject” buttons for a dialog box in English, where, under globalization enablement standards, the code for the corresponding “Accept” and “Reject” buttons should call an API to display the text in the language associated with a target region. Hard-coding the message string literals in this case can be problematic if the application is deployed in non-English-speaking countries. 
     In one embodiment, the GDOIS may detect areas in developer source code that do not comply with globalization enablement standards, such as in the examples described above. Once detected, the GDOIS may replace the non-compliant portions of the code with source code that provides the globalization feature at that location. Continuing the previous example of the “Accept” and “Reject” dialog buttons, the GDOIS may extract the text within the hard-coded message strings and place them into a text file associated with the regional language settings. The GDOIS may then remove the hard-coded message string from the source code and then replace it with a call to a globalization API method that retrieves the string from a text file associated with target regional language settings. By doing so, the application may, at runtime initialization, call the method used for the “Accept” and “Reject” buttons and display the buttons in a language appropriate to a region setting of the application. 
     In addition, the GDOIS verifies developer source code in real-time to ensure that developer source code complies with the specified globalization requirements associated with the application. The GDOIS may do so without having to fully compile the source code into a binary executable. Instead, the GDOIS may create a temporary build of the developer source code and execute the build in a test environment. For example, the GDOIS can execute the build under one or more test cases to check for any errors in implementing globalization enablement in the source code. Additionally, in one embodiment, the GDOIS also allows a virtual verification procedure, where the GDOIS logically verifies developer source code by determining whether the source code adheres to globalization enablement standards based on the specified requirements associated with the underlying application project. In doing so, the GDOIS may also determine whether necessary files in the application project, e.g., language files and sub-directories associated with targeted regions are present. For example, the verification might fail if a translation file associated with a given target region is missing. 
     Embodiments presented herein disclose techniques for dynamically enabling globalization features to an application in a software development environment. The GDOIS proactively updates and verifies developer source code to comply with predefined globalization enablement requirements, prior to a developer checking the code in to a repository or compiling the code into a binary executable. Advantageously, detecting non-compliant portions of code (e.g., hard-coded string literals in a region-specific language) and replacing those portions with globalization-enabled source code reduces the amount of globalization enablement errors in the resulting application at deployment. In addition, the GDOIS also verifies the application that the globalization features are functioning properly, prior to check-in or to compilation, which significantly reduces the time of a development operation cycle for a given application. 
       FIG. 1  illustrates an example computing environment  100 , according to one embodiment. As shown, computing environment  100  includes a developer system and a globalization development operation information system (GDOIS)  110 , each interconnected with a network  115  (e.g., a local area network, the Internet, etc.). In one embodiment, the developer system  105  is a physical computing system (e.g., a desktop computer, laptop computer, tablet computer, etc.) or a virtual computing instance executing in a cloud. Similarly, the GDOIS  110  may be a physical computing system (e.g., residing in a data center, workstation, etc.) or a virtual computing instance executing in the cloud. In one embodiment, computing environment  100  represents a software development environment having multiple developer systems  105  creating one or more application projects. 
     In one embodiment, the developer system  105  includes a developer toolkit  107  which provides an integrated development environment (IDE) application  108 . A user, such as a software developer for an enterprise, may create software applications via the IDE application  108 . In particular, the IDE application  108  provides a user interface that allows the software developer to create or edit application projects and files that are part of or associated with those projects (e.g., application source code, user libraries, and the like). Further, the developer toolkit  107  may provide compilers to generate an executable from the application projects. In the software development environment, the developer may save updates to application source code and check-in the code to a repository (not shown) storing the application projects. 
     In some cases, the enterprise may impose globalization requirements on applications created in the software development environment. Such may be the case for applications that the enterprise desires to make available in different countries. In such a case, a developer will need to program a given application such that the application is adaptable to target regions. 
     For example, assume that a software developer designs a payment processing application that can be used in various countries, such as the United States and France. When released in France, the payment processing application should adhere to regional and cultural conventions of the country. For example, the payment processing application should display relevant text in French, currency signs in Euros, dates in Day/Month/Year format, and the like. To reduce time in adapting a United States-specific version of the payment processing application to a France-specific version (and other region-specific versions), a developer may take advantage of globalization enablement application programming interface (API) libraries. 
     Generally, globalization enablement APIs provide sets of methods for adapting a given application to a particular region. For example, APIs can include methods for setting and retrieving locale information, formatting a date and time to conform with a set locale, formatting a currency pattern to conform with a set locale, set and retrieve preferred language information for a set locale, insert strings for user interface components in a set preferred language, etc. 
     At times, however, a developer might incorrectly use (or neglect to use) globalization enablement APIs during development of an application project. For example, the developer may, instead of calling a particular globalization enablement method for a message to be displayed in a status dialog box of an application, hard-code a string literal representing the message in a native language of the developer. This may cause translatability problems when the application is deployed in other countries. For instance, if the application is eventually ported to another country (that does not use the native language of the developer), and the hard-coded string literal is not identified prior to deployment to the other country, the application will still display the hard-coded string literal in the native language of the developer. 
     To address issues such as these, in one embodiment, the GDOIS  110  evaluates developer source code (via globalization enablement daemons  109  provided by the developer for enablement of globalization features in real-time and/or prior to check-in of the code to the repository. As further described below, the GDOIS  110  updates the source code to comply with specified globalization enablement requirements in the event that deficiencies (e.g., such as the examples described above) are detected. Further, the GDOIS  110  performs a variety of software globalization verification tests to the application project (e.g., to the source code itself or to a temporary build of the application) in real-time or prior to check-in of the source to ensure that the application complies with specified globalization enablement requirements. 
     To that effect, the GDOIS  110  includes a development operation information system manager  112 .  FIG. 2  further illustrates the development operation information system manager  112 , according to one embodiment. As shown, the development operation information system manager  112  includes a source code examination component  205 , a globalization request analyzer  210 , a globalization code generator  215 , a verification component  220 . The development operation information system manager  112  may also be associated with or include verification logs  225 , a specification check list  230 , one or more globalization enablement profiles  235 , one or more source code templates  240 , and a test case repository  245 . 
     In one embodiment, the specification check list  230  for a given application project is a predefined (e.g., by a globalization architect or development operations manager) list of globalization enablement features that should be included with the application. The specification check list  230  may include a targeted market region, languages associated with that region that need to be translated for the targeted market region, business mode associated with the application (e.g., an information management application, enterprise financial management tool, social media application, etc.), and any cultural-dependent features (e.g., time and date formats, currency symbols, numerical conventions, etc.). Further, in one embodiment, a globalization enablement profile  235  for a particular application project is a configuration file that specifies parameters for corresponding globalization enablement features. For example, a globalization architect can add a configuration setting to enable or disable real-time examination of the source code. As another example, the globalization enablement profile  235  may specify partial enablement of certain globalization features, which allows for incremental enablement during the development process. 
     In one embodiment, the source code examination component  205  evaluates source code of an application project based on design documents associated with the source code and development settings. The source code examination component  205  does so to identify related translatability calls and other potential issues in the source code as pertaining to globalization enablement. For example, the source code examination component  205  may scan for hard-coded string literals in the source code and determines whether the strings should be replaced with calls to an appropriate API method. To do so, the source code examination component  205  may first identify a given hard-coded string literal in the code and evaluate one of the design documents associated with the application. Then, the source code examination component  205  may flag the hard-coded string literal for further review (e.g., by the globalization request analyzer  210 ). As another example, the source code examination component  205  may flag API calls to globalization enablement methods that are performed out of sequence. 
     In one embodiment, the globalization request analyzer  210  evaluates the source code relative to the specification check list  230  to determine whether the source code includes the globalization enablement APIs and translatability codes described in the specification check list  230 . For example, if the specification check list  230  defines that the source code needs translatability functions, but the globalization request analyzer  210  cannot find an API call to a method for setting a locale in the application, the globalization request analyzer  210  may provide an indication to insert the proper method call to the source code at a proper location. The indication may include a description of a given issue detected in the source code, a line in the source code where the issue was detected, a recommendation of what code to replace or insert to the code. 
     In one embodiment, the globalization code generator  215  includes a set of modules for generating and inserting globalization-enabled source code based on the output of the source code examination component  205  and indications by the globalization request analyzer  210 . To do so, the globalization code generator  215  may evaluate the indications to determine an action to perform on the source code. For example, if the globalization request analyzer  210  indicates a recommendation to display a translated message based on a detected hard-coded string literal, the globalization code generator  215  may extract the hard-coded string literal and store it in a translatability file (used as a parameter for a translatability API method call) and replace the hard-coded string literal with the translatability API method call. To provide the globalization code generator  215  with the correct call, the globalization code generator  215  may evaluate source code templates  240 . In one embodiment, the source code templates  240  provide a set of globalization enablement sources used to solve different globalization requirements on different business modes. Such templates  240  can be in a variety of programming languages, such as Java, C++, pseudocode, etc. For instance, the source code templates  240 , for areas of source code identified to be related to translatability of a usage status message in a user interface, may provide a sequence of calls, such as calls to a method for setting a region locale, opening a category descriptor, retrieving a category relating to usage, and closing the category descriptor. As another example, the globalization request analyzer  210  may indicate that a portion of the source code should include globalization enablement for currency formatting. A template  240  for such a case may include calls to a method for setting a locale and calling a monetary formatting method. The globalization code generator  215  may apply a corresponding source code template  240  to the developer source code. 
     In one embodiment, the verification component  215  may generate a temporary build of the developer source code, e.g., prior to check-in of the source code to the repository. Further, the verification component  220  may execute the build against one or more of the verification test cases in the test case repository  245  to determine whether the new globalization-enabled source code performs as expected. In addition, the verification component  215  may evaluate updated source code after the globalization code generator  215  inserts globalization-enabled code therein. For example, the verification component  215  may evaluate a correct sequence of API method calls associated with translatability. Further still, the verification component  220  may record results of the verification tests to the verification logs  225 . 
       FIG. 3  illustrates a method  300  for updating developer source code to comply with globalization enablement requirements (e.g., specified in the check list  230  associated with a given application project), according to one embodiment. In this example, assume that a developer completes writing source code for a given application project and requests to check-in the code to the repository. Of course, method  300  may be applicable in cases where the developer is writing code in real-time. As shown, method  300  begins at step  305 , where the source code examination component  205  receives source code in a temporary code buffer. The source code examination component  205  may evaluate lines in the source code relative to design documents associated with the application project and the specification check list  230 . Doing so allows the source code examination component  205  to identify potential issues with the source code relative to globalization enablement requirements specified in the specification check list  230 , such as hard-coded string literals in the source code that should be replaced with translatability API calls. 
     At step  310 , the globalization request analyzer  210  determines, based on the output of the source code examination component  205 , whether the source code complies with globalization enablement standards specified for the application. If so, then at step  330 , the development operations information system manager  112  checks in the code to the repository. 
     Otherwise, at step  315 , the globalization request analyzer  210  determines one or more portions of the code that does not comply with the globalization enablement standards. To do so, the globalization request analyzer  210  identifies the predefined requirements (from the specification check list  230 ) that are deficient in the source code. For example, if the specification check list  230  specifies that the application should include globalization features for translatability but the source code itself does not include any calls to a method that sets a locale for the application, the globalization request analyzer  210  may generate an indication that includes a recommendation to insert that call in the source code. The indication may also recommend a location in the source code in which to place the API method call. 
     At step  320 , the globalization code generator  215  replaces identified portions of the code with globalization-enabled source code. To do so, the globalization code generator  215  may evaluate indications received by the globalization request analyzer  210  relative to source code templates  240 . This step is explained in further detail relative to  FIG. 4 . 
     At step  325 , the verification component  220  evaluates the source code to determine that the source code complies with the globalization enablement standards. To do so, the verification component  220  may generate a temporary build of the source code on a server. The verification component  220  may then perform one or more test cases maintained in the test case repository  245 . An example test case determines whether messages output to the application, set for a given region, correspond to an expected message. The test case may fail if one of the messages differs from the expected message (e.g., this may be because the message corresponds to a hard-coded string literal that was written in a native language of the developer). If the verification component  220  identifies any errors, the verification component  220  may send such results to the globalization request analyzer  210 . In turn, the globalization request analyzer  210  may evaluate the results and send an indication to the globalization code generator  215  describing the issues. 
     At step  330 , after determining that the developer source code complies with the globalization enablement standards described in the associated specification check list  230  and globalization enablement profile  235 , the development operation information system manager  112  checks the code in to the repository. 
       FIG. 4  illustrates a method  400  for formatting developer source code to conform to globalization enablement standards, according to one embodiment. As stated, the source code examiner  205  and the globalization request analyzer  210  may detect potential issues in developer source code regarding compliance to specified globalization enablement standards. The globalization request analyzer  210  generates an indication for each area in the source code that is deficient with regard to globalization enablement (e.g., due to a hard-coded string literal, missing API calls, etc.). The globalization request analyzer  210  may the send the indication to the globalization code generator  215 . 
     As shown, method  400  begins at step  405 , where the globalization code generator  215  identifies, based on the indications send by the globalization request analyzer  210 , one or more globalization features that are deficient in the developer source code. The globalization code generator  215  parses the indications to identify missing globalization features. For example, the globalization code generator  215  may identify that an API call to set a locale within the source code is missing. The globalization code generator  215  may also identify that a currency formatting API is missing. 
     At step  410 , the globalization code generator  215  retrieves APIs associated with each of the identified globalization features. To do so, the globalization code generator  215  evaluates the source code templates  240  relative to the indications received by the globalization request analyzer  210 . 
     At step  415 , the globalization code generator  215  incorporates the APIs into the source code. In particular, the globalization code generator  215  may retrieve a corresponding template and apply the template to the source code. For example, the template may specify that the globalization code generator  215  extract a hard-coded string literal from the source code and store that string in a key-value structure listing translatability terms, saved in a directory corresponding to given locale. The globalization code generator  215  may pass the stored string to a translation server for translation into regional languages contemplated for application users in other countries. The template may also include source code corresponding to a translatability method call. The globalization code generator  215  may insert the call into the source code, using the stored string as a parameter. 
       FIG. 5  illustrates an example of converting hard-coded messages in developer source code to conform with specified globalization enablement standards, according to one embodiment. In particular,  FIG. 5  depicts example developer source code for a given application. For instance, item  505  illustrates source code defining an “Example” class. Within the example class are calls to a print method to display some text as output. In this example, the developer source code includes hard-coded string literals in English as parameters to each print method call: “Hello world!”, “What a wonderful place!”, and “See you in space!”. Such strings may be problematic in the event that the underlying application is adapted to non-English-speaking countries. Indeed, a specification check list  230  associated with the underlying application may specify translatability requirements for the application. 
     In this example, the source code examination component  205  and the globalization request analyzer  210  may detect the hard-coded string literals. Further, the globalization request analyzer  210  may send an indication of the hard-coded string literals to the globalization code generator  215 . The indication may recommend replacing the hard-coded string literals with translatability API method calls. In response, the globalization code generator  215  evaluates the indication with the source code templates  240 . The globalization code generator  215  may identify and retrieve a translatability API that provides a Messages class that includes a getString method, which retrieves a string from a specified text file. Once retrieved, the globalization code generator  215  may extract the hard-coded string literals from the source code and store the strings in a key-value store (at  515 ). Thereafter, the globalization code generator  215  may replace the hard-coded string literals in the source code with API calls for retrieving the corresponding text from the key-value store (at  510 ). The resulting source code at  515  complies with the specified globalization enablement requirements. 
       FIG. 6  illustrates an example globalization development operation information system (GDOIS)  600 , according to one embodiment. As shown, the GDOIS  600  includes, without limitation, a central processing unit (CPU)  605 , a network interface  615 , a memory  620 , and storage  630 , each connected to a bus  617 . The GDOIS  600  may also include an I/O device interface  610  connecting I/O devices  612  (e.g., keyboard, display, mouse devices, etc.) to the GDOIS  600 . Further, in context of the present disclosure, the computing elements shown in the GDOIS  600  may correspond to a physical computing system (e.g., a system in an enterprise network) or a virtual computing instance. 
     CPU  605  retrieves and executes programming instructions stored in memory  620  as well as stores and retrieves application data residing in the storage  630 . The bus  617  is used to transmit programming instructions and application data between CPU  605 , I/O devices interface  610 , storage  630 , network interface  615 , and memory  620 . Note, CPU  605  is included to be representative of a single CPU, multiple CPUs, a single CPU having multiple processing cores, and the like. Memory  620  is generally included to be representative of a random access memory. Storage  630  may be a disk drive storage device. Although shown as a single unit, storage  630  may be a combination of fixed and/or removable storage devices, such as fixed disc drives, removable memory cards, or optical storage, network attached storage (NAS), or a storage area-network (SAN). 
     Illustratively, memory  620  includes a development operation information system manager  621 . And storage  630  includes globalization enablement profiles  631 , a globalization specification check list  632 , source code templates  633 , a test case repository  634 , and verification logs  635 . The development operation information system manager  621  provides a user interface for managing development operations, such as activities on high-level and low-level design, code, and verification tests. 
     In one embodiment, the manager  621  may evaluate developer source code (e.g., via globalization enablement daemon processes executing on a developer system) for a given application project to determine whether the developer source code complies with globalization enablement profiles  631  and the globalization specification check list  632  associated with the application project. If issues relating to globalization enablement are identified in the source code (e.g., hard-coded string literals, misplaced or missing globalization enablement API calls, etc.), the manager  621  may insert (and/or replace) source code identified in the source code templates  633  such that the source code complies with the requirements. The manager  621  may perform these actions in real-time (e.g., using source code saved to a temporary buffer) or prior to a developer checking-in source code to a repository. 
     Further, in one embodiment, the manager  621  may verify the operability of the globally-enabled code inserted in developer source code using test cases from the test case repository  634  on a temporary build of the application project. In addition, the manager  621  may perform logical analysis of the source code (without having to create a temporary build of the code) to determine whether the code makes proper calls to globalization enablement APIs. In addition, the GDOIS may determine whether necessary files in the application project, e.g., language files and sub-directories associated with targeted regions are present. In one example, the verification might fail if a translation file associated with a given target region is missing. The manager  621  may record the results of the test cases to the verification logs  635 . 
     The descriptions of the various embodiments of the present disclosure have been presented for purposes of illustration, but are not intended to be exhaustive or limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terminology used herein was chosen to best explain the principles of the embodiments, the practical application or technical improvement over technologies found in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein. 
     In the following, reference is made to embodiments presented in this disclosure. However, the scope of the present disclosure is not limited to specific described embodiments. Instead, any combination of the following features and elements, whether related to different embodiments or not, is contemplated to implement and practice contemplated embodiments. Furthermore, although embodiments disclosed herein may achieve advantages over other possible solutions or over the prior art, whether or not a particular advantage is achieved by a given embodiment is not limiting of the scope of the present disclosure. Thus, the following aspects, features, embodiments and advantages are merely illustrative and are not considered elements or limitations of the appended claims except where explicitly recited in a claim(s). Likewise, any reference to “the invention” shall not be construed as a generalization of any inventive subject matter disclosed herein and shall not be considered to be an element or limitation of the appended claims except where explicitly recited in a claim(s). 
     Aspects of the present disclosure may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module” or “system.” 
     The present disclosure may be a system, a method, and/or a computer program product. The computer program product may include a computer readable storage medium (or media) having computer readable program instructions thereon for causing a processor to carry out aspects of the present disclosure. 
     The computer readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of the computer readable storage medium includes the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punch-cards or raised structures in a groove having instructions recorded thereon, and any suitable combination of the foregoing. A computer readable storage medium, as used herein, is not to be construed as being transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission media (e.g., light pulses passing through a fiber-optic cable), or electrical signals transmitted through a wire. 
     Computer readable program instructions described herein can be downloaded to respective computing/processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and/or a wireless network. The network may comprise copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers and/or edge servers. A network adapter card or network interface in each computing/processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium within the respective computing/processing device. 
     Computer readable program instructions for carrying out operations of the present disclosure may be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state-setting data, or either source code or object code written in any combination of one or more programming languages, including an object oriented programming language such as Smalltalk, C++ or the like, and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The computer readable program instructions may execute entirely on the user&#39;s computer, partly on the user&#39;s computer, as a stand-alone software package, partly on the user&#39;s computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user&#39;s computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGA), or programmable logic arrays (PLA) may execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present disclosure. 
     Aspects of the present disclosure are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the present disclosure. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer readable program instructions. 
     These computer readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer readable program instructions may also be stored in a computer readable storage medium that can direct a computer, a programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer readable storage medium having instructions stored therein comprises an article of manufacture including instructions which implement aspects of the function/act specified in the flowchart and/or block diagram block or blocks. 
     The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer implemented process, such that the instructions which execute on the computer, other programmable apparatus, or other device implement the functions/acts specified in the flowchart and/or block diagram block or blocks. 
     The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts or carry out combinations of special purpose hardware and computer instructions. 
     Embodiments of the present disclosure may be provided to end users through a cloud computing infrastructure. Cloud computing generally refers to the provision of scalable computing resources as a service over a network. More formally, cloud computing may be defined as a computing capability that provides an abstraction between the computing resource and its underlying technical architecture (e.g., servers, storage, networks), enabling convenient, on-demand network access to a shared pool of configurable computing resources that can be rapidly provisioned and released with minimal management effort or service provider interaction. Thus, cloud computing allows a user to access virtual computing resources (e.g., storage, data, applications, and even complete virtualized computing systems) in “the cloud,” without regard for the underlying physical systems (or locations of those systems) used to provide the computing resources. 
     Typically, cloud computing resources are provided to a user on a pay-per-use basis, where users are charged only for the computing resources actually used (e.g. an amount of storage space consumed by a user or a number of virtualized systems instantiated by the user). A user can access any of the resources that reside in the cloud at any time, and from anywhere across the Internet. In context of the present disclosure, a user may access applications (e.g., the development operation information system manager) or related data available in the cloud. For example, the development operation information system manager could execute on a computing system in the cloud and evaluate developer source code against globalization enablement requirements set by a globalization architect of an enterprise network. In such a case, the development operation information system manager could detect deficiencies in developer source code with respect to globalization enablement source code and correct the deficiencies identified in the source code. Further, the development operation information could store verification test result logs at a storage location in the cloud. Doing so allows a user to access this information from any computing system attached to a network connected to the cloud (e.g., the Internet). 
     While the foregoing is directed to embodiments of the present disclosure, other and further embodiments of the present disclosure may be devised without departing from the basic scope thereof, and the scope thereof is determined by the claims that follow.