|Publication number||US8010947 B2|
|Application number||US 11/752,473|
|Publication date||Aug 30, 2011|
|Filing date||May 23, 2007|
|Priority date||May 23, 2006|
|Also published as||US8438543, US20080235664, US20110276942|
|Publication number||11752473, 752473, US 8010947 B2, US 8010947B2, US-B2-8010947, US8010947 B2, US8010947B2|
|Inventors||Giancarlo Carbone, Fabio Cerri, Bernardo Pastorelli, Antonio Perrone|
|Original Assignee||International Business Machines Corporation|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (40), Non-Patent Citations (3), Referenced by (13), Classifications (5), Legal Events (4)|
|External Links: USPTO, USPTO Assignment, Espacenet|
The present invention relates to the information technology field. More specifically, the invention relates to the discovering of software components in a data processing system.
Thorough knowledge of data processing systems is of the utmost importance in a number of resource management applications. A typical example consists of the identification of software products that are installed on a system; typically, this information is used to meter the usage of the software products, such as by a license management application (for example, for charge-back accounting).
For this purpose, inventory tools are exploited to discover the required information. A commercial inventory tool available on the market is the “IBM Tivoli Common Inventory Technology or CIT” by IBM Corporation; in the example at issue, the inventory tool is part of a commercial license management application, such as the “IBM Tivoli License Compliance Manager or ITLCM” by IBM Corporation.
In this scenario, a problem arises when the software products include multiple software components cooperating among them. Generally, these software components may be installed independently; moreover, the same software components may belong to two or more different software products. A typical case is that of utilities that can be used in more complex applications; for example, the inventory tool itself may be exploited—in addition to the above-mentioned license management applications—in software distribution applications, in monitoring applications, and the like.
The inventory tools known in the art can only determine the software components that are installed on the system. However, it is quite difficult (if not impossible) to determine the software product owning each software component. Indeed, once a software component is installed on the system, it generally does not include any information about the corresponding software product (because of either a deliberate design choice or an intrinsic limitation of the software component).
Therefore, if the software component may be shared by multiple software products it is not possible to determine the one among them that actually includes the software component. This may even prevent the identification of software products that are installed on the system.
This problem is particular acute when different conditions of use apply to specific exploitation of the same software component. Indeed, the conditions of use of the software component typically depend on the software product that embeds it; for example, the usage of the software component is generally subjected to licensing fees increasing with the complexity of the environment wherein it is used (while it may be free of charge in specific contexts).
All of the above may impair the correct operation of the inventory tool (and more generally of any application based thereon). Particularly, in the software licensing scenario it is not possible to associate the correct charging rate to the usage of the software components. This involves the risk of having a wrong license management of the system, which may result in inaccurate charge-back.
In general, the present invention provides a method, system and computer product for discovering software components belonging to software products in a data processing system where at least one of the software components may belong to a plurality of software products. The invention associates each software product with the definition of at least one group of software components based on a relationship among the software components of the group. The invention detects the software components available in the system being included in each group. Next, the groups which are valid according to the inclusion of the software components of the corresponding definition are identified. Next, each available software component is assigned to at least one of the software products which has at least one associated valid group including the available software component.
The invention itself, as well as further features and the advantages thereof, will be best understood with reference to the following detailed description, given purely by way of a non-restrictive indication, to be read in conjunction with the accompanying drawings, in which:
With reference in particular to
The system 100 includes one or more independent organizations (only one shown in the figure), which are completely separate and distinct from each other. Within the organization, different divisions are defined. Each division is controlled by a runtime server 105, which collects information about the usage of assigned software products on a set of corresponding execution servers 110; for this purpose, the runtime server 105 and all the execution servers 110 of the division communicate through a network 115 (for example, a LAN). The different runtime servers 105 report to a single administration server 120, which implements a central control point of the usage information collected in the whole organization by the runtime servers 105; the runtime servers 105 and the administration server 120 are connected to a different network 125 (for example, a Virtual Private Network or VPN based on the Internet).
The software components 220 are used to identify the software products 210 that are available on each execution server, so as to assign each software component 220 to the correct software product 210. For this purpose, as described in detail in the following, in the solution according to an embodiment of the present invention the software components are aggregated into one or more groups 230. Each group 230 includes (exclusive or shared) software components 220, which must be linked by a corresponding relationship. The relationship represents some sort of interaction among the software components 220 of the group 230 (with the corresponding condition that is always fulfilled in a degenerated group 230 formed by a single software component 220); in other words, the presence of the software components 220 in a group 230 indicates that these software components 230 interact to each other, and then it is likely that they belong to the corresponding software product 210. This information is statically defined, and it is typically readily available when the software product 210 is built. Each group 230 must include one or more software components 220 that are required for its definition; preferably, some of the groups 230 may also include software components 220 that are only optional (i.e., they are not necessary for the definition of the groups 230 and may also be missing).
In order to identify the available software products 210, for each required software component 220 available on the execution server the corresponding groups 230 that may include it are determined. Each group 230 for which all the required software components 220 are available is considered valid. When an available software component 220 is included in a single valid group 230, the available software component 220 is assigned to this valid group 230. Each group 230 is then considered available on the execution server when all its required software components 220 are assigned thereto. Each software product 210 can now be identified (as available on the execution server) when one or more of its groups 230 are available.
In this way, for each available software component—or at least for some of them—it is possible to identify the correct software product owning it (even when the available software component might be owned by more software products). As a consequence, it is possible to determine the software products that are actually available.
This advantage is clearly perceived in the software licensing applications (especially when different conditions of use apply to specific exploitation of the same software component); indeed, the proposed solution allows associating the correct charging rate to the usage of the software component (for example, by increasing it with the complexity of the software products wherein it is included).
All of the above substantially improves the reliability of the process of discovering the software components/products that are available (and then of any application based on this discovering process). Particularly, in the software licensing scenario this prevents the risk of having a wrong license management of the system, which may result in inaccurate charge-back.
Different relationships may be used to define the groups 230. For example, in an embodiment of the invention the relationships consist of a co-location in a common logical environment (typically defined by an operating system image); in this case, the software components 220 are considered included in the corresponding group 230 when they are installed on the same operating system image. The proposed choice reflects the location properties of the software products 210 (which software components 220 must generally be available in the same environment).
Alternatively, the relationships consist of an intercommunication of the software components 220; in this case, the software components 220 are considered included in the corresponding group 230 when they communicate to each other (either locally by means of message pipes or remotely by means of network protocols). The proposed choice reflects the communication properties of the software products 210 (which software components 220 must generally exchange information).
In a different embodiment of the invention, the relationships consist of an invocation dependency of the software components 220; in this case, the software components 220 are considered included in the corresponding group 230 when they launch or are launched by the others. The proposed choice reflects the inter-process structure of the software products 210 (which software components 220 must generally be invoked along a hierarchical path).
At the end, another implementation defines the relationships according to an access to a predefined memory structure (such as a file or a database); in this case, the software components 220 are considered included in the corresponding group 230 when they use the same memory structure (for example, writing and reading it as producers/consumers). The proposed choice reflects the data sharing properties of the software products 210 (which software components 220 must generally process common data relevant to the specific application).
In the above-described algorithm, an available software component 220 might be included in two or more (eligible) valid groups 230; in this situation, it is not possible to assign the available software component 220 to a single group 230. In order to solve this ambiguity, a score SC is calculated for each associated software product 210 (eligible to have this ambiguous software component 220 assigned thereto); the score is indicative of the probability that the ambiguous software component 220 is actually owned by the respective software product 210.
For this purpose, a weight Wre is defined for the software components 220 that are required and exclusive, whereas another weight Wrs is defined for the software components 220 that are required but shared; likewise, a weight Woe is defined for the software components 220 that are optional and exclusive, whereas another weight Wos is defined for the software components 220 that are optional but shared. Denoting with Nre, Nrs, Noe and Nos the number of all the available software components 220 of the software product 210 included in its valid groups 230 that are required-exclusive, required-shared, optional-exclusive and optional-shared, respectively, the score SC is given by the following formula:
The software product 210 with the highest score SC is selected; the ambiguous software component 220 is then assigned to this selected software product 210, and then to the corresponding eligible group(s) 230.
As a result, all the available software components 220 are assigned to a single software product 210 (either deterministically or at least with an acceptable degree of confidence).
Preferably, the weights Wre, Wrs, Woe and Wos have decreasing values (for example, Wre=23=8, Wrs=22=4, Woe=21=2 and Wos=20=1). This choice reflects the fact that the availability of the software components 220 that are required-exclusive, required-shared, optional-exclusive and optional-shared has a decreasing relevance for indicating that the software product 210 is actually available on the execution server.
Moving now to
Let us assume now that the software components available on the execution server that are linked by the relationship defining the groups Ga1-Ge1 are C1, C2, C4, C7, C8 and C9. In this condition, all the groups Ga1-Ge1 may include some of the available software components C1-C9 (being shaded in the figure).
The valid groups having all the required software components (either exclusive or shared) available on the execution server are then determined; in this case, the only non-valid groups—crossed in the figure—are Ga2 and Gc2 (since the required software component C6 is missing in both of them). The process continues by verifying whether some available software component is included in a single valid group; in this case, the available software component is automatically assigned to the corresponding valid group (as indicated by underlying it in the figure). Of course, the condition is always satisfied by the exclusive software components (either required or optional), which can be included in a single group by definition. In the example at issue, the available software component C1 is assigned to the valid group Ga1 and the available software component C7 is assigned to the valid group Gc1; moreover, the same condition is also satisfied by the available software component C2, which is assigned to the valid group Gb1.
The other (ambiguous) software components C4, C8 and C9 are instead included in multiple (eligible) groups, i.e., the ambiguous software component C4 in the eligible groups Ga3, Gb2 and Gc1, the ambiguous software component C8 in the eligible groups Gc3 and Gd1, and the ambiguous software component C9 in the eligible groups Gc3 and Ge1. Therefore, for each (eligible) software product (PRODa-PRODe) including one or more of those eligible groups the corresponding scores are calculated (denoted by adding the same index to the term SC):
SC a=Nre·Wre+Nrs·Wrs+Noe·Woe+Nos·Wos=1 ·8+0·4+0·2+1·1=8+1=9,
SC c= Nre·Wre+Nrs·Wrs+Noe·Woe+Nos·Wos=0·8+2·4+1·2+1·1=8+2+1=11,
SC d= Nre·Wre+Nrs·Wrs+Noe·Woe+Nos·Wos=0·8+1·4+0·2+0·1=4 and
In this condition, the ambiguous software component C4 is assigned to the eligible group Gc1 (since the score SCc=11 is higher than the scores SCa=9 and SCb=8); this is indicated in the figure by underlying the software component C4 in the selected group Gc1, and at the same time crossing the available software component C4 in the other (non-selected) eligible groups Ga3 and Gb2. Likewise, the ambiguous software component C8 is assigned to the eligible group Gc3 (since the score SCc=11 is higher than the scores SCd=4), and the ambiguous software component C9 is again assigned to the eligible group Gc3 (since the score SCc=11 is higher than the scores SCe=4).
As a result, the groups Ga1, Gb1, Gc1 and Gc3 (underlined in the figure) are considered available on the execution server, since all the corresponding (exclusive or shared) required software products C1, C2, C4 and C8, respectively, are available. It is then possible to identify the software products PRODa, PRODb and PRODc (underlined in the figure) as available on the execution server, since at least one of the corresponding groups Ga1, Gb1 and Gc1-Gc3, respectively, are available.
With reference to
In detail, a licensing agent 405 (continually running in the background) detects the usage of software components/products installed on the execution server 110. The process is based on the content of a local copy of a software catalogue 415 that is downloaded from the associated runtime server, not shown in the figure (action “M1.Download”). The software catalogue 415 specifies all the known software products to be metered in the organization. More specifically, each software product is identified by a composition signature. The composition signature specifies the groups (in logical OR) indicating the availability of the software product on the execution server. Each group is defined by the relationship that must link the corresponding software components (i.e., co-location, inter-communication, invocation dependency or access to memory structure); each software component is also flagged as required or optional, and as exclusive or shared. Each software component is in turn identified by an installation signature, which indicates the installation of the software component on the execution server. The installation signature may consist of the indication of a file (generally defined by multiple attributes, such as its name, size and checksum) or of a configuration parameter; a more complex example is an extended signature, which consists of an expression based on multiple conditions in logical AND (such as of the above-mentioned type). In any case, each installation signature uniquely identifies a single software component as available on the execution server. In addition, each software component is also identified by a usage signature, which indicates the running of the software component on the execution server. The usage signature may consist of an expression based on the loading of one or more executable modules in logical OR (generally simply defined by their names). Another example is an instrumentation signature, which consists of a message returned by the software component itself (specifically adapted for this purpose). It should be noted that each usage signature may identify multiple software components (such as different versions or service levels thereof).
The software catalogue 415 is accessed by a discovery engine 420 (action “M2.Access”), such as the above-mentioned “CIT”. The discovery engine 420 interacts with a scanner 425. The module 425 scans a file system of the execution server 110 and then identifies all the software components that are available according to the corresponding installation signatures (action “M3.Components”). In this phase, the scanner 425 also determines the available software components that are linked by any required co-location relationship (action “M4.Co-locations”). The discovery engine 420 further interacts with a communication monitor 430, an invocation monitor 435 and an access monitor 440. The communication monitor 430 intercepts all the local and/or remote messages exchanged among the available software components, so as to determine the available software components that are linked by any communication relationship (action “M5.Communications”). The invocation monitor 435 instead intercepts the launching of any new process on the execution server 110; this information is used to determine the corresponding available software components that are linked by any invocation relationship (action “M6.Invocations”). At the end, the access monitor 440 intercepts all the read/write operations on any memory structure of interest, so as to determine the available software components that are linked by the corresponding access relationship (action “M7.Accesses”).
The discovery engine 420 saves an indication of the software components that are available in the execution server 110 and their relationships into a corresponding repository 445 (action “M8.Save”). An analyzer 450 determines all the groups (indicated in the software catalogue 415) that are valid, i.e., having all the required software components available as indicated in the relationship repository 445 (action “M9.Valid”). The analyzer 450 then assigns each available software component included in a single valid group to this group (action “M10.Assign”).
The analyzer 450 interfaces with an estimator 455. The estimator 455 extracts the weights assigned to the different types of software components, i.e., required-exclusive, required-shared, optional-exclusive and optional-shared, from a corresponding table 460 (Action “M11.Extract”). The estimator 455 then calculates the score of each eligible software product, which is associated with one or more of the eligible groups relating to the remaining ambiguous software components, i.e., included in multiple eligible groups (action “M12.Scores”). For each one of these ambiguous software components, in response thereto the analyzer 445 selects the valid group (or groups) corresponding to the software product with the highest score, to which the ambiguous software product is then assigned (action “M13.Select”).
The analyzer 450 now extracts a reduced catalogue 465 from the software catalogue 415 (action “M14.Reduce”). The reduced catalogue 465 lists the software components that are available on the execution server 110, each one identified by the corresponding usage signature only; for each available software component, the reduced catalogue 465 also specifies the corresponding software product owning it (as resulting from the above-described discovery process).
Periodically (for example, every 1-10 minutes), the licensing agent 405 retrieves a list of processes that are active on the execution server 110 (by means of a corresponding API of its operating system). For each process, the licensing agent 405 verifies whether the name of the corresponding executable module is included in the reduced catalogue 465; when the executable module matches an entry of the reduced catalogue 465, the corresponding software component (with its software product) is identified as running on the execution server 110 (action “M15.Identify”). The list of running software components so obtained is compared with the content of a runtime table, which provides a snapshot of the software components running on the execution server 110 at a previously iteration of the process; in this way, it is possible to detect the software components that have been started or stopped since then. Each detected event with a corresponding time-stamp is added to a usage log 470, with the runtime table that is updated accordingly (action “M16.Add”). With a different periodicity (for example, at the end of every day), the licensing agent 405 uploads the usage log 470 to the associated runtime server (action “M17.Upload”).
The runtime server receives the usage logs from every execution server in the division, and forwards it to the administration server; moreover, the runtime server downloads a main copy of the software catalogue and distributes it to the corresponding execution servers (for example, periodically or at any change thereof). The administration server in turn aggregates the received information into a usage report, which lists all the periods of usage of the software components/products on different numbers of execution servers (for example, during the last day); this information may be used to charge a prescribed licensing fee for any usage peak of the known software components/products (based on predefined rates varying according to the actual use of the software components in the different software products).
Naturally, in order to satisfy local and specific requirements, a person skilled in the art may apply to the solution described above many modifications and alterations. Particularly, although the present invention has been described with a certain degree of particularity with reference to preferred embodiment(s) thereof, it should be understood that various omissions, substitutions and changes in the form and details as well as other embodiments are possible; moreover, it is expressly intended that specific elements and/or method steps described in connection with any disclosed embodiment of the invention may be incorporated in any other embodiment as a general matter of design choice.
Particularly, similar considerations apply if the system has a different architecture or includes equivalent units. For example, the execution servers (down to a single one) may be associated with a single runtime server (which receives and processes the information at the same time); in any case, nothing prevents the application of the proposed solution to a stand-alone computer. Moreover, each computer may have another structure or may include similar elements (such as cache memories temporarily storing the programs or parts thereof to reduce the accesses to the mass memory during execution); in any case, it is possible to replace the computer with any code execution entity (such as a PDA, a mobile phone, and the like).
The proposed solution may also be used to discover whatever software products (such as electronic books or multimedia works); likewise, the software products may include any equivalent software components (such as monitors or databases). More generally, the proposed solution is suitable to be applied to any digitally encoded manufacture and parts thereof. In any case, the same algorithm may be used in alternative scenarios; for example, the devised solution also finds application to discover simple software products (including exclusive software components only) in addition to the above-mentioned complex software products (including shared software components).
It should be readily apparent that the exploitation of the present invention is not limited to any specific license management application; particularly, the available information may be simply used to meter the usage of software products (as identified by the availability of the corresponding software components), or more generally for whatever management purpose. In any case, the solution according to the present invention lends itself to be used in different environments (such as for monitoring applications).
Without departing from the principles of the invention, the available software components may be detected by means of different installation signatures (or by any other equivalent technique). It is also emphasized that the software catalogue does not necessarily consist of a single file; alternatively, it is possible to provide multiple files for the different types of signatures, or more generally any other similar structure.
It should be readily apparent that the relationships described above (with the corresponding methods for their detection) are not comprehensive. For example, it is possible to define any other relationship (such as requiring a common version of the software components), or to combine them into complex expressions; conversely, only some of the proposed relationships may be supported (down to a single one for all the groups).
Alternatively, it is also possible to identify the valid groups according to different criteria (for example, in response to the availability of a predetermined percentage of their software components).
Moreover, nothing prevents implementing alternative algorithms for assigning the available software components to the corresponding software products; for example, it is possible to associate each available software component to all the eligible software products (when the available software component may be used by more software products at the same time). Alternatively, the scores may be used only as a suggestion for a system administrator (who always takes the final decision); in any case, this feature is not strictly necessary and it may be omitted in a basic implementation of the invention (only assigning the software components to the corresponding software products deterministically, when it is possible).
A simplified implementation of the proposed solution (wherein the groups are defined only according to the required software components) is also within the scope of the invention.
Naturally, different weights may be used to calculate the scores of the software products; moreover, it is also possible to combine the weights in a different way (for example, according to a logarithmic scale), or even to base the corresponding formula on some types of software components only. In any case, the use of other algorithms to select the eligible groups for the assignment of any ambiguous software component is not excluded (for example, based on fuzzy logic techniques).
Similar considerations apply if the program (which may be used to implement each embodiment of the invention) is structured in a different way, or if additional modules or functions are provided; likewise, the memory structures may be of other types, or may be replaced with equivalent entities (not necessarily consisting of physical storage media). Moreover, the proposed solution lends itself to be implemented with an equivalent method (having similar or additional steps, even in a different order). In any case, the program may take any form suitable to be used by or in connection with any data processing system, such as external or resident software, firmware, or microcode (either in object code or in source code). Moreover, the program may be provided on any computer-usable medium; the medium can be any element suitable to contain, store, communicate, propagate, or transfer the program. Examples of such medium are fixed disks (where the program can be pre-loaded), removable disks, tapes, cards, wires, fibers, wireless connections, networks, broadcast waves, and the like; for example, the medium may be of the electronic, magnetic, optical, electromagnetic, infrared, or semiconductor type.
In any case, the solution according to the present invention lends itself to be carried out with a hardware structure (for example, integrated in a chip of semiconductor material), or with a combination of software and hardware.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US5590056||Sep 21, 1995||Dec 31, 1996||Isogon Corporation||Method and apparatus for computer program usage monitoring|
|US5845065||Nov 15, 1994||Dec 1, 1998||Wrq, Inc.||Network license compliance apparatus and method|
|US5970143||Jul 10, 1996||Oct 19, 1999||Walker Asset Management Lp||Remote-auditing of computer generated outcomes, authenticated billing and access control, and software metering system using cryptographic and other protocols|
|US6202924||Mar 26, 1999||Mar 20, 2001||Ncr Corporation||Method of authenticating an application program and a system therefor|
|US6209093||Jun 23, 1998||Mar 27, 2001||Microsoft Corporation||Technique for producing a privately authenticatable product copy indicia and for authenticating such an indicia|
|US6898555||Jul 14, 2003||May 24, 2005||Aladdin Knowledge Systems Ltd.||Method for indicating the integrity of use-information of a computer program|
|US6920567||Apr 7, 2000||Jul 19, 2005||Viatech Technologies Inc.||System and embedded license control mechanism for the creation and distribution of digital content files and enforcement of licensed use of the digital content files|
|US7089552||Aug 29, 2002||Aug 8, 2006||Sun Microsystems, Inc.||System and method for verifying installed software|
|US7174540 *||Jun 16, 2003||Feb 6, 2007||Microsoft Corporation||Component dependency matrices|
|US7236610||May 12, 2000||Jun 26, 2007||Fraunhofer Gesellschaft||Authenticating executable code and executions thereof|
|US7236958||Jan 5, 2001||Jun 26, 2007||Microsoft Corporation||Electronic software license with software product installer identifier|
|US7434202 *||Feb 24, 2004||Oct 7, 2008||Bea Systems, Inc.||System and method for software component dependency checking|
|US7529775||Aug 20, 2003||May 5, 2009||Microsoft Corporation||Method and system for collecting information about applications on a computer system|
|US7617224 *||Jan 30, 2006||Nov 10, 2009||International Business Machines Corporation||System and method for managing hierarchically related software components|
|US7617483 *||Dec 21, 2004||Nov 10, 2009||Sap Ag||Framework for managing components|
|US7627855 *||Oct 2, 2002||Dec 1, 2009||Japan Science And Technology Agency||Software component importance evaluation system|
|US7676792 *||Oct 21, 2005||Mar 9, 2010||Kabushiki Kaisha Toshiba||Software component library management system|
|US7860239||Jun 28, 2005||Dec 28, 2010||International Business Machines Corporation||Method and apparatus for metering usage of software products using multiple signatures|
|US20020022971||Aug 21, 2001||Feb 21, 2002||Masanori Tanaka||Software rental system, software rental method, and computer program for being executed on the software rental system|
|US20020083003||Sep 26, 2001||Jun 27, 2002||Halliday David C.||Method and apparatus for the accurate metering of software application usage and the reporting of such usage to a remote site on a public network|
|US20020107701||Jun 8, 2001||Aug 8, 2002||Batty Robert L.||Systems and methods for metering content on the internet|
|US20020194578 *||Mar 15, 2002||Dec 19, 2002||Kabushiki Kaisha Toshiba||Software component library management system|
|US20030120923||Dec 21, 2001||Jun 26, 2003||Avaya Technology Corp.||Secure data authentication apparatus|
|US20030135474||Jan 15, 2002||Jul 17, 2003||Edgar Circenis||Software pay-per-use pricing|
|US20030154168||Feb 25, 2000||Aug 14, 2003||Richard A Neifeld||Method for using software products that are offered via a network|
|US20040162989||Feb 19, 2003||Aug 19, 2004||Darko Kirovski||Enhancing software integrity through installation and verification|
|US20040168152 *||Feb 24, 2004||Aug 26, 2004||Bea Systems, Inc.||System and method for software component dependency checking|
|US20040243807||May 30, 2003||Dec 2, 2004||Microsoft Corporation||Runtime digital signatures|
|US20040255272 *||Jun 16, 2003||Dec 16, 2004||Microsoft Corporation||Component dependency matrices|
|US20040268313||Jun 25, 2004||Dec 30, 2004||Yannick Teglia||Statistical control of the integrity of a program|
|US20050091535||Jun 15, 2004||Apr 28, 2005||Microsoft Corporation||Application identity for software products|
|US20050120333 *||Oct 2, 2002||Jun 2, 2005||Katsuro Inoue||Software component importance evaluation system|
|US20050278791||Feb 17, 2005||Dec 15, 2005||Microsoft Corporation||Service protection|
|US20060026105||Oct 6, 2003||Feb 2, 2006||Canon Kabushiki Kaisha||Peripheral device, information processing method, and control program|
|US20060037001 *||Oct 21, 2005||Feb 16, 2006||Kabushiki Kaisha Toshiba||Software component library management system|
|US20060059366||Nov 3, 2005||Mar 16, 2006||Microsoft Corporation||Restricted software and hardware usage on a computer|
|US20060136935 *||Dec 21, 2004||Jun 22, 2006||Vigelius Christoph P||Framework for managing components|
|US20060155830 *||Nov 12, 2004||Jul 13, 2006||International Business Machines Corporation||Configuration mediator for a multi-component software solution environment|
|US20070192340 *||Jan 30, 2006||Aug 16, 2007||Moulckers Ingrid M||System and method for managing hierarchically related software components|
|WO1996018939A2||Dec 15, 1995||Jun 20, 1996||Graphisoft R & D Software Development Company Limited By Shares||Software usage metering system|
|1||"InterLok for Windows User Guide", PACE Anti-Piracy, Inc., Feb. 2001, http://www.paccap.com/docs/InterLok-for-windows.pdf, 132 pages.|
|2||"InterLok for Windows User Guide", PACE Anti-Piracy, Inc., Feb. 2001, http://www.paccap.com/docs/InterLok—for—windows.pdf, 132 pages.|
|3||U.S. Appl. No. 11/168,693, Image File Wrapper printed Apr. 6, 2011, 3 pages.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US8479159 *||Jun 15, 2007||Jul 2, 2013||International Business Machines Corporation||System and method for automatically determining relationships between software artifacts using multiple evidence sources|
|US8726236 *||Oct 26, 2009||May 13, 2014||International Business Machines Corporation||Determining context specific content|
|US8788497 *||Sep 15, 2008||Jul 22, 2014||Microsoft Corporation||Automated criterion-based grouping and presenting|
|US8984481 *||Apr 2, 2013||Mar 17, 2015||International Business Machines Corporation||System and method for automatically determining relationships between software artifacts using multiple evidence sources|
|US9015235 *||Jan 14, 2013||Apr 21, 2015||Antecea, Inc.||Server aggregated application streaming|
|US9026412||Dec 17, 2009||May 5, 2015||International Business Machines Corporation||Managing and maintaining scope in a service oriented architecture industry model repository|
|US9111004||Feb 1, 2011||Aug 18, 2015||International Business Machines Corporation||Temporal scope translation of meta-models using semantic web technologies|
|US9430591||Feb 5, 2015||Aug 30, 2016||International Business Machines Corporation||System and method for automatically determining relationships between software artifacts using multiple evidence sources|
|US20080098360 *||Jun 15, 2007||Apr 24, 2008||International Business Machines Corporation|
|US20100070497 *||Sep 15, 2008||Mar 18, 2010||Microsoft Corporation||Automated Criterion-Based Grouping and Presenting|
|US20110099536 *||Oct 26, 2009||Apr 28, 2011||International Business Machines Corporation||Determining Context Specific Content|
|US20130219358 *||Apr 2, 2013||Aug 22, 2013||International Business Machines Corporation|
|US20140032644 *||Jan 14, 2013||Jan 30, 2014||Antecea, Inc.||Server Aggregated Application Streaming|
|U.S. Classification||717/121, 717/120|
|May 23, 2007||AS||Assignment|
Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:CARBONE, GIANCARLO;CERRI, FABIO;PASTORELLI, BERNARDO;ANDOTHERS;REEL/FRAME:019333/0624
Effective date: 20070412
|Apr 10, 2015||REMI||Maintenance fee reminder mailed|
|Aug 30, 2015||LAPS||Lapse for failure to pay maintenance fees|
|Oct 20, 2015||FP||Expired due to failure to pay maintenance fee|
Effective date: 20150830