| Class / Patent application number | Description | Number of patent applications / Date published |
|---|
| 717163000 | Including library | 35 |
| 20080229299 | Adaptive class loading - An apparatus, system, and storage medium that, in an embodiment, determine the classes that are needed during a first invocation of an application and preload those classes during a subsequent invocation of the application. In various embodiments, the classes may be preloaded if they are within a specified package, if they were needed greater than a threshold number of times, if the class path did not change between the first invocation and the subsequent invocation, or if the jar files the contain the classes are in a class path. In this way, an embodiment of the invention may increase the performance of class preloading. | 09-18-2008 |
| 20080244550 | DYNAMIC DLL CYCLE RESOLUTION - Deterministically resolving cycles in a library tree is disclosed. Resolving cycles supports certain processes such as safe library initialization. Cycles in the library tree are identified; at least one soft link in each identified cycle is identified; and the at least one soft link in each identified cycle is broken. If a cycle has no soft links, notification is provided indicating that the cycle cannot be broken. Identifying at least one soft link in each identified cycle comprises, for each link in the cycle, determining the dependent and supporting libraries; and determining if one or more functions in the supporting library are required for initializing the dependent library. | 10-02-2008 |
| 20080244551 | PARALLEL DLL TREE INITIALIZATION - A parallel processing method and apparatus for initializing libraries is disclosed. Libraries for an application are identified, an initialization order for the libraries is determined, and the libraries are initialized in asynchronous stages. The initialization order is determined by forming a library tree of the libraries' references and determining a load order for the references according to the levels of the references in the library tree. The asynchronous stages comprise a loading stage that includes a load queue, a snapping stage that includes a snap queue, and an initializing stage that includes an initialize queue. | 10-02-2008 |
| 20080271007 | SYSTEM AND METHOD FOR MANAGED TUXEDO WRAPPER FOR .NET APPLICATIONS - A system supports managed wrapping of Tuxedo functions for .NET applications, comprising Wrapper Interfaces and Wrapper Utilities. The Wrapper Interfaces that wrap around one or more Tuxedo functions used by a .NET application are operable to encapsulate the one or more unmanaged Tuxedo libraries and provide connectivity between the one or more unmanaged Tuxedo libraries and the .NET application. The Wrapper Utilities are operable to build .NET applications using the Wrapper Interfaces, wherein the .NET applications are operable to invoke the one or more unmanaged Tuxedo libraries through Wrapper Interfaces to run under Common Language Runtime (CLR). | 10-30-2008 |
| 20080313625 | DISCO: A SIMPLIFIED DISTRIBUTED COMPUTING LIBRARY - Core commands and aggregations of such commands are provided to programmers to enable them to generate programs that can be parallel-processed without requiring the programmer to be aware of parallel-processing techniques. The core commands and aggregations abstract mechanisms that can be executed in parallel, enabling the programmer to focus on higher-level concepts. The core commands provided include commands for applying a function in parallel and distributing and joining data in parallel. The output of each core command can implement an interface that can enable underlying mechanisms to stitch together multiple core commands in a cohesive manner to perform more complex actions. | 12-18-2008 |
| 20090125895 | Re-Using Legacy Libraries in Software - A method of using a computer program that accesses legacy program code can include distinguishing between non-legacy program code of the computer program and legacy program code of the computer program, separating the computer program into at least a first logical unit including non-legacy program code and at least a second logical unit including legacy program code, and including interface code within the first logical unit. The interface code can be non-legacy program code that communicates with the second logical unit. The first logical unit and the second logical unit can be output. | 05-14-2009 |
| 20090199171 | Code Size Reduction by Outlining Specific Functions in a Library - A method of reducing the size of a set of computer code intended for use in a computing device, the set of code being intended for loading into memory automatically when the computing device is powered up, and comprising functions for performing computing tasks, the method comprising: specifying a particular use of the computing device; identifying those functions in the set of computer code that will be required in order to implement the said use of the computing device; and removing the identified functions from the set of code and placing them in a separate computer code library. | 08-06-2009 |
| 20090204954 | System and Method For Providing A Web-Based Operating System - A system and method for providing a web-based operating system is disclosed. A web-based operating system is downloaded from a server to a network-enabled device. The web-based operating system provides a platform from which to run web-based computer applications. Web-based computer applications are downloaded from the server onto the network-enabled device, and executed in conjunction with the web-based operating system. Those portions of the web-based operating system software and web-based computer application software are downloaded to the network-enabled device as needed. A component-based environment for the development and deployment of a web-based operating system and web-based computer applications is also provided. Components are deployed within library files as part of a component-based development model. The web-based operating system downloads those library files needed to execute the web-based computer applications. | 08-13-2009 |
| 20090265697 | Methods, Devices and Software Applications for Facilitating a Development of a Computer Program - A software development application determines whether routine name and version number parameters have been identified ( | 10-22-2009 |
| 20100122243 | System For Library Content Creation - A method for generating a library of materials that can be applied to geometry in a graphics scene when performing rendering operations. The method includes generating a class file that includes material parameters representing rendering characteristics of a material class and generating a library root file that includes a reference to the class file. The method further includes generating a rendering implementation file for translating values of the material parameters into a format recognized by a particular rendering engine and generating a user interface file that includes at least one user interface configured to allow a user to modify the values of the material parameters. The method also includes linking the class file to the library root file, and linking the rendering implementation file and the user interface file to the class file. Advantageously, the library can be organized and updated more effectively when compared to prior art techniques. | 05-13-2010 |
| 20100242031 | Systems and Methods for Dynamically Linking Application Software into a Running Operating System Kernel - The present invention provides systems and methods for dynamically linking modules into a running operating system kernel. Systems and methods described herein have the following advantages: (1) they permit an application programmer to write, compile, execute, and terminate application code that is to be loaded into a kernel as if the application code was an ordinary application program, (2) they allow a standard programming environment to be used to encapsulate application software in a familiar environment, and (3) they permit automatic cleanup of errors and freeing of program resources when the application terminates. | 09-23-2010 |
| 20110302565 | IMPLICIT WORKSPACE DEPENDENCIES - Implicit dependences allow a user to add multiple independent software components to a workspace, which results in the automatic establishment of ad-hoc dependencies. If one project depends on the products of another in the same workspace, a dependency manager detects this, causing a build engine to automatically build the projects in the correct sequence. Each project retains its individual identity, so a project can be included in more than one workspace or removed from a workspace without affecting the project. The workspace module maintains pointers to the projects and other files that the workspace includes. A target and the product it creates can be related to another target. If both targets are in the same workspace, the dependency manager discovers the dependency and the build engine builds the products in the required order. Such a relationship is referred to as an implicit dependency. | 12-08-2011 |
| 20110321022 | Code generation through metadata programming for mobile devices and web platforms to ease access to web services - A system and method for making a web service available to remote clients. In one illustrative embodiment, the web services are provided by a server. The server can use a metadata program to generate client side libraries that facilitate the development and maintenance of client side applications. A metadata binder on the server can be used to interface with the client side libraries. In operation, web services can be provided to mobile clients by generating Web Services Description Language function definitions. From those Web Services Description Language function definitions, Java objects can be created. Libraries can be generated from the objects for a plurality of platforms. The server can then communicate with the mobile clients operating on the plurality of platforms through the generated libraries. | 12-29-2011 |
| 20120117553 | PROGRAMMATIC DISPATCH TO FUNCTIONS WITH MATCHING LINKAGE - An enhanced function-descriptor-based dispatch in a multi-linkage environment receives user code containing a function compiled in a supplementary linkage convention of a caller to form an invoked function and determines whether the supplementary linkage convention of the caller for the invoked function matches a supplementary linkage implementation provided by a library. Responsive to a determination that the supplementary linkage convention of the caller for the invoked function matches a supplementary linkage implementation provided by the library, an embodiment selects the supplementary linkage implementation provided by the library and dispatches the invoked function in the selected supplementary linkage implementation provided by the library. | 05-10-2012 |
| 20120240106 | OPTIONAL RETARGETING OF LIBRARY REFERENCES - Shared libraries and references within the shared libraries can be retargeted in accordance with optional transformation rules. The optional transformation rules can be applied differently for different binding contexts. For user-code scenarios, optional retargeting binding rules can be applied automatically by default without requiring any human intervention. Optional targeting that triggers automatic binding behaviors can be disabled based on heuristics. Alternatively, the user can specify in the code or in a configuration file if the source or target is to be loaded. Transformation rules can be disabled based on heuristics. A manual option permits a user to choose at runtime whether the transformation is to be applied, or not applied, in a late-bound fashion. | 09-20-2012 |
| 20120266148 | SUPPORTING MULTIPLE HARDWARE COMPONENTS IN UEFI - Approaches for customizing a unified extensible firmware interface (UEFI) compatible firmware component to support multiple hardware components. The UEFI compatible firmware component may be implemented by linking one or more executive drivers created in an executive module of the firmware component. The executive drivers, instead of platform drivers, are executed by UEFI dispatchers. The platform module, rather than being a collection of drivers, functions as a platform library that links to the executive drivers. One or more programs for providing one or more library functions to the one or more executive drivers are also linked into the firmware component. Call outs to board library functions provided by a board module are implemented in the executive drivers, instead of drivers of the platform module. The board library functions replace the one or more library functions provided to the executive drivers and reflect a change in a customer reference board (CRB). | 10-18-2012 |
| 20130212569 | AIRCRAFT SOFTWARE PART LIBRARY - A computer implemented method, apparatus, and computer program product for managing aircraft software parts. An aircraft software part is received at a library. The received part is stored in the library with other aircraft software parts. A user interface is provided to manipulate the aircraft software parts. Responsive to receiving a user input from the user interface to uplink a selected aircraft software part to a target aircraft data processing system, a command is created to send the selected part to an aircraft in which the target aircraft data processing system is located. The uplink command is stored in a queue in the storage in the library. The uplink command is distributed to a proxy server application in response to a request for commands. Responsive to receiving a request from the proxy server application processing the stored uplink command, the selected part is sent to the proxy server application. | 08-15-2013 |
| 20130263103 | METHOD AND APPARATUS FOR CREATING A PLATFORM AGNOSTIC APPLICATION FILE - A method and apparatus for creating an application file comprising accessing at least one library, stubbing the at least one library to create a stub library containing symbols exported from the at least one library, and packing the stub library into the application file. Other embodiments include method and apparatus for packaging an application file comprising accessing the application file, unpacking the application file to expose at least one stub library, accessing the at least one stub library and packaging the application file with another application using symbols contained in the stub library for delivery to an end user computer. | 10-03-2013 |
| 20130275955 | CODE PROFILING OF EXECUTABLE LIBRARY FOR PIPELINE PARALLELIZATION - A system and associated method for creating a library method stub in source code form corresponding to an original library call in machine-executable form. Sequential code subject to pipeline-parallelization includes the original library call of which source code is not available for profiling. The original library call is annotated for a library method signature to specify formal arguments and parameters accessible to the formal arguments. Memory operations of the original library call are summarized with on one or more idiom sentences, which are mapped to a respective code stub that simulates the original library call. The library method stub is created for profiling of the original library call in source code level such that the sequential code is parallelized via the created library method stub. | 10-17-2013 |
| 20130326492 | APPARATUS AND METHOD FOR MANAGING ENTITLEMENTS TO PROGRAM CODE - A method, apparatus and machine readable medium are described for managing entitlements on a computing device. For example, one embodiment of a method comprises: loading a first application into a system memory of a computing device; for each library value/symbol pair referenced by the first application, determining whether the first application has a correct entitlement to be linked with the library value/symbol pair; wherein if the application does not have the correct entitlement associated with the library value/symbol pair, then denying linking to the library value/symbol pair and/or linking the application to an alternate library value/symbol pair which does not have the entitlement associated therewith; and if the application has the correct entitlement associated with the library value/symbol pair, then linking the application to the library value/symbol pair with the entitlement in the system memory. | 12-05-2013 |
| 20140059526 | Systems and Methods for Providing Class Loading for Java Applications - A mechanism for providing class loading for a JAVA application is disclosed. A method of the invention includes retrieving, by a processing device, a JAVA class file. The method also includes identifying, by the processing device, a class dependency for the JAVA class file. The method also includes determining, by the processing device, a probability that the JAVA class file is to be loaded into a cache based on the identified class dependency. The method further includes loading, by the processing device, the JAVA class file into the cache based on the probability determined for the JAVA class file. | 02-27-2014 |
| 20140068583 | GENERATING NATIVE CODE FROM INTERMEDIATE LANGUAGE CODE FOR AN APPLICATION - Disclosed herein are representative embodiments of tools and techniques for installing, executing, and/or updating managed applications through generation of native code from code in an intermediate language. According to one exemplary technique, a computing device receives machine dependent intermediate language code (MDIL code) generated by an online provider for an application. Additionally, the computing device installs the application on the computing device by generating a native image for the application, which includes binding a portion of the MDIL code with one or more libraries on the computing device. Also, the native image is stored on the computing device for use in loading the application for execution. | 03-06-2014 |
| 20140137090 | SYSTEM AND METHOD OF CROSS-PLATFORM SOFTWARE DEVELOPMENT AND COMPILATION - Methods of development and compilation of cross-platform software are provided. Through the use of platform-specific libraries, software can be written using only platform-independent instructions and then compiled for one or more different platform targets. In the compilation process, a compiler can obtain a target platform. Then, the compiler can select a platform-specific library associated with that target platform. A platform-independent instruction can then be obtained by parsing source code, for example. The compiler can then link the platform-independent instruction with a platform-specific instruction of the selected platform-specific library. This can allow cross-platform software to be written using only platform-independent instructions, and platform-specific instructions can be linked automatically when compiling the software for a specific target platform. | 05-15-2014 |
| 20140189668 | PROCESSING PROPOSED PROGRAM CODE LIBRARIES IN A NETWORKED COMPUTING ENVIRONMENT - An integrated development environment (IDE)-based approach for processing/analyzing proposed program code libraries as a replacement for existing program code libraries in a networked computing environment is provided. A set of annotations associated with a set of program code files and a proposed (e.g., new, modified, etc.) program code library are received in an integrated development environment (IDE). It may then be determined whether the proposed program code library is an excluded program code library based on the set of annotations. It may also be determined whether the proposed program code library meets one or more thresholds for replacing an existing program code library. If the proposed program code library is not excluded and meets the threshold(s), the proposed program code library may then be provided to a computer device hosting the IDE (e.g., for implementation). | 07-03-2014 |
| 20140196019 | Method and Apparatus for Substituting Compiler Built-in Helper Functions with Machine Instructions - An executable program compiled according to a source instruction set architecture (source ISA) is loaded for execution by a target instruction set architecture (target ISA)-based hardware execution unit, wherein the source and target ISA's are different. The loading includes mapping a compiler built-in helper function in the executable program to a target ISA machine instruction. The loaded program is then executed. As part of the execution, the helper function is replaced with the target ISA machine instruction to which the helper function was mapped, and the target ISA machine instruction is executed rather than the helper function. | 07-10-2014 |
| 20140337824 | OUT-OF-BAND FRAMEWORK LIBRARIES WITHIN APPLICATIONS - An enhanced binder provides flexibility and certainty when selecting a version of a software library to load, and an enhanced loader prevents a library version vulnerable to a security flaw from being loaded. The binder can perform unification, implicit override, and/or redirection. Implicit override searches assembly-specific locations for an implicit_version, and override the previously chosen unification or other version with the implicit_version when the implicit_version is greater. The implicit_version gets updated with the individual assembly, whereas the unification_version gets updated with the framework. Redirection may override the implicit_version. Unlike redirection, an implicit_version does not recite an explicit range and is found outside application configuration files. The implicit_version is specified implicitly by the assembly without an XML declaration. Vulnerable libraries are not loaded, based on out-of-band metadata placed in response to a list of known out-of-band assemblies, an out-of-band-servicing attribute, or a custom servicing library. | 11-13-2014 |
| 20150067663 | CODE PROFILING OF EXECUTABLE LIBRARY FOR PIPELINE PARALLELIZATION - A method and system for creating a library method stub in source code form corresponding to an original library call in machine-executable form. The library method stub is created in a predefined programming language by use of a library method signature associated with the original library call, at least one idiom sentence, and a call invoking the original library call. Creating the library method stub includes composing source code of the library method stub by matching the at least one idiom sentence with idiom-stub mappings predefined for each basic idiom of at least one basic idiom. The original library call appears in sequential code. The library method signature specifies formal arguments of the original library call. The at least one idiom sentence summarizes memory operations performed by the original library call on the formal arguments. The created library method stub is stored in a database. | 03-05-2015 |
| 20150347109 | METHOD AND SYSTEM FOR FACILITATING REPLACEMENT OF SYSTEM CALLS - An example method includes modifying, prior to run time, an executable file of an application to cause an operating system loader to load additional code using a dynamically-linked library. Modifying the executable file includes determining whether the executable file includes sufficient unused space to accommodate a load command, and adding the load command to the executable file when the executable file includes sufficient unused space by: shifting, in the executable file, an existing load command that does not contain dependency information to make space for the load command; or identifying unused space outside of a data portion of the executable file that can be removed to accommodate the load command. The additional code, when executed by a processor, causes the processor to change a pointer in a table that indicates an address of an imported function implementing a system call so the pointer indicates an address of a customized function. | 12-03-2015 |
| 20160070542 | FACILITATING USE OF TECHNIQUES IMPLEMENTED BY EXTERNAL LIBRARY FUNCTIONS IN PROCESS DEFINITIONS OF ANALYTICAL APPLICATIONS - An aspect of the present disclosure provides a server system which facilitates use of techniques implemented by external library functions in the process definitions of analytical applications. In an embodiment, a definitions block enables users to develop process definitions as basis for corresponding user applications, with each process definition incorporating a corresponding set of techniques. The definitions block requires metadata corresponding to each technique to be present in registration data prior to permitting incorporation of the technique in process definitions. Accordingly an importation block is provided which facilitates a user to register an external technique implemented by a function of an external library to cause meta data corresponding to the external technique to be added to said registration data. As a result, the external technique can thereafter be used in development of new process definitions. | 03-10-2016 |
| 717164000 | Shared | 6 |
| 20090158264 | CONFIGURING A SHARED LIBRARY TO ACCOMMODATE RELOCATABLE DATA IN A PERVASIVE DEVICE - A method, system, architecture and apparatus for generating a shared library for a pervasive device target platform which can accommodate relocatable data. A tool chain in furtherance of this purpose can be arranged in accordance with the present invention to include a compiler programmed to compile source code into a compiled object and a linker programmed to link the compiled object into a linked object using a relocatable data segment. In this regard, in a preferred aspect of the invention a linker configuration file can be included for use in the linker which specifies the use of the relocatable data segment in lieu of a position independent data segment. The tool chain further can be arranged to include a relocation data extraction tool programmed to extract relocation data from the linked object and to dispose the relocation data in a relocation data file configured for disposition in a pervasive device. | 06-18-2009 |
| 20090187898 | METHOD FOR SECURELY UPDATING AN AUTORUN PROGRAM AND PORTABLE ELECTRONIC ENTITY EXECUTING IT - The method for updating an autorun program of a portable electronic entity includes:
| 07-23-2009 |
| 20120124566 | SHARED RESOURCE DEPENDENCIES - Described herein are methods for sharing resource dependencies between applications stored on a system. For example, in at least certain embodiments, a computer-implemented method for sharing resource dependencies includes installing or initiating installation of multiple application bundles having one or more applications and respective resources on the system. Next, an installer determines identifiers (e.g., hash signatures) for first and second resources and determines whether the resources are identical if an identifier for the first resource matches an identifier for the second resource. Then, a link is created from the second application bundle to the first resource of the first application bundle if the first resource is identical to the second resource. The second resource may be removed from the system if it has been installed. Alternatively, installation of the second resource is terminated if it has not been installed on the system. | 05-17-2012 |
| 20140282457 | Systems And Methods For Embedded Shared Libraries In An Executable Image - Systems and methods are provided for deploying new software application features as a dynamically-loadable executable package including one or more dynamically-linked shared dependent libraries. The dynamically-loadable executable package may be capable of being loaded into volatile memory and executed in an information handling system environment with or without the dependent shared libraries, and without duplicating the presence or use of redundant shared libraries that may be already present on the existing software stack. | 09-18-2014 |
| 20160117181 | LINKING A FUNCTION WITH DUAL ENTRY POINTS - A method for a static linker to resolve a function call can include identifying, during link time, a first function call of a calling function to a callee function, determining whether the callee function is a local function, determining whether the callee function has a plurality of entry points, and whether an entry point of the plurality of entry points is a local entry point. The method can include resolving, during link time, the first function call to enter the local entry point, which can include replacing a symbol for the function in the first function call with an address of the local entry point during link time. If the callee function cannot be determined to be a local function, the method can include generating stub code and directing the first function call to enter the stub code during link time. | 04-28-2016 |
| 20160154657 | Extensible Firmware Abstraction | 06-02-2016 |
