Entries |
Document | Title | Date |
20080229292 | Validator-Driven Architecture of an XML Parsing and Validating Solution - A method for parsing a document in an Extensible Markup Language (XML) format includes identifying data via the XML format, defining a tag set including a plurality of tags, defining a tokenizer that produces one token at a time, parsing the XML document via a parser, validating the XML document via a validation engine, the validation engine driving the tokenizer, the validating being an integral part of the parsing, and permitting the validation engine to be written in a recursive-descent code-driven manner. | 09-18-2008 |
20080235673 | Method and System for Measuring Database Programming Productivity - A method for measuring database programming productivity is disclosed. The method quantifies the database programming effort, which can then be used to calculate the software productivity for database development. | 09-25-2008 |
20080235674 | COMPILER METHOD OF EXPLOITING DATA VALUE LOCALITY FOR COMPUTATION REUSE - A compiler method for exploiting data value locality for computation reuse. When a code region having single entry and exit points and in which a potential computation reuse opportunity exists is identified during runtime, a helper thread is created separate from the master thread. One of the helper thread and master thread performs a computation specified in the code region, and the other of the helper thread and master thread looks up a value of the computation previously executed and stored in a lookup table. If the value of the computation previously executed is located in the lookup table, the other thread retrieves the value from the table, and ignores the computation performed by the thread. If the value of the computation is not located, the other thread obtains a result of the computation performed by the thread and stores the result in the lookup table for future computation reuse. | 09-25-2008 |
20080256523 | Computerized Data Warehousing - A system and method for transforming data from a first format to a second format. A pre-existing set of software instructions may be used to transform the data from the first format to the second format. A user may document a set of format parameters for the first format of data, which can be used to determine which portion of the pre-existing software instructions are used to transform the data from the first format to the second format. | 10-16-2008 |
20080271000 | Predicting Conflicts in a Pervasive System - A method of predicting conflicts in a system is described which uses a process calculus to describe programs and actions within the system. The source code for programs is transformed into an expression in the process calculus and then the reduction rules for the process calculus can be applied to the expressions for the various programs and actions. Analysis of the resultant reduced expression(s) enables potential conflicts to be identified. | 10-30-2008 |
20080307399 | GENE EXPRESSION PROGRAMMING BASED ON HIDDEN MARKOV MODELS - Computer programs ( | 12-11-2008 |
20090019430 | METHODS AND ARRANGEMENTS FOR UNIFIED PROGRAM ANALYSIS - A unified program analysis framework that facilitates the analysis of complex multi-language software systems, analysis reuse, and analysis comparison, by employing techniques such as program translation and automatic results mapping, is presented. The feasibility and effectiveness of such a framework are demonstrated using a sample application of the framework. The comparison yields new insights into the effectiveness of the techniques employed in both analysis tools. These encouraging results yield the observation that such a unified program analysis framework will prove to be valuable both as a testbed for examining different language analysis techniques, and as a unified toolset for broad program analysis. | 01-15-2009 |
20090024987 | METHOD AND SYSTEM FOR FACILITATING THE UTILIZATION OF COMPLEX DATA OBJECTS - Computer implemented method, system and computer usable program code for facilitating utilization of data. A computer implemented method for facilitating utilization of data includes receiving data, wherein the received data is in a first representation. The received data is converted from the first representation to a common representation that is mapped to the first representation using an external configuration file. The common representation of the data is output to facilitate utilization of the data. | 01-22-2009 |
20090070751 | Methods and apparatus for generating branchless code for select statements - In one embodiment, the present invention includes a method for determining whether a select statement can be transformed, and if so selecting a first or second transformation operation based on compiler-evaluated values for certain variables of the select statement, performing the selected transformation operation to obtain at least one new statement, and replacing the select statement with the at least one new statement. Other embodiments are described and claimed. | 03-12-2009 |
20090094587 | INFORMATION PROCESSING TERMINAL AND PROGRAM - An information processing terminal capable of specifying function information of a Jar file not to read the function information from a Jad file in which the function information of the Jar file are described, and a program used to specify the function information of the Jar file are provided. | 04-09-2009 |
20090094588 | METHOD AND SYSTEM FOR PROGRAM TRANSFORMATION USING FLOW-SENSITIVE TYPE CONSTRAINT ANALYSIS - A method for analyzing a program is provided. The method includes, determining an object type that may exist at an execution point of the program, wherein this enables determination of possible virtual functions that may be called; creating a call graph at a main entry point of the program; and recording an outgoing function call within a main function. The method also includes analyzing possible object types that may occur at any given instruction from any call path for virtual calls, wherein possible object types are determined by tracking object types as they pass through plural constructs; and calling into functions generically for handling specialized native runtime type information. | 04-09-2009 |
20090172648 | BYTE CODE ANALYSIS LIBRARY - A method to obtain offline source code is described. The system implementing the method extracts metadata from offline source code an constructs a logical model of the extracted metadata. | 07-02-2009 |
20090288073 | Edit Time Analyzer in a Loosely Typed Textual Language - Analyzing code written in a loosely typed language. User input specifying code for a script may be received. The specified code may be analyzed. More specifically, one or more code portions referenced by the specified code may be determined. Properties of symbols of the specified code and the one or more code portions may also be determined. Additionally, the specified code may be analyzed using the determined properties to determine errors in the specified code. Accordingly, one or more errors may be graphically indicated based on said analyzing. Receiving the user input, analyzing the specified code, and graphically indicating the one or more errors may be performed at edit time. | 11-19-2009 |
20100005456 | COMPILING METHOD, COMPILING APPARATUS AND COMPUTER SYSTEM FOR A LOOP IN A PROGRAM - A method for compiling a program including a loop is provided. In the program, the loop includes K instructions (K>2) and repeats for M times (M>2). The compiling method comprises following steps: performing resource conflict analysis to the K instructions in the loop; dividing the K instructions in the loop into a first combined instruction section, a connection instruction section and a second combined instruction section, wherein there is no resource conflict between the instructions in the first combined instruction section and the instructions in the second combined instruction section respectively; and compiling the program, wherein the instructions in the first combined instruction section in the cycle N (N=2, 3, . . . M) and the instructions in the second combined instruction section in the cycle N−1 are combined to be compiled respectively. A compiling apparatus and a computer system for realizing the above-mentioned compiling method are further provided. | 01-07-2010 |
20100070955 | ALIAS ANALYSIS FOR CONCURRENT SOFTWARE PROGRAMS - A computer-implemented pointer alias-analysis for concurrent software programs utilizing a divide-and-conquer approach, transaction level summarization and parallelization. | 03-18-2010 |
20100138815 | IMPLEMENTING ASPECTS WITH CALLBACKS IN VIRTUAL MACHINES - Implementing aspects via callback in a virtual machine, where an aspect weaver weaves the aspect with a module to provide primary and crosscutting functionality in the runtime execution of the module. The virtual machine has multiple modules that are part of an application implementing separation of concerns. Each of the multiple modules has a distinct functionality portion and a common functionality portion, common to all modules. The common functionality is referenced by the virtual machine via callback for the multiple modules. Aspect code is loaded as a callback that is applied to the multiple modules by the virtual machine. Loading the aspect code as a callback can implement the aspect at any point in the modules, including conditional statements, calls to methods of objects or classes, loops, any point in an exception handler, or to monitor changes in variables. | 06-03-2010 |
20100162218 | RELAXED AND EXTENDED DELEGATES - Systems and methods that enhance expressibility in a programming language (e.g., Visual Basic) via relaxation of artificial restrictions and extension of delegates associated therewith, without changing the runtime infrastructure. A stub is employed that can replace an impermissible expression in the programming language, to leverage the existing permissible expressions. | 06-24-2010 |
20100169870 | System and Method for Reducing Transactional Abort Rates Using Compiler Optimization Techniques - In transactional memory systems, transactional aborts due to conflicts between concurrent threads may cause system performance degradation. A compiler may attempt to minimize runtime abort rates by performing one or more code transformations and/or other optimizations on a transactional memory program in an attempt to minimize one or more store-commit intervals. The compiler may employ store deferral, hoisting of long-latency operations from within a transaction body and/or store-commit interval, speculative hoisting of long-latency operations, and/or redundant store squashing optimizations. The compiler may perform optimizing transformations on source code and/or on any intermediate representation of the source code (e.g., parse trees, un-optimized assembly code, etc.). In some embodiments, the compiler may preemptively avoid naïve target code constructions. The compiler may perform static and/or dynamic analysis of a program in order to determine which, if any, transformations should be applied and/or may dynamically recompile code sections at runtime, based on execution analysis. | 07-01-2010 |
20100211938 | SCHEMA-BASED DYNAMIC PARSE/BUILD ENGINE FOR PARSING MULTI-FORMAT MESSAGES - A parse/build engine that can handle multi-format financial messages. The engine converts the different format messages into a common format, and the common format message is then processed by the business service application. A parser examines the message and determines an appropriate schema for the particular format of message received. The schema is a data structure in a schema registry that includes a grammar structure for the received format as well as pointers to handlers for converting the different fields of the message into the internal message format using the grammar structure (the “grammar” can include field sequence, field type, length, character encoding, optional and required fields, etc.). The handlers are individually compiled. As formats change, new formats or changes to old formats can be dynamically added to the parse/build engine by loading new schema and handlers. | 08-19-2010 |
20100223604 | MODULE SYSTEM FOR POLYMORPHIC PI-CALCULUS - A method and apparatus is disclosed herein for using a module system for polymorphic π-calculus. In one embodiment, the method comprises receiving a formal specification of a software program; and performing automatic analysis on the formal specification using a module system fitted with processes of the polymorphic π-calculus processes. | 09-02-2010 |
20100281471 | METHODS AND APPARATUSES FOR COMPILER-CREATING HELPER THREADS FOR MULTI-THREADING - Methods and apparatuses for compiler-created helper thread for multi-threading are described herein. In one embodiment, exemplary process includes identifying a region of a main thread that likely has one or more delinquent loads, the one or more delinquent loads representing loads which likely suffer cache misses during an execution of the main thread, analyzing the region for one or more helper threads with respect to the main thread, and generating code for the one or more helper threads, the one or more helper threads being speculatively executed in parallel with the main thread to perform one or more tasks for the region of the main thread. Other methods and apparatuses are also described. | 11-04-2010 |
20100306749 | Software Analysis Framework - Presently described is a decompilation method of operation and system for parsing executable code, identifying and recursively modeling data flows, identifying and recursively modeling control flow, and iteratively refining these models to provide a complete model at the nanocode level. The nanocode decompiler may be used to determine if flaws, security vulnerabilities, or general quality issues exist in the code. The nanocode decompiler outputs in a standardized, human-readable intermediate representation (IR) designed for automated or scripted analysis and reporting. Reports may take the form of a computer annotated and/or partially human annotated nanocode listing in the above-described IR. Annotations may include plain English statements regarding flaws and pointers to badly constructed data structures, unchecked buffers, malicious embedded code or “trap doors,” and the like. Annotations may be generated through a scripted analysis process or by means of an expert-enhanced, quasi-autonomous system. | 12-02-2010 |
20100318976 | METHOD AND SYSTEM FOR CONSTRUCTING A CUSTOMIZED WEB ANALYTICS APPLICATION - A method for constructing a customized web analytics application comprises providing a base analytics code, including a base data mining code and a plurality of tokens corresponding to unincorporated code snippets, and incorporating code snippets as selected to create the application where each code snippet is configured to track a different custom web analytic. The system displays a selection of at least one web analytic to track and receives user selection of at least one displayed web analytic to track over a wide area network. Once selected, an unincorporated code snippet corresponding to each selected displayed web analytic is retrieved from a library of such code snippets. The code snippet is then substituted in place of its corresponding token within the base analytics code to create a customized analytics code. The customized code is finalized by removing the remaining tokens and the finalized code transmitted to the user for incorporation into their web pages. | 12-16-2010 |
20110029960 | ENCAPSULATING AND MANAGING DIAGNOSTIC INFORMATION - The disclosed embodiments provide a system that encapsulates and manages diagnostic information. During operation, the system detects an event that generates diagnostic information, and stores this diagnostic information in a format that preserves semantic information associated with the event. The system also determines an output context (e.g., the intended target environment) for the diagnostic information, and then uses the preserved semantic information to output the diagnostic information in a context-sensitive format suited for the output context. Note that outputting customized diagnostic information that is adapted to a specific target environment facilitates improving the quality of diagnostic information presented to a user. | 02-03-2011 |
20110154306 | Methods And Apparatuses For Endian Conversion - An embodiment of the invention includes code, such as a compiler, that enables byte order dependent code to execute on opposite byte order dependent architectures or systems. The compiler analyzes source code and produces diagnostic reports that indicate where source code changes are desirable to produce “endian neutral” source code versions that are compatible with opposite byte order dependent architectures or systems. Such source code changes may be desirable for code portions that will produce implicit byte order changes or byte order border crossings. The modified source code that is generated may include the semantics of the desired endian conversion, as opposed to generated executable code that includes proper endian formats but which may limit the architectures to which the code is applicable. | 06-23-2011 |
20110173594 | Selective Loading of Code Elements for Code Analysis - Systems and methods are described herein for selectively loading code elements included in a plurality of software entities comprising a target software entity and one or more reference software entities to facilitate analysis of the target software entity by a code analysis tool, such as a static code analysis tool. In one embodiment, all of the code elements in the target software entity are loaded while only those code elements included in the reference software entities that are determined to be most important from a dependency standpoint are loaded. The loaded code elements may be used to obtain suitable definitions of the code elements included in the target software entity for the purpose of code analysis. | 07-14-2011 |
20110179403 | SYSTEM AND METHOD FOR ANNOTATION-DRIVEN FUNCTION INLINING - Disclosed herein are systems, methods, and computer-readable storage media for obfuscating using inlined functions. A system configured to practice the method receives a program listing including annotated functions for obfuscation, identifies an annotated function called more than once in the program listing, and creates an inline control flow structure in the program listing for the identified annotated function, the control flow structure being computationally equivalent to inlining the identified annotated function into the program listing for each occurrence of the identified annotated function. The program listing can include tiers of annotated functions. The system can identify annotated functions called more than once based on an optionally generated callgraph. The system can create inline control flow structures in the program listing in order of annotation importance. The system can identify how many times each annotated function is called in the program listing. | 07-21-2011 |
20110191756 | Code string search apparatus, search method, and program - A code ID range table holding code ID ranges for each code and a next code ID table holding next code IDs, which are the code ID located next to each code ID, are created. Code ID ranges of codes configuring a search code string are read out from the code ID range table for the search target code string, and the stored next code ID corresponding to a code ID included in the code ID range of the head code in the search code string is read out from the next code ID table while the stored next code IDs corresponding to the next codes are successively read out from the next code ID table, and the next code ID read out from the next code ID table is verified whether it is included in the code ID range read out from the code ID range table. | 08-04-2011 |
20110202906 | COMPILING METHOD AND COMPILING PROGRAM - A compiling method for translating an input program to an object program enables a user to easily ascertain how the input program and the object program are affected by designation of a plurality of extended language specifications. The compiling method includes: analyzing, in the case where the plurality of extended language specifications are designated in the input program, the designated plurality of extended language specifications, to determine which part of the input program is affected by the designated plurality of extended language specifications; and outputting information about the part, together with the object program. | 08-18-2011 |
20120072890 | UNIFIED DATA TYPE SYSTEM AND METHOD - A type system includes a dual representation for basic data types. One representation is the basic data type representation common to such basic built-in data types, known as an unboxed value type or simply as a value type. Each of the basic data types also has a boxed representation that can be stored in the object hierarchy of the type system. This dual representation can also be extended to user-defined types, so that user-defined types may exist both as an unboxed value type and as an object within the object hierarchy of the type system. This dual representation allows the compiler and/or runtime environment to select the most effective and efficient representation for the data type depending on the particular need at the moment. | 03-22-2012 |
20120096446 | PARSING OF DECLARATIONS IN ALL BRANCHES OF PREPROCESSOR CONDITIONALS - Declarations from an input source code or tokenized source code are serialized into a stream of tokens produced by following each branch of a preprocessor conditional directive statement that interrupts a declaration. Tokens are labeled with a parsing path indicator corresponding to a parsing path induced by branches of a preprocessor conditional directive. The declarations that are formed along the different parsing paths are serialized by fetching the tokens that belong to the first parsing path in a first pass, and passing the tokens on to a next phase of a compiler. The pointer that marks the next token is repositioned to return to the start of the declaration. The declaration may be serialized again through the second parsing path in a second pass. The operation may be repeated until each of the parsing paths induced by the presence of branches of the preprocessor conditional directives in the source code is exhausted. | 04-19-2012 |
20120192162 | Optimizing Handlers for Application-Specific Operations for Validating C++ Programs Using Symbolic Execution - Particular embodiments discover a relationship between a plurality of methods of a C++ object; define one or more rules to represent the relationship; verify the rules by symbolically executing the methods; and if the rules are verified, then use the rules when symbolically executing the methods so that bytecode of the methods is not executed. | 07-26-2012 |
20130125101 | HOSTABLE COMPILER UTILIZING TYPE INFORMATION FROM A HOST APPLCIATION - A hostable compiler interacts with a host application to enable the host application to execute program code supported by the hostable compiler. The host application and the hostable compiler exchange data through an interface that allows the hostable compiler to receive type information pertaining to data elements used applications executing within the host application process. This type information may then be used by the hostable compiler in the compilation of source code to infer a type for data elements used in the source code that are not declared yet associated with a value of an expression used in an application executed within the host application process. | 05-16-2013 |
20130152060 | DUAL MODE EVALUATION FOR PROGRAMS CONTAINING RECURSIVE COMPUTATION - A dual evaluation mode method for use with computer software that includes the acts of determining, for certain functions and expressions within input computer code, whether each function and expression may have any recursive dependencies, generating eager evaluation mode executable code for one or more elements of the input computer code based on the act of determining and providing both eager evaluation mode executable code and non-eager evaluation mode executable code to runtime software that supports both eager and non-eager evaluation modes. | 06-13-2013 |
20130205283 | Any-To-Any System For Doing Computing - Methods for constructing an Any-to-Any data machine (consisting of Any-to-Any data components and their environmental requirements) and an Any-to-Any code machine (consisting of Any-to-Any code components and their environmental requirements) and relating them together so that they harmoniously interact and so that the data Any-to-Any machine controls and is also acted upon by the code Any-to-Any machine so as to produce an Any-to-Any system that transforms data in a manner that is useful and which is analogous to the harmonious interaction of the Any-Any binary code and Any-to-Any transistor systems, and which handles data and transforms it in a sufficiently similar manner to the manner in which the human handles and transforms data that the human finds it easy and intuitive to operate, all supported by methods that enable data to be stored in a single logical grid structure that can accept and correctly relate, transmit and receive any data, together examples of methods to derive benefits from these inventions. | 08-08-2013 |
20140019947 | SYSTEM AND METHOD FOR SUPPORTING COMPATIBILITY CHECKING FOR LAMBDA EXPRESSION - A system and method can support compatibility checking in a programming language environment. The programming language environment can check whether a target type associated with an expression in the programming language environment is functional, wherein the target type is functional when it has exactly one method meeting one or more criteria that define that method as relevant in a counting system. Then, the programming language environment can derive a function descriptor from the target type, which is context-dependent. Furthermore, the programming language environment can type-check the expression with the function descriptor associated with the target type. | 01-16-2014 |
20140040871 | MOBILE BUILD, QUALITY AND DEPLOYMENT MANAGER - The present technology relates to computer implemented methods and systems for managing mobile applications by executing various routines on one or more computers in connection with the mobile applications. The present technology can involve routines and tools that download source code from a code repository. The present technology automatically builds the source code to create an executable build. The present technology can perform a check on the executable build according to a defined quality control rule, and communicate the executable build to an application repository. In certain aspects, the present technology can monitor application metrics and generate reports relating to the application metrics. In certain embodiments, the present technology compiles a launchability metric that establishes the mobile application's readiness for launch. | 02-06-2014 |
20140047419 | Handling Pointers in Program Code in a System that Supports Multiple Address Spaces - Some embodiments include a processing subsystem that compiles program code to generate compiled program code. In these embodiments, while compiling the program code, the processing subsystem first identifies a pointer in the program code that points to an unspecified address space. The processing subsystem then analyzes at least a portion of the program code to determine one or more address spaces to which the pointer may point. Next, the processor updates metadata for the pointer to indicate the one or more address spaces to which the pointer may point, the metadata enabling a determination of an address space to which the pointer points during subsequent execution of the compiled program code. | 02-13-2014 |
20140053142 | Imperative Attribution for Elements in Managed Runtimes - Aspects of the subject matter described herein relate to imperative attribution. In aspects, metadata of a managed runtime environment may be set by imperative statements included in code of a program executing in the managed runtime environment. The metadata may be associated with lookup data that identifies the metadata. The lookup data may be formed from an identifier supplied by an imperative statement and an identifier of a logical element which may be explicitly or implicitly supplied. The metadata may be computed at parse time, run time, or another time and may be computed based on state available to a managed runtime environment at the time the metadata is computed. | 02-20-2014 |
20140068576 | EXTENSIBLE EXECUTABLE MODELING - Methods, systems, and computer program products for generating executable computer code in an extensible format are provided. A computer-implemented method may include receiving computer source code for compilation and compiling the source code, to generate executable computer code in an extensible format that includes instructions for execution by a computer system configured to process the instructions in the extensible format. | 03-06-2014 |
20140075421 | APPARATUS AND METHOD FOR GENERATING ASSERTION BASED ON USER PROGRAM CODE, AND APPARATUS AND METHOD FOR VERIFYING PROCESSOR USING ASSERTION - Exemplary embodiments disclose a method for generating an assertion based on a user program code. The method may include receiving a user program comprising at least one assertion directive, a compiled result of the user program, and architecture information of a processor, and generating, based on the compiled result of the user program and the architecture information of the processor, an assertion which states an operation that the processor needs to perform in accordance with a code of the user program indicated by each of the at least one assertion directive. | 03-13-2014 |
20140282441 | STATIC TYPE CHECKING ACROSS MODULE UNIVERSES - Static type checking can be performed on types and values defined in modules in a system that dynamically composes programs from modules. The types and values do not share a global namespace. Each module defines its own module universe, disjoint from other modules. A language mechanism can establish a local name binding to one module within the content of another module. When type checking at compile time an environment can be established that corresponds to a runtime instance of the program. The static type system can be arranged to align with the runtime values, such that the names used to refer to objects at runtime are the same as the names used to refer to the types of those objects in the static type system. Aliases of a particular type are resolved to a known compile time description of the type. | 09-18-2014 |
20150033213 | COMPILING METHOD, STORAGE MEDIUM AND COMPILING APPARATUS - A compiling method for reading, by a computer comprising a processor and a memory, a source file therein and outputting an executable binary file, the compiling method including: a first step of receiving, by the computer, an interface file including a process and a module constructing a business process, input/output information of data of the business process being defined in the interface file, operation information for data set to be used in the business process being defined in the interface file; a second step of validating, by the computer, the operation information for the data set defined in the interface file; a third step of inhibiting, by the computer, generation of the executable binary file when a validation result is invalid; and a fourth step of generating, by the computer, the executable binary file from a source file containing the interface file when the validation result is valid. | 01-29-2015 |
20150100947 | BUILD-TIME RESOLVING AND TYPE CHECKING REFERENCES - Build-time resolution and type-enforcing of corresponding references in different code that references the same value. In response to detecting a directive within the code itself that a first reference in first code is to be correlated with a second reference in second code, and in response to detection that the types of the references are the same, a code generation tool generates correlation code that is interpretable to a compiler as allowing a value of a type of the first reference of a compiled-form of the first code to be passed as the same value of the same type of the second reference of a compiled-form of the second code. The first code, the second code, and the generated correlation code may then be compiled. If compilation is successful, this means that the first and second references are already properly resolved as referring to the same value and type-enforced. | 04-09-2015 |
20150121351 | GENERATING CONFIGURATION DATA BASED ON APPLICATION DEFINITIONS - Configuring a computer-based application on one or more computer systems includes compiling a configuration source to generate a compiled configuration file. Compiling the configuration source may also include accessing an application definition that includes a property definition, where the property definition includes a name attribute and a type attribute. Compiling the configuration source may further include selecting a property source from the configuration source based on the property source having a name attribute that matches the name attribute of the property definition. The property source may also include a value, and a type check may be performed on that value based on the type attribute of the property definition. Thereafter, a configuration property may be recorded in the compiled configuration file, where the configuration property includes a name specified by the name attribute of the property definition and the value of the property source. | 04-30-2015 |
20150317136 | COMPILED AND EXECUTABLE METHOD - A method and software system allowing the ability to use an existing Excel model and extract the business intelligence, relationships, computations and model into pure mathematical relationships and codes such that the business intelligence in the original model is completely protected and the model can be run at extremely high speed and advanced simulations of hundreds of thousands to millions of trials can be run. | 11-05-2015 |
20160048378 | METHOD FOR ENABLING INDEPENDENT COMPILATION OF PROGRAM AND A SYSTEM THEREFOR - A method and system for enabling independent or separate compilation of a program in a memory access and management system including one or more intraprocedural static analyses including an analysis with a first step mapping layouts or types to keys locally, file-by-file, obliviously followed by a second step providing a re-mapping of the layouts to keys globally, cognizant of all files in a program. | 02-18-2016 |
20160154633 | SYSTEMS, METHODS, AND APPARATUS FOR CERTIFYING PLUGINS FOR APPLICATION DEVELOPMENT | 06-02-2016 |