Abstract:
A software management database contains data structures supporting computer software provisioning for a range of CTO/BTO variations, language variations, region variations, and operating system variations.

Description:
RELATED APPLICATION 
     This application claims priority from U.S. provisional application 60/722,130, filed Sep. 29, 2005, incorporated herein by reference. 
    
    
     I. FIELD OF THE INVENTION 
     The present invention relates generally to systems and methods for software integration and factory deployment of the software. 
     II. BACKGROUND OF THE INVENTION 
     Producing consumer electronics and in particular computers that might incorporate, in addition to operating systems with various configurations and suites of applications, several subsystems, each in turn with their own software drivers, can be complicated. Not only must a bill of materials (BOM) be defined, managed, and conformed to, but product defects and corrective actions must also be managed in way that ensures corrective action can be known and taken across the globe. 
     Because of the complexity inherent in the above considerations, it can happen that more than a single management system might develop over time, complicating efforts to integrate knowledge and data. As recognized herein, it is desirable to have a management system that can integrate the knowledge and input of designers, engineers, software integrators, etc. in ways that reduce engineering lead times and provide ease of tracking defects and cures to the defects in a single, globally shared system within an enterprise, while providing an easy way to manage regional differentiation of software offerings, sharing information between business groups within the enterprise, and eliminating duplicative data maintenance. 
     For example, many computers are sold on a configure to order/build to order (CTO/BTO) basis. Each software part can have a multidimensional relationship with each stock keeping unit (SKU) that represents a product when region, language, various operating system versions, and platforms are factored in. Thus, each software part can potentially have dozens of version releases to accommodate all of these variables. As but one example of the complexity of providing CTO/BTO computers, one version of a “click to DVD” software may be used only on French Windows MCE SR series SKUs that are sold only in Quebec, but another version may be designed to work on any model using Windows XP Home Edition Spanish Version regardless of region. 
     As another example of complexity, consider that there are currently about ten Sony VAIO platforms worldwide, and each platform may contain multiple VAIO models with variations on CPU, RAM, HDD capacity, wireless (WLAN, WWAN, and Bluetooth), graphics chipset, etc. Several major regions that include an even greater number of languages in many different countries, along with plural operating system variations, may require support. Still further, each model of VAIO for each region/language/country/OS variation contains well over one hundred pieces of software, each of which may be a unique version for only that model, or may be used for multiple models of VAIO, giving an idea of the exponential scope of the relationship between software and computer models the database must be designed to support. In summary, the relationships between software parts and the platforms they are used on have become extremely complex, and with this critical recognition in mind, the invention herein is provided. 
     In addition, the present invention critically recognizes that the quality of the final product is important. As understood herein, each piece of software may contain defects, or when combined in an image with other software may cause defects to be generated. 
     SUMMARY OF THE INVENTION 
     As set forth further below, processes and tools are provided herein for quickly assessing the quality of a project by relating the defects to part releases, which are in turn related to projects. For example, if a major flaw is found in a particular release version of a part, this defect is related to the appropriate part release or releases so that the defect is instantly related to all the projects that use the particular part release. Given the complexity of the software BOMs, without the present invention this task would be difficult and time consuming to do manually. 
     Thus, preferred implementations of the present invention correlate the relationships between software parts, the platforms they are used on, and the quality of those parts. 
     A method is disclosed for managing computer production in an enterprise. The method includes receiving a block of software offerings, with each block being associated with at least one product series. A product series component structure is received that defines parts for a respective product series. Parts that are required for a product series are added to the block associated with the series, with parts being assigned to each software class and related software specification pair in a block based on the part or parts required for the pair to thereby define a design structure. The method includes establishing a software bill of materials (BOM) based on the design structure using a template and/or a snapshot. 
     In non-limiting implementations the method includes defining software offerings. A software offering includes at least one software class and at least one associated software specification. Software offerings are associated with respective product series to establish a configuration, with configurations cumulatively defining a configuration range that contains product offerings of the enterprise for all regions in which the enterprise does business. The method may include grouping classes into blocks. A block is associated with at least one product series. 
     The non-limiting method may also include defining which classes are dependent on each other, and defining which blocks are base blocks. Defects can be associated with related classes and corrective actions associated with respective defects. 
     If desired, the method can includes associating a respective installation file with each software offering. Each installation file may include a data file format version number, a version number of an installation data snapshot, an installation order for modules, data required for confirming successful installation, cyclic redundancy check (CRC) data for each binary file, path information for locating files in a file store, partition size information for recovery and customer partitions. Also, installation and recovery tools may use a list of software releases directly instead of microcode, which is used only for customer recovery, with microcode bit mappings being constrained to respective recovery media sets. 
     In another aspect, a software management database on a computer readable medium can contain data structures supporting computer software provisioning for a range of CTO/BTO variations, language variations, region variations, and operating system variations. 
     Non-limiting data structures may include bill of materials (BOM) entities containing information related to parent BOMs and child BOMs, if any. Each BOM entity can also include an engineering part ID, a software release ID, a major version ID, a group ID, a component ID, a planning parts ID, and a software series ID. A plan parts entity can also be provided that includes launch dates for software base releases, import dates for software bases indicating when the bases were imported into computers, and identifications for software bases. 
     Other non-limiting entities in the database may include component entities including launch dates for software base releases, import dates for software bases, identifications for software bases. Software release entities containing a base ID, a name, a file path, a launch date can also be provided, as can be software release status entities that include data representing status and name of a software release. Additional database entities may include: a group entity containing data representing a name and launch of a type, a series entity containing a software series ID, base ID, name, an indication of being active, a launch date, an import date, an engineering parts entity containing an engineering part ID, a base ID, a type ID, a name, a launch date, and indication of dependent parts, an engineering parts major revision entity containing information related to default use, an engineering part software release entity containing information on a related engineering part entity, a related engineering parts major revision entity, a related language code entity, and a language entity containing information related to a language name and a language code. 
     In another aspect, a computer-implemented system for creating bills of materials (BOMs) includes logic that can be executed by a computer and stored on a computer readable medium. The logic facilitates creation of BOMs using templates and/or snapshots. BOMs can be automatically generated based on part attributes and groups of parts, major versions, and releases. The logic can automatically check BOMs to reduce errors. 
     In still another aspect, a computer system executing logic stored on a computer readable medium enters, into a first database, first software data. The first software data includes operating systems and configure to order/build to order (CTO/BTO) options. The system transfers at least some of the first software data in the first database to a comprehensive global database, referred to herein colloquially as “ePic.” Second software data such as operating system updates, device drivers, and utilities is automatically adding to a bill of materials (BOM) through the comprehensive global database. Also, software along with metadata that describes the software can be checked into the comprehensive global database by users, and the BOM for a specific series/language/region can be frozen/locked and the process to create factory deliverables including software image, software modules, and data can then begin. 
     The database tracks defects and relates them to parts, stores test cases which are related to parts which in turn allows test strategies to be auto-generated. 
     The details of the present invention, both as to its structure and operation, can best be understood in reference to the accompanying drawings, in which like reference numerals refer to like parts, and in which: 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIGS. 1-3  are diagrams of non-limiting software management phases; 
         FIG. 4  is a flow diagram of non-limiting overall software development, integration, and factory deployment processes; 
         FIG. 5  is a flow diagram of a non-limiting software planning process; 
         FIG. 6  is a flow diagram of a non-limiting bill of materials (BOM) creation process; 
         FIG. 7  is a flow diagram of a non-limiting software development process; 
         FIG. 8  is a flow diagram of a non-limiting software integration process; 
         FIG. 9  is a flow diagram of a non-limiting factory deployment process; 
         FIG. 10  is a flow diagram of aspects of a non-limiting factory deployment process; 
         FIG. 11  is a flow diagram of a non-limiting software installation process; 
         FIGS. 12-17  are non-limiting screen shots used for defect management and test case management purposes; 
         FIG. 18  is a diagram showing software inputs to the ePic database interface; 
         FIG. 18A  is a flow chart of logic of downloading an image to a test system; 
         FIG. 19  is a flow chart showing how BOM snapshots are generated, automatically at least in part, and entered into ePic; 
         FIGS. 20 and 21  are consolidated diagrams showing the interaction between various entities in a non-limiting implementation; 
         FIG. 22  is a diagram showing various data entities in the ePic database and some of their attributes; 
         FIG. 23  is a map showing a non-limiting deployment regime; 
         FIG. 23A  is a flow chart showing software integration logic; 
         FIG. 24  is a flow diagram showing a non-limiting factory deployment process; and 
         FIGS. 25-27  are further non-limiting defect-related screen shots. 
         FIGS. 28 and 29  are tables illustrating bill of material (BOM) information and associations, respectively. 
     
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
     In the present non-limiting implementation, only part of the software data is contained in a data store referred to below as “DB Hero”. Specifically, software data that is visible to customers (e.g., operating systems, configure to order/build to order (CTO/BTO) options, software highlighted on web sites, etc.) is entered into DB Hero. As set forth in the specification below, periodically, some of the data from DB Hero is pushed to a comprehensive global database referred to herein as ePic, including both stock keeping unit (SKU) data and software data. 
     Software data that is not as visible to customers (such as operating system updates, device drivers, utilities, etc.) are added to the bill of materials (BOM) through the comprehensive global database. Software is checked into the comprehensive global database by developers, vendors or engineers, along with metadata that describes the software for process tools. The BOM for a specific series/language/region is frozen/locked and the process to create the factory deliverables (software image, software modules, and data) can then be started. As set forth in the detailed specification below, various process tools and manual process can be used to create the factory deliverables, all of which use data stored in the comprehensive global database. 
     Additionally, the factory deliverables are tested and validated to meet quality standards. The factory deliverables, and the metadata that describes them, are then delivered to the factory to be used in mass production. 
     To better understand terms used herein, the range of potential software offerings for a given sales cycle is defined as a set of classes and specifications. The class structure captures how the various software items will be offered to the customer, and is a specific type of software. Specifications, on the other hand, are individual software items that are associated with classes. Thus, a specification is an option that the customer may choose within a class, and a class may have more than one specification while a specification is assigned to only one class. Software offerings (classes and specifications) are associated with individual series, with the resulting structure being called the “configuration range.” The configuration range for a SKU is a list of all the Classes (and specifications) that are offered for that SKU. 
     By way of non-limiting example only, a “class” might be “pre-installed office software”, and specifications within that class from which the customer can select might be “MS Office professional”, “MS Office Small Business”, “MS Office Basic”, and “MS Works.” 
     With the detailed description below it will be appreciated that the database herein supports software variations in CTO/BTO, language, region, and OS. In addition, this database, and the tools that use it, allow for the creation of CTO systems, based on individual customer orders, in the mass production process with every piece of software preinstalled and ready to use, allowing for a virtually infinite number software offerings to customers as opposed to a few pre-defined options. 
     Also, unnecessary duplicate data entry is eliminated, hardware components are automatically mapped to software releases, and developers can specify language and geographic region supported for each software release at the time of software check-in, with the correct release being assigned to each BOM automatically. Further, BOMs are created using templates and snapshots for efficiency. Moreover, BOMs are automatically generated based on part attributes to reduce effort, and groups of parts, major versions, and releases can be defined and reused. Automatic checking of the BOMs is provided to reduce errors. In addition, installation and recovery tools use a list of software releases directly instead of microcode, which is used only for customer recovery, with microcode bit mappings being constrained to each recovery media set that is defined. This solves the problem of limited microcode bits and makes the changing of a recovery key easier. 
     Below are details of one non-limiting implementation of present principles.  FIG. 1  illustrates that the present methods may be undertaken by a computer system  10  including one or more enterprise computers  12 , each potentially having its own monitor  14  which can display the screen shots described below. The enterprise computers  12  can be used by developers and software engineers to execute the invention. Thus, the logic and the databases herein (including the so-called “DBHero” database  16  and global database  18 , referred to herein as “ePic”) may be distributed over plural computers if desired, and some of the method steps may be undertaken by human users of the enterprise computers  12  while other method steps can be undertaken automatically by logic resident on computer readable media in computers. The computer readable media can include but is not limited to RAM, ROM, floppy disks, hard disk drives, optical disk drives, solid state memory devices, etc. 
     Referring briefly to  FIG. 19  out of turn, logic for creating BOMs is shown. Beginning at start state  20 , a software developer or integrator selects a software series, discussed above, from a list of series. The series can include data on software that an end user ordinarily “sees”, e.g., operating systems and configure to order/build to order (CTO/BTO) software options. 
     A human language and/or geographic region is selected at state  24  and then based on the selected language and region, at state  26  a processor in one or more of the enterprise computers  12  shown in  FIG. 1  can retrieve a list of component parts, including images and modules. These component parts typically include software the end user ordinarily does not “see” such as operating system updates, device drivers, and utilities. 
     The software integrator then selects the image or module to be built at state  28 , and at state  30  a BOM snapshot from a list is selected for the part selected at state  28 . In response, a processor in one or more of the enterprise computers  12  shown in  FIG. 1  then downloads, at state  32 , BOM items from a file store that may be resident in the global database  18  shown in  FIG. 1  to create an image to be loaded onto a computer to be vended. The image is checked in to the global database  18  at state  34  and uploaded to the file store, from whence it may be downloaded in the factory and loaded onto a computer to be vended. The process ends at state  36 . 
     A detailed description of a non-limiting implementation of the invention follows below. 

 
     While the particular SYSTEM AND METHOD FOR SOFTWARE INTEGRATION AND FACTORY DEPLOYMENT is herein shown and described in detail, it is to be understood that the subject matter which is encompassed by the present invention is limited only by the claims.