Inventors list

Assignees list

Classification tree browser

Top 100 Inventors

Top 100 Assignees


Editing

Subclass of:

717 - Data processing: software development, installation, and management

717100000 - SOFTWARE PROGRAM DEVELOPMENT TOOL (E.G., INTEGRATED CASE TOOL OR STAND-ALONE DEVELOPMENT TOOL)

Patent class list (only not empty are listed)

Deeper subclasses:

Class / Patent application numberDescriptionNumber of patent applications / Date published
717113000 Visual 83
717111000 Dynamic 22
Entries
DocumentTitleDate
20100083223COMPILATION MODEL - The claimed subject matter provides a system and/or method that facilitates creating executable code for an industrial environment. A language editor can enable a programming of a portion of data within a programming language. A compiler can compile the portion of data within the programming language. An assembler component can utilize an intermediate language to convert the portion of data into a portion of assembly object code, wherein the assembly object code is target independent. A linker can create a binary file from the portion of assembly object code, wherein the binary file is target independent. A loader can specifically tailor the binary file to a target resource by leveraging at least one PLC definition, wherein the loader creates a target executable code (TEC) program at runtime or at development time.04-01-2010
20130086550REORGANIZATION OF VIRTUALIZED COMPUTER PROGRAMS - In an embodiment, a data processing method comprises obtaining access to computer program code; identifying a plurality of code segments in the computer program code; reorganizing the computer program code into reorganized code, by re-ordering the plurality of code segments into a new order that is potentially different than an original order of the plurality of code segments; wherein the new order is unpredictable based on the original order; rewriting one or more pointers of the reorganized code to point to new locations in the reorganized code consistent with the order of the reorganized code; wherein the method is performed by one or more computing devices.04-04-2013
20090125881SYSTEM AND METHOD FOR DYNAMICALLY REDEFINING CLASS FILES IN AN APPLICATION SERVER ENVIRONMENT - Disclosed herein is a system and method for dynamically redefining class files in a Java-based development environment. The existing development cycle in Java generally requires developers to edit, build, and deploy before they can test changes to the code. This process can be quite time consuming. There is a need for dynamically redefining and testing class files in a development environment without a significant time delay or loss of data. In one embodiment, when a developer modifies the class definition a ClassFileTransformer function is used to maintain the original shape of a redefinable class, i.e. its declared fields and methods, without affecting the redefined class' behavior or appearance to outside code.05-14-2009
20120167040IDENTIFYING SOURCE CODE ELEMENTS FOR REFACTORING - A solution for identifying build errors associated with a source code file for determining source code elements for refactoring. An embodiment of the invention utilizes a source code management system in combination with build logs generated by a build environment to determine source code elements that would benefit from refactoring.06-28-2012
20090144697REFRACTOR INNER CLASS WITH OBJECT-ORIENTED PROGRAM OPTIMIZER TOOL FOR REDUCED FOOTPRINT AND FASTER APPLICATION START - A computer implemented method, computer program product, and data processing system for reducing the number of inner classes in a compiled computer program written in an object-oriented programming language. An outer class of the compiled computer program is received, wherein the outer class contains an inner class, wherein the outer class comprises instructions to create an instance of an inner class. The instance is to be used as one of a callback, a listener command, a set of instructions by which an object instance of the inner class transfers information to the corresponding containing instance of the outer class, and combinations thereof. A transformation of the outer class is performed by moving methods of the inner class, as well as their contained instructions, into the outer class. The behavior of the compiled computer program remains unchanged.06-04-2009
20090307657SYSTEM AND METHOD FOR ARRAY OBFUSCATION - Disclosed herein are systems, methods, and computer readable-media for obfuscating array contents in a first array, the method comprising dividing the first array into a plurality of secondary arrays having a combined total size equal to or greater than the first array, expanding each respective array in the plurality of the secondary arrays by a respective multiple M to generate a plurality of expanded arrays, and arranging data elements within each of the plurality of expanded arrays such that a data element located at an index I in a respective secondary array is located at an index I*M, wherein M is the respective multiple M in an associated expanded array, wherein data in the first array is obfuscated in the plurality of expanded arrays. One aspect further splits one or more of the secondary arrays by dividing individual data elements in a plurality of sub-arrays. The split sub-arrays may contain more data elements than the respective secondary array. The principles herein may be applied to single dimensional or multi-dimensional arrays. The obfuscated array contents may be accessed via an index to the first array which is translated to retrieve data elements stored in the plurality of expanded arrays.12-10-2009
20090307656Optimized Scalar Promotion with Load and Splat SIMD Instructions - Mechanisms for optimizing scalar code executed on a single instruction multiple data (SIMD) engine are provided. Placement of vector operation-splat operations may be determined based on an identification of scalar and SIMD operations in an original code representation. The original code representation may be modified to insert the vector operation-splat operations based on the determined placement of vector operation-splat operations to generate a first modified code representation. Placement of separate splat operations may be determined based on identification of scalar and SIMD operations in the first modified code representation. The first modified code representation may be modified to insert or delete separate splat operations based on the determined placement of the separate splat operations to generate a second modified code representation. SIMD code may be output based on the second modified code representation for execution by the SIMD engine.12-10-2009
20130074035SOURCE CODE COMPARISON DEVICE, SOURCE CODE COMPARISON METHOD AND SOURCE CODE COMPARISON PROGRAM - A source code comparison device includes a difference extraction portion extracting a difference between a source code before correction and the source code after correction, a syntax analysis portion dividing the extracted difference into divided differences which are portions corresponding to components usable in the source code, and generating a syntax analysis result having associated the divided difference with the component corresponding to the divided difference, a feature analysis portion setting a feature division for each of the divided differences included in the syntax analysis result, and an output portion outputting a comparison result having associated the divided difference with the feature division set for the divided difference. The feature analysis portion sets the feature division associated with the component in a correction history for the divided difference associated with the component in the syntax analysis result.03-21-2013
20090293041SOFTWARE PROTECTION THROUGH INTERDEPENDENT PARAMETER CLOUD CONSTRAINED SOFTWARE EXECUTION - Methods and a tool or instrument for performing the methods of protecting a computer program with a parameter cloud are disclosed. A parameter cloud comprising a plurality of elements may be created. Called functions of a computer program may have defined expected parameter cloud states so that proper behavior of the called function is achieved when the parameter cloud state is the expected parameter cloud state. An expected parameter cloud state may include a selected set of elements of the parameter cloud having assigned values. Static portions of the called functions may depend on a current parameter cloud state, and calling functions may transform the parameter cloud state prior to calling their respective called functions. The methods and instrument may operate on original source code or post-binary targets of the computer program. A fingerprint may be used to identify a specific computer program from a sequence of state transitions.11-26-2009
20120117536METHODS AND APPARATUS FOR SUB-ASSET MODIFICATION - Methods and apparatus for on-the-fly identification of sub-asset modifications in a data pipeline are described.05-10-2012
20120272212METHOD FOR INSERTING CODE INTO .NET PROGRAMS AND APPARATUS THEREFOR - The present invention discloses a method for inserting code into .Net program and an apparatus therefor, relating to the field of information security. The method comprises the steps of: writing information of code to be inserted to import table of a .Net executable file; adding address of the code to be inserted to import address table (IAT) of the .Net executable file to form a new import address table; change offset address of entry point of the .Net executable file to address of the new IAT; and change flag in header of metadata table of the .Net executable file to enable the .Net executable file to meet certification requirements when being executed. The apparatus comprises a writing module, a forming module, and a modification module. The method and apparatus provided by the present invention implement code insertion into .Net executable file without the dependency on assembly and disassembly tools and are easy to use. The problems of low efficiency, poor stability, and poor compatibility in inserting code into .Net executable file can be solved by the present invention.10-25-2012
20110296376Dynamically Injecting Behaviors Into Flex View Components - Systems, methods and articles of manufacture for dynamically injecting behaviors into view components are described herein. In an embodiment, a view component resides in an MXML file, while its behavior code (e.g., ACTIONSCRIPT) is stored in a separate file (e.g., .as file). In this way, the view component can be reused in separate applications where different behaviors may be applied to the same view component. In addition, because the behavior code is stored in a separate file, the behavior code is easier to read and maintain. Furthermore, behaviors can be dynamically (i.e., at runtime) injected into and un-injected from the view component. Embodiments of the invention also allow multiple behaviors to be injected into the same view component.12-01-2011
20100169861ENERGY/PERFORMANCE WITH OPTIMAL COMMUNICATION IN DYNAMIC PARALLELIZATION OF SINGLE-THREADED PROGRAMS - A method and apparatus for optimizing parallelized single threaded programs is herein described. Code regions, such as dependency chains, are replicated utilizing any known method, such as dynamic code replication. A flow network associated with a replicated code region is built and a minimum cut algorithm is applied to determine duplicated nodes, which may include a single instruction or a group of instructions, to be removed. The dependency of removed nodes is fulfilled with inserted communication to ensure proper data consistency of the original single-threaded program. As a result, both performance and power consumption is optimized for parallel code sections through removal of expensive workload nodes and replacement with communication between other replicated code regions to be executed in parallel.07-01-2010
20100011341METHOD, SYSTEM, AND APPARATUS FOR DYNAMICALLY INJECTING LOGGING STATEMENTS INTO WEB 2.0 JAVASCRIPT APPLICATIONS - A Method, System and Apparatus for dynamically injecting logging statements into Web 2.0 JavaScript applications includes a single block of JavaScript code configured to execute on a client device by loading a profiler JavaScript code into memory on the client device and registering a target JavaScript object. The profiler JavaScript code is configured to dynamically scan the user-defined JavaScript code and modify the functions to add events to a modified user-defined code which include an identification of when the function was called, when the function was exited and when an exception occurs. The modification module is wrapped into a try/catch block so that exceptions can be handled and posted back to the server or displayed to the user or developer.01-14-2010
20100275181CONVERSION OF A CLASS ORIENTED DATA FLOW PROGRAM TO A STRUCTURE ORIENTED DATA FLOW PROGRAM - System and method for converting a class oriented data flow program to a structure oriented data flow program. A first data flow program is received, where the first data flow program is an object oriented program comprising instances of one or more classes, and wherein the first data flow program is executable to perform a first function. The first data flow program is automatically converted to a second data flow program, where the second data flow program does not include the instances of the one or more classes, and where the second data flow program is executable to perform the first function. The second data flow program is stored on a computer memory, where the second data flow program is configured to be deployed to a device, e.g., a programmable hardware element, and where the second data flow program is executable on the device to perform the first function.10-28-2010
20100083224METHOD OF MODIFYING CODE OF A RUNNING COMPUTER PROGRAM BASED ON SYMBOL VALUES DISCOVERED FROM COMPARISON OF RUNNING CODE TO CORRESPONDING OBJECT CODE - In a method of modifying code of a running computer program so as to modify the running computer program without having to restart the running computer program for changes to the running computer program to take effect, the improvement is disclosed of: (a) comparing differences in the running program's running binary code versus object code produced by compiling the running program's source code and (b) using the results of step (a), determining what values to use for symbols in said changes to the program. The compiling may be performed using either the compiler originally used to compile the running program or a different compiler. A data storage medium having instructions stored therein for a computer to perform the improved method is also disclosed.04-01-2010
20100083222Development of Networked Applications - Mashup creation, through the reuse and combination of existing networking or Web applications, are presented. For example, a method for forming a networked software application on a first computer resource coupled by a network to a client computer of a user includes accessing, within a repository that is part of the first computer resource, a first networked software application part, forming, within the first computer resource, a second networked software application part, and providing the second networked software application part to the repository. The second networked software application part comprises a first element of the first networked software application part. The steps of accessing, forming and providing are performed using the first computer resource comprising the repository. The first and the second networked software application parts remain on the first computer resource, and separate from the client computer, during the forming of the second networked software application part.04-01-2010
20090282387SYSTEM AND PROGRAM PRODUCT FOR PROVIDING COMPUTING-ENVIRONMENT CONTROL OF A RESOURCE TO BE ACCESSED BY PROGRAM CODE - A system and program product for facilitating computing-environment control of a resource to be accessed by existing program code is provided which includes transparently replacing an uncontrolled resource referenced by existing program code with a resource controlled by a computing environment. The protocol also includes transparently interposing at least one resource management service of the computing environment between the existing program code and the resource controlled by the computing environment, wherein the at least one resource management service provides computing-environment control of the resource to be accessed by the existing program code. The replacing of the uncontrolled resource prevents the existing program code from directly accessing the resource.11-12-2009
20120297361CONFIGURATION MANAGEMENT SYSTEM FOR SOFTWARE PRODUCT LINE DEVELOPMENT ENVIRONMENT - A system that includes: a configuration management system configured to receive resource updates submitted by developers of a product line; an update monitor configured, in manual monitoring, to mark each submitted resource update with respective variability data specified as relevant to the update submission, by the developer; and a tracer configured, in automatic monitoring, to trace portions of the updated resource into respective features or products of the product line, to determine variability data relevant to the update submission, wherein when an update request is initiated by the developer, the configuration management system is configured to associate the submitted resource updates with the update request based on common variability data, to provide resource updates on demand, based on variability data, wherein in automatic update, the configuration management system is configured to notify developers on resource updates, based on variability data common to the updated resource and the notified developers.11-22-2012
20090288066EDITING APPARATUS AND METHOD FOR TEST DRIVEN DEVELOPMENT - An editing apparatus for Test Driven Development (TDD) includes: a design model manager for managing a design model; a test code manager for managing test code; an implementation code manager for managing implementation code; and a TDD synchronization manager, as the design model or the test code is altered, for altering the test code or the design model in synchronization with the design model or the test code, and selectively altering the implementation code.11-19-2009
20080201692SIEBEL SPF TEMPLATE FILE UPDATE UTILITY - The present invention is directed to a Siebel SPF template file update utility. A method for updating a template file in accordance with an embodiment of the present invention includes: obtaining a template file, an existing row_id, and a target row_id; scanning the template file for section markers; locating an encoded length of a section of the template file using a section marker; decoding the encoded length of the section to obtain a section length; reading the section in its entirety using the section length; scanning the section to locate each instance of the existing row_id; replacing each instance of the existing row_id with the target row_id; and recalculating and re-encoding the section length. This process is repeated for each additional section marker08-21-2008
20120297362EDITING SOURCE CODE - A method for editing source code includes receiving a modification to the source code made by a user, determining whether the modification would change the semantics of the source code, and handling the modification depending on the result of the determining.11-22-2012
20090007065LOGGING SYSTEM AND METHOD FOR COMPUTER SOFTWARE - The present invention provides a computer-implemented method to generate a logging dictionary for a compilation of a source code that has a logging statement and associated source code static data, comprising: selecting part of the source code that includes the logging statement; determining source code static data associated with the logging statement; generating a combined data element from the associated source code static data; correlating the combined data element with the logging statement; wherein if the combined data element does not occur in the logging dictionary correlated to said logging statement; assigning a log index value to the combined data element; and adding the log index value, correlated to the logging statement, to the log dictionary.01-01-2009
20080244512Code optimization based on loop structures - Instructions that have no dependence constraint between them and other instructions in a loop of a critical section may be moved out of the critical section so that the size of the critical section may be reduced. A flow graph of a program including the critical section may be generated, which includes loops. The flow graph may be transformed based on which any unnecessary instructions in loops may be moved out of the critical section. Subsequently, the original flow graph of the critical section may be recovered from the transformed flow graph.10-02-2008
20090064100SYSTEM, METHOD, AND COMPUTER PROGRAM PRODUCT FOR RECORDING OPERATIONS PERFORMED ON COMPUTER SOURCE CODE - A system, method, and computer program product are described. An example system comprises a development module creating and editing a plurality of classes in a plurality of files, the development module performing an operation that changes one of the classes and makes references to the class consistent with the change throughout the plurality of files, and a management module in communication with the development module storing the plurality of files, the management module creating and storing a record of the operation.03-05-2009
20080270982METHOD FOR AUTOMATING VARIABLES IN END-USER PROGRAMMING SYSTEM - A method for automating variables in an end-user programming system is disclosed. The end-user programming system comprises a script, a shared repository, at least one database, a recorder, an interpreter, and an execution engine. The script comprises at least one command describing an event comprising a data value. Each user has a uniquely identified entry set for the entries distributed in at least one database. The interpreter automatically creates a variable for a data value in a command by comparing the data value with each entry value in the entry set for the user recording the command. The interpreter automatically instantiates a variable in a command with an entry value by comparing the variable with each entry name in the entry set for the user executing the command.10-30-2008
20080270981DETERMINATIOIN OF A SET OF CANDIDATE CODE INSERTIONS FOR INSERTION IN PROGRAM CODE - A code assistance feature provides a user with a set of suggested program code insertions at a given point in the program code being edited. For example, in response to a user command, the feature identifies syntactically correct possible insertions derived from a search for insertions of a compatible type. The feature identifies members in the set of possible code insertions that can be expanded via a field dereference or subroutine call to provide further possible code insertions for selection by the user.10-30-2008
20090049425Code Obfuscation By Reference Linking - A method of obfuscating executable computer code to impede reverse-engineering, by interrupting the software's execution flow and replacing in-line code with calls to subroutines that do not represent logical program blocks. Embodiments of the present invention introduce decoy code to confuse attackers, and computed branching to relocated code so that actual program flow cannot be inferred from disassembled source representations.02-19-2009
20090094579METHOD AND SOFTWARE FOR EDITING WEB DOCUMENTS - Disclosed is a method of editing text using a web-based text editor. The method comprises opening a document using a web-based text editor; receiving a first user input for selecting a block of text in the document; in reply to the first user input, inserting, into a source code of the document, a first temporary node before the selected block and a second temporary node after the selected block; receiving a second user input for applying an attribute to the selected block; and in reply to the second user input, adding an attribute node between the first and second temporary nodes of the source code so as to apply the attribute to at least part of the block of the document.04-09-2009
20090164973CONTRACT PROGRAMMING FOR CODE ERROR REDUCTION - In one embodiment, a computer system provides an application programming interface (API) for augmenting an application API. A computer system receives software code written in a second programming language indicating a user's intention to augment an application API with contracts from a contract API written in a first programming language. The software code includes a reference to the contract API. The contracts include assertions indicating appropriate use of the application API. The computer system accesses portions of the contract API according to the reference in the software code and compiles the received software code and the referenced portions of the contract API into an intermediate language (IL) version of the software code. The IL version is in an intermediate language common to both the first programming language and the second programming language. The IL version includes the assertions indicating appropriate use of the application API.06-25-2009
20090064099STATIC ANALYSIS OF REACHABLE METHODS AND FIELDS IN OBJECT-ORIENTED APPLICATIONS USING OBJECT INSTANTIATION - Exemplary embodiments of the present invention comprise an algorithm described herein that utilizes a technique to shrink a set of potentially reachable elements to a close approximation of the actually reachable elements within a software application by closely approximating how the application executes at runtime. The algorithm attempts to identify all of the reachable elements of an object-oriented software application by starting with the entry points into the application and thereafter progressively determining all of the software elements within the application that are reachable. The algorithm instantiates application objects in the same way they would be instantiated at runtime and passes references to these objects from one method and field to the next; emulating as closely as possible object instantiation performed by the application at runtime.03-05-2009
20090055798METHOD AND APPARATUS FOR ADDRESS TAKEN REFINEMENT USING CONTROL FLOW INFORMATION - A computer implemented method, apparatus, and computer program product for obtaining aliasing information for a target variable in a computer program. A control flow graph representing the computer program is partitioned into an taken address portion that includes all reachable nodes in which an address of the target variable is taken and an untaken address portion that includes all other reachable nodes. All references to the target variable are replaced with a temporary variable in the untaken address portion. The target variable is initialized with the value from the temporary variable at each intermediary node in a set of intermediary nodes in the taken address portion. An intermediary node is a node at which an address of a target variable is taken. The aliasing information for the target variable is generated using the modified computer program.02-26-2009
20110225564Cross-Module Inlining Candidate Identification - Routines which are likely to be good candidates for cross-module inlining are automatically identified according to criteria based on service history, compiler inlining criteria, and/or execution performance criteria. Candidates can also be automatically identified by pattern matching codes of routines which satisfy service history, execution performance, and/or compiler criteria. Automatically identified candidate routines are presented in an inlining advisory tool, allowing developers to approve/veto automatically identified candidates, to add other routines, and to either suggest or require that the development tools perform cross-module inlining with particular routines. Changes to a candidate routine can trigger regeneration of native image(s) into which the routine has been compiled.09-15-2011
20090210856EFFICIENT COMPRESSION OF APPLICATIONS - In one embodiment, a method for inserting advertising into an application includes removing first application code from a first input executable file and placing it into an output executable file, wherein the first application code represents code part of the application. Then a first set of proxies is inserted into the first input executable file, wherein the first set of proxies, when run, makes calls to the first application code. Second application code is added into the output executable file, wherein the second application code represents code executable to display the advertising. The output executable file is compressed. Then, the first input executable file and the output executable file are provided to a device such that the device may load and execute the files.08-20-2009
20090204942ITERATIVE COMPONENT BINDING - Component domains used to define a binding between various components associated with the component domain. The component domain tracks the various services to be imported by each component, and tracks the various services exported by each component. At runtime, rather than at compile time, the various interrelations between the components are bound using the service import and export data. Accordingly, depending on the components available and their characteristics, the bindings may differ. This permits applications to be much more flexible. In one implementation, the binding is performed iteratively. For example, if after one iteration of binding service imports to service exports, some components may expand the services that they export, or the services that they desire to import.08-13-2009
20090319988SOFTWARE OPTIMIZATION DEVICE AND SOFTWARE OPTIMIZATION METHOD - A software optimization device includes performance data storage unit to store data indicating performance of each system call, corresponding to a plurality of system calls, system call extraction unit to extract a system call described in a program source and similar-system-call detection unit to detect, from among the system calls the data indicating the performance of which is stored in the performance data storage unit, a system call having a function similar to that of the system call extracted by the system call extraction unit and having a performance better than that of the extracted system call.12-24-2009
20090083704 System and method for expediting information display - Exemplary systems and methods for expediting information display on a user device are provided. In exemplary embodiments, a request for information is received. An application server then generates and provides source code for a web page containing the requested information. In exemplary embodiments, a removal module is returned with the source code for the first web page. The removal module is configured to remove unnecessary elements from subsequent source code in order to expedite loading and displaying of subsequent web pages on the user device. In some embodiments, the web page comprises a syndicated web page within a window of a main web page.03-26-2009
20100153914SERVICE RE-FACTORING METHOD AND SYSTEM - A service re-factoring method and system. The method includes selecting by a computing system, a first service comprising a first name. The computing system receives a second name for a second service to be generated from the first service. The computing system executes a service refactoring software application, adjusts a granularity of the first service, and generates the second service. The computing system retrieves first traceability links associated with the first service and a first value associated with a first service identification technique. The first traceability links are created within the second service. The computing system generates a second value associated with a second service identification technique. The first service, the first name, and the first value are removed from the computing system. The computing system stores the second service, the second name, the second value, and the first traceability link.06-17-2010
20120144366REFACTOR EXCEPTION CLASS HIERARCHY FOR REDUCED FOOTPRINT AND FASTER APPLICATION START - A method, system, and program product for removing exception classes that match a pattern is disclosed. Exception classes are searched for those of the exception classes that match that pattern. The parent classes of matched exception classes are refactored to accept an exception type argument. Code that throws the matched exceptions is rewritten by replacing the exception class with the parent class and adding a corresponding exception type. Code that catches the thrown exceptions is rewritten by changing a catch clause to catch a parent exception class and inserting a case statement for the exception type in that catch clause. The matched exception classes are removed.06-07-2012
20090249291Method To Transfer Annotation Across Versions of the Data - A method, apparatus, and article are provided for managing migration of annotations between versions of source code. Annotations associated with patterns of source code are identified. A comparison of the modified source code is conducted in conjunction with the identified annotations in a prior version of the source code to determine if the annotations may be migrated to any portions of the modified source code. The comparison includes an exact match and a partial match. With respect to the partial match, a threshold value is employed to define the parameters of a partial match. All annotations that are determine to be an exact match or a partial match are automatically migrated to a location in the modified source code determine to match within the threshold value.10-01-2009
20080307387SOFTWARE DEVELOPMENT APPARATUS AND METHOD FOR PROVIDING PERFORMANCE PREDICTION - Provided are an apparatus and method for developing software. More particularly, provided are a software development apparatus and method enabling prediction of non-functional performance, such as execution time, as well as functional performance of each constituent module in a software development process.12-11-2008
20100162209Embedding Software Developer Comments In Source Code Of Computer Programs - Computer-implemented methods, apparatus, and products for embedding software developer comments in source code of computer programs that includes receiving, by a software development application from a software developer, a location in source code of a computer program at which to insert a multimedia annotation, the multimedia annotation including software developer comments; and inserting, at the location in the source code, by the software development application, a hyperlink including a URL specifying a storage location for the multimedia annotation.06-24-2010
20100186001METHOD AND APPARATUS FOR NATIVE METHOD CALLS - A method and apparatus for a native method call. The method comprises: generating, in response to a native method call-associated event, a template copy from a generic template for processing the native method call; filling information required for processing the native method call in corresponding locations in the template copy; and changing a code execution flow to execute the template copy. When a native method is called, the native method is processed by dynamically inserting the template copy in the execution path at the assembly level.07-22-2010
20100175046METHOD AND DATA PROCESSING SYSTEM FOR COMPUTER-ASSISTED PERFORMANCE ANALYSIS OF A DATA PROCESSING SYSTEM - A method is disclosed for the computer-assisted performance analysis of a data processing system, wherein a program code with a plurality of code parts is running. During the execution of at least one embodiment of the method, one or more parts of the code parts are at least varied once while using a functionality creating a variance in regard to at least one criterion to be evaluated. The data processing system is executed with the varied code part and parts multiple times. A variance of the at least one criterion to be evaluated of the varied code part or parts, or of all code parts of the program code is determined. Finally, a covariance resulting from the variance is subjected to a multivariant analysis.07-08-2010
20100153915UNIQUE CONTEXT-BASED CODE ENHANCEMENT - Unique context-based code enhancement of the core functionality of standard source code objects is performed at any position in the code. Desired insertion/replacement position(s) input by a user trigger the generation of a unique context for an enhancement. The unique context is based on characteristics of the code in the standard source code objects, such as the statements proximate to the insertion/replacement position(s). The unique context is associated with one or more extension source code objects that, when integrated into the existing source code at the insertion/replacement position(s), will provide the enhancement. At compile-time, the unique context used to unambiguously locate the insertion/replacement position(s). The extension source code objects can include industry or customer extensions, add-ons, plug-ins, and the like.06-17-2010
20090293042APPARATUS, METHOD, AND SYSTEM OF ASSISTING SOFTWARE DEVELOPMENT - An apparatus, method, and system of assisting a user in the process of developing software having a function to access a web service are disclosed. A determination result is generated, which indicates whether an operation test of determining whether the software under development properly operates should be performed by a first test module or a second test module. Based on the determination result, the operation test is performed by a selected one of the first test module and the second test module.11-26-2009
20100235811Promotion of a Child Procedure in Heterogeneous Architecture Software - A method for promotion of a child procedure in a software application for a heterogeneous architecture, wherein the heterogeneous architecture comprises a first architecture type and a second architecture type, comprises inserting a parameter representing a parallel frame pointer to a parent procedure of the child procedure into the child procedure; and modifying a reference in the child procedure to a stack variable of the parent procedure to include an indirect access to the parent procedure via the parallel frame pointer.09-16-2010
20100146481DEVELOPING APPLICATIONS AT RUNTIME - Data applications may be developed within an integrated development environment comprising an iterative cycle of writing source code, building the source code, running the data application, and testing the data application. The development becomes iterative because the application is torn down, redesigned, rebuilt, and re-executed if the data application is modified. Developing an application at runtime is disclosed herein, which is generally more efficient than conventional iterative techniques. As provided herein, runtime application comprising prebuilt components is presented to a user. The runtime application may be modified through modification gestures. An update assembly may be built based upon the modification gestures. The runtime application may be updated based upon the updated assembly. For example, prebuilt components modified by modification gestures may be torn down, updated with a corresponding update assembly, and reloaded into the runtime application, while the runtime application is in a runtime state.06-10-2010
20090259989LAYERED STATIC PROGRAM ANALYSIS FRAMEWORK FOR SOFTWARE TESTING - A method for analyzing a set of potential bug statements in source code. The method including obtaining a set of static program analyses; recursively reducing the set of potential bug statements in the source code by: selecting a static program analysis for each recursion from the set of static program analyses in order from least time consuming to most time consuming; evaluating the set of potential bug statements using the static program analysis of the set of static program analyses to determine a subgroup of bug free statements of the set of potential bug statements in each recursion; and removing the subgroup of the bug free statements from the set of potential bug statements to reduce the set of potential bug statements in each recursion; thereby filtering at least one subgroup of bug free statements out of the set of potential bug statements in the source code.10-15-2009
20090327997Timing Analysis of Concurrent Programs - Described are various techniques by which a concurrent program is analyzed with respect to timing. In one aspect, code fragments in a concurrent program are modified and/or instrumented by inserting iteration counters inside loops. Examples of modified fragments include those corresponding to concurrently executing code fragments, non-blocking concurrent code fragments, blocking concurrent code fragments, fragments having a loop that may not terminate, fragments having interlocked operation, or fragments having a timeout. Such fragments are modified and/or flagged so as to provide the summary data. When statically analyzed, the instrumented code provides complexity information regarding each fragment, or combinations of fragments, such as concurrent fragments. Summary data regarding the concurrent program is provided by processing the complexity information into at least one computation graph.12-31-2009
20090138848COMPUTER READABLE RECORDING MEDIUM ON WHICH PROGRAM CONVERTING PROCESS PROGRAM IS RECORDED, PROGRAM CONVERTING METHOD, AND PROGRAM CONVERTING APPARATUS - A general-purpose rewriting process (patch process) is provided. In a program code, a command statement execution place and initialization of a character string variable of an argument of the command statement execution place are detected, and a range to be replaced is extracted on the basis of the detected place. In an adding operation of the detected character string, a portion (character string) to be added is extracted, and it is determined whether the portion is a fixed character string invariable) Based on information obtained by determining whether the added portion is invariable, a parameterized prepared command statement may be dynamically formed. In execution of the command statement, original function calling may be replaced with function calling using a prepared command statement. By the patch process, a byte code of a target program is rewritten and executed.05-28-2009
20100306737Techniques for Providing Environmental Impact Information Associated With Code - A technique for providing environmental impact information associated with code includes determining, based on execution of the code on a computer system, an environmental impact of a code execution sequence included in the code. A section of the code that is associated with the code execution sequence is then annotated with environmental impact information associated with the environmental impact of the code execution sequence.12-02-2010
20100180255PROGRAMMABLE FRAMEWORK FOR AUTOMATIC TUNING OF SOFTWARE APPLICATIONS - A target application is automatically tuned. A list of solutions for identified performance bottlenecks in a target application is retrieved from a storage device. A plurality of modules is executed to compute specific parameters for solutions contained in the list of solutions. A list of modification commands associated with specific parameters computed by the plurality of modules is generated. The list of modification commands associated with the specific parameters is appended to a command sequence list. The list of modification commands is implemented in the target application. Specific source code regions corresponding to the identified performance bottlenecks in the target application are automatically tuned using the implemented list of modification commands. Then, the tuned target application is stored in the storage device.07-15-2010
20110078656Code Edit Apparatus and Recording Medium - Each of first programs stored in a recording medium causes a computer to execute each specific type of edit process. A second program stored in the recording medium causes the computer to execute the following steps. A first step is a step of acquiring first information for designating a program file and an area to be edited and second information for designating the first program. A second step is a step of causing the computer to execute the process of editing the binary code of the area designated by the first information via the first program designated by the second information.03-31-2011
20090217238INCORPORATING STATE MACHINE CONTROLS INTO EXISTING NON-STATE MACHINE ENVIRONMENTS - A computer program product for incorporating state machine controls into existing non-state machine environments includes a tangible storage medium readable by a processing circuit and storing instructions for execution by the processing circuit for performing a method. The method includes determining a state machine representation for an existing environment, assigning state indicators to each state of the state machine, transcoding existing software flags of the environment into modifier values associated with the state indicators, assigning state values based on the modifier values and the state indicators, assigning event identifiers for transitions from the state values, and creating a tabular representation of the determined state machine, the tabular representation providing next state information based on the event identifiers and the state values.08-27-2009
20110107297SYSTEMS AND METHODS FOR RESOURCE LEAK DETECTION - Systems and methods for detecting resource leaks in a program using static analysis are disclosed. Dynamically adjustable sets of must-access paths can be employed for aliasing purposes to track resources intra- and inter-procedurally through a program. Actionable reports are also disclosed, in which resource leaks are prioritized, filtered and clustered to improve utility.05-05-2011
20110083118REVERSE ENGINEERING FOR CODE FILE REFACTORIZATION AND CONVERSION - A system comprises a processing device, a data store selectively connected to the processing device and configured to store a plurality of segments of a software application, and a code refactoring application included on the processing device. The code refactoring application may include instructions that when executed cause the processing device to receive at least a subset of the segments of the software application from the data store, determine a design structure for the segments based at least in part on the received segments, and refactor the segments into a refactored segment according to the determined design structure.04-07-2011
20120304149Editor with Commands for Automatically Disabling and Enabling Program Code Portions11-29-2012
20110252401SUPPORTING AND DEPLOYING DISTRIBUTED COMPUTING COMPONENTS - Methods and systems consistent with the present invention provide an improved software development tool that generates code corresponding to a distributed computing component, and verifies and corrects compliance of the code. In some embodiments, the improved software development tool verifies compliance of the code with a specification for the distributed computing component, and corrects any non-compliant portions of the code, using methods and systems consistent with the present invention.10-13-2011
20110035727UNDO/REDO ARCHITECTURE ACROSS MULTIPLE FILES - Editing operations are monitored for operations for which information must be stored in order to properly apply an undo or undo/redo sequence to plurality of files. A snapshot is taken and persisted before such an operation is performed. Upon the execution of an undo or redo command, the persisted snapshot is retrieved and applied to the newly generated editing element.02-10-2011
20100281463XML based scripting framework, and methods of providing automated interactions with remote systems - A method of creating an XML based framework to perform automated forecasting includes sending a file from a local host computer to a remote computer, receiving a file at the local host computer from the remote computer, installing the received file on the local host computer, and executing commands on the local host computer and the remote computer. Executing a command on the remote computer includes reading a run file and a host definition file. A framework for interacting between the local host computer and the remote computer is determined based on types of XML tags, the XML tags including at least one of a start of a tag, end of a tag, and text between the start of a tag and the end of a tag. Computer program products for creating an XML based framework to perform automated forecasting are also described.11-04-2010
20100088673Optimized Code Generation Targeting a High Locality Software Cache - Mechanisms for optimized code generation targeting a high locality software cache are provided. Original computer code is parsed to identify memory references in the original computer code. Memory references are classified as either regular memory references or irregular memory references. Regular memory references are controlled by a high locality cache mechanism. Original computer code is transformed, by a compiler, to generate transformed computer code in which the regular memory references are grouped into one or more memory reference streams, each memory reference stream having a leading memory reference, a trailing memory reference, and one or more middle memory references. Transforming of the original computer code comprises inserting, into the original computer code, instructions to execute initialization, lookup, and cleanup operations associated with the leading memory reference and trailing memory reference in a different manner from initialization, lookup, and cleanup operations for the one or more middle memory references.04-08-2010
20110154290METADATA PLUG-IN APPLICATION PROGRAMMING INTERFACE - Computer-based methods and systems for editing a time-based media program involve receiving an instruction to associate metadata with a selected portion of the program, determining a type of the metadata, wherein the type of the metadata is one of a predetermined set of metadata types, identifying a software component available to the editing system that is configured to process metadata of the determined type, and associating the metadata with the selected portion of the program by executing the identified software component to process the metadata. Metadata is represented using a scheme that is shared among the various computational components that manipulate the metadata; the scheme may also be shared with a host media processing system, as well as with other systems that are used in a time-based media editing and production workflow.06-23-2011
20080320444LATE BOUND PROGRAMMATIC ASSISTANCE - Programmatic assistance is provided for dynamic typing within an integrated development environment (IDE). Types associated with late bound constructs can be inferred from static information and/or determined from design time execution. Assistance can then be provided as a function of a precise and/or speculative type. Furthermore, dynamic type assistance can be employed in conjunction with static type assistance to facilitate development of a program that supports both late and early binding, for example.12-25-2008
20080320445SYSTEMS AND METHODS FOR GATHERING AND PROCESSING USER FEEDBACK - A system for enabling submission of user feedback includes an extension to an application that is configured for execution on a computing system. The extension is for operation with the application and may be invoked during execution of the application in order to submit user feedback on a feature of the application substantially contemporaneously with a presentation of the feature to the user during execution of the application. The extension may visually identify a location of the feature on a user's screen and display on the user's screen textual input, received from the user, concerning the feature.12-25-2008
20080320443WIKI APPLICATION DEVELOPMENT TOOL THAT USES SPECIALIZED BLOGS TO PUBLISH WIKI DEVELOPMENT CONTENT IN AN ORGANIZED/SEARCHABLE FASHION - The present invention discloses a software development system for WIKIs including a WIKI server, a BLOG server, and a data store. The WIKI server can serve WIKI pages to WIKI clients. The BLOG server can serve BLOGs to BLOG clients. The data store can manage WIKI BLOG entries. Each WIKI BLOG entry can include a link to one of the WIKI pages and metadata for the linked WIKI page. The metadata can include a WIKI page title, a WIKI page version, a WIKI page description, design notes, and other information. Searchable keywords can be generated from the metadata. WIKI BLOG entries can be searched by WIKI developers to find WIKI pages having designer specified criteria based on a keyword search. Wherein searching for WIKI BLOG entries and editing discovered WIKI pages associated with WIKI BLOGs can be performed by a WIKI client via a WIKI interface.12-25-2008
20100023925System and method for transforming hierarchical objects - A method and system for transforming a first object into a second object, comprising: receiving the source and second objects; subject to the objects being of attribute type, copying, the value of the source object to the second object; subject to the objects being of node type which comprises, for each member of the second object: locating a corresponding member having a corresponding name in the source object; and invoking the method for the member and the corresponding member; subject to the objects being of list type, the source object adapted to contain elements of a first type and the second object adapted to contain elements of a second type, for each element of the source object: creating a corresponding default element of the second type; and invoking the method for the element and the corresponding default element; and invoking a user-implemented transformation routine.01-28-2010
20090125880POLYMORPHIC SOFTWARE ARCHITECTURE - A polymorphic software architecture is provided by which the shape of the architecture is enabled to be dynamically changed by splitting and fusing various architectural components (which may also be called “elements”) responsively to the environment in which the software executes, without changing the application's code. The splitting and fusing points determine, for example, the partitioning of functionality and data across architecture components, communication among the components, and the allocation of resources to the components. A profile of an end-user, or a profile of the runtime environment that supports the end-user, may be used to drive the shape of the software architecture so that overall design goals are met upon initial software deployment, and maintained as the profiles change.05-14-2009
20120060146Automatic Application Tuning - According to an embodiment, a method of automatically tuning a software application is provided. The method includes modifying the execution of the software application using a first parameter, and scoring the first parameter based on a log value from the software application and an improvement goal. Next, the first parameter, the score of the first parameter and the log value is stored in a data store. The first parameter is then combined with a selected parameter retrieved from the data store, resulting in a second parameter. The listed steps are repeated until a criteria is met, and when the criteria is met, tuning results are generated based on the parameters, the log values and the improvement goal.03-08-2012
20120210297Virtual Typing Executables - A method for modifying a computer program. According to one embodiment, a new value to replace a value associated with a virtual type in a computer program is received. The new value is received during execution of the computer program by a processor unit. The replacement of the value by the new value modifies the computer program while the computer program is executed by the processor.08-16-2012
20100095271Fine-Grained Software-Directed Data Prefetching Using Integrated High-Level and Low-Level Code Analysis Optimizations - A mechanism for minimizing effective memory latency without unnecessary cost through fine-grained software-directed data prefetching using integrated high-level and low-level code analysis and optimizations is provided. The mechanism identifies and classifies streams, identifies data that is most likely to incur a cache miss, exploits effective hardware prefetching to determine the proper number of streams to be prefetched, exploits effective data prefetching on different types of streams in order to eliminate redundant prefetching and avoid cache pollution, and uses high-level transformations with integrated lower level cost analysis in the instruction scheduler to schedule prefetch instructions effectively.04-15-2010
20110099534INFORMATION PROCESSING APPARATUS, EXECUTION PROGRAM OPERATION MODIFICATION METHOD, AND RECORDING MEDIUM - A disclosed information processing apparatus capable of modifying an operation of an execution program includes an instruction information receiving unit that receives instruction information from an execution environment; an instruction information interpreting unit that interprets a position and execution contents in a source program from the received instruction information; an instruction information executing unit that refers to debug information including a corresponding relationship between the source program and an execution program main body, specifies a position in the execution program main body, the position corresponding to the interpreted position in the source program, and modifies the specified position in the execution program main body based on the interpreted execution contents; and an execution program main body unit that starts execution of the execution program after processes of the instruction information receiving unit, the instruction information interpreting unit, and the instruction information executing unit have been completed.04-28-2011
20120317545SYSTEMS AND METHODS FOR PROVIDING FEEDBACK FOR SOFTWARE COMPONENTS - Systems and methods for transforming applications to provide uniform mechanisms for commenting on application objects, and mechanisms for collecting and processing feedback are described herein. An aspect provides for analyzing application code for at least one user action event handler associated with at least one object; and for modifying each at least one user action event handler located within the application code to contain at least one action configured to handle feedback for the associated at least one object; wherein invoking the at least one user action event handler triggers the at least one action configured to handle feedback. Other embodiments and aspects are also described herein.12-13-2012
20120131549SYSTEMS AND METHODS FOR AUTOMATICALLY OPTIMIZING HIGH PERFORMANCE COMPUTING PROGRAMMING LANGUAGES - Systems and methods for replacing inferior code segments with optimal code segments. Systems and methods for making such replacements for programming languages using Message Passing Interface (MPI) are provided. For example, at the compiler level, point-to-point code segments may be identified and replaced with all-to-all code segments. Programming code may include X10, Chapel and other programming languages that support parallel for loop.05-24-2012
20110185341OPTIMIZING BOUNDS CHECKING USING COMPUTER ALGEBRA - Some embodiments of the present invention provide techniques and systems for optimizing bounds-checking During operation, the system can receive one or more instructions which when executed evaluate a first expression whose value is required to be between a lower bound expression's value and an upper bound expression's value, such that at least one of the following three values is not determinable before execution: the first expression's value, the lower bound expression's value, and the upper bound expression's value. Next, the system can use computer algebra to determine whether the first expression's value is guaranteed to be between the lower bound expression's value and the upper bound expression's value. If the system determines that the first expression's value is not guaranteed to be between the lower bound expression's value and the upper bound expression's value, the system can add bounds-checking instructions to the one or more instructions.07-28-2011
20120222001PROGRAM CREATION SUPPORT DEVICE - A program creation support device includes a program component creating, upon a user setting a content of a reuse parameter corresponding to each program element, a program in accordance with the set content, and a program component holding unit editing the program by reuse of that. The program component includes a program element creating, upon a plurality of parameters being enumerated and set in the reuse parameter, a program in which a plurality of elements corresponding to respective parameters are combined. The program creation support device can reduce efforts in the selection and combination of program components for creating a program conforming to predetermined specifications, to thereby enhance the efficiency of creating a program.08-30-2012
20100275182Knowledge Extraction and Transformation - The present disclosure includes a system and method for learning (or discovering and extracting) business knowledge from a collection of source code. The collection of source code is abstracted to generate an abstracted data stream, which is then transformed to an Extensible Markup Language (XML) format. The transformed data in XML format can be further converted to target formats or processed to satisfy different needs such as software system documentation, migration, impact analysis and security analysis. The disclosure also includes an implementation and operation for a pattern abstraction engine configured to receive an input data stream and format it for abstraction into a standard format using a pattern matching mechanism. The disclosure also includes an implementation and operation for a contextual pattern decoder engine configured to extract knowledge attributes and contextual taxonomy from classified blocks of an input data stream.10-28-2010
20120227029METHOD FOR CODE TRANSFORMATION SUPPORTING TEMPORAL ABSTRACTION OF PARAMETERS - A method of code transformation supporting temporal abstraction of parameters is provided herein. The method includes the following stages: extracting a set of statements from an original code and further creating a residual code being the original code without the statements, wherein two or more of the extracted statements are not on a same loop in the original code; adding conditions from the original code to the extracted set of statements, such that the added conditions are sufficient to render the set of statements executable; adding statements from the original code to the residual code, such that the added statements are sufficient to render the residual code executable; and adding code portions and variables to the set of statements and the residual code, such that a passing of values between the enhanced set of statements and the residual code maintains a respective passing of values in the original code.09-06-2012
20080301630MECHANISM TO PROVIDE DEBUGGING AND OPTIMIZATION IN POLICY AND KNOWLEDGE CONTROLLED DISTRIBUTED COMPUTING SYSTEMS, THROUGH THE USE OF TAGGED POLICIES AND KNOWLEDGE REPRESENTATION ELEMENTS - A mechanism to provide debugging and optimization in policy and knowledge controlled distributed computing system through the use of tagged policies is provided. An aspect of the mechanism tags one or more policies, for instance, at their creation time, execution time and/or at any other time an event that affects the policies occur. Decisions made according to policy execution or evaluation may be traced using the tags.12-04-2008
20120240101SYSTEM, METHOD AND PROGRAM PRODUCT FOR CORRECTING SEMANTIC ERRORS IN CODE USING PEER SUBMITTED CODE SNIPPETS - A method, system and/or program product corrects semantic errors in code in an integrated development environment. The method includes inputting, using a code editor, code being developed in an integrated development environment. One or more nodes, in a syntax tree constructed for inputting the code, are identified as containing semantic errors pertaining to use of a third-party library. A primary executable code snippet and a secondary code snippet for correcting the semantic errors are displayed. If execution of the primary code snippet does not correct the semantic errors, then the secondary code snippet is automatically executed.09-20-2012
20110035726IDENTIFYING SOURCE CODE ELEMENTS FOR REFACTORING - A solution for identifying build errors associated with a source code file for determining source code elements for refactoring. An embodiment of the invention utilizes a source code management system in combination with build logs generated by a build environment to determine source code elements that would benefit from refactoring.02-10-2011
20120272213DYNAMIC GENERATION OF FORMATTED USER INTERFACES IN SOFTWARE ENVIRONMENTS - Methods and systems for selecting multiple entities of a model or models to set or change data of the multiple entities together in a modeling environment are disclosed. When users create or edit a model or models, information on the entities of the model or models is provided to the users so that the users can select multiple entities in the model or models. On the selection of the multiple entities in the model or models, the modeling environment dynamically generates a user interface for the selected entities of the model or models for displaying, setting or changing data of the selected entities together. The user interface may display data of the selected entities that is not common to all of the selected entities in a different manner so that the users can identify common data of the selected entities.10-25-2012
20120331445Unchanged Object Management - Apparatus and program products are disclosed. Using a static analysis performed on code, the code is analyzed to determine a set of unchanged objects and modifying the code to exercise a singleton-pattern technique for one or more members of the set of unchanged objects. The modified code is output. Another technique includes accessing code from a client, and in response to any of the code being source code, compiling the source code into object code until all the code from the client comprises object code. Using a static analysis performed on the object code, the object code is analyzed to determine a set of unchanged objects and the object code is modified to exercise a singleton-pattern technique for one or more members of the set of unchanged objects. The modified object code is returned to the client.12-27-2012
20120089962Unchanged Object Management - A method includes, using a static analysis performed on code, analyzing the code to determine a set of unchanged objects and modifying the code to exercise a singleton-pattern technique for one or more members of the set of unchanged objects. The method also includes outputting the modified code. Apparatus and program products are also disclosed. Another method includes accessing code from a client, and in response to any of the code being source code, compiling the source code into object code until all the code from the client comprises object code. The method further includes, using a static analysis performed on the object code, analyzing the object code to determine a set of unchanged objects and modifying the object code to exercise a singleton-pattern technique for one or more members of the set of unchanged objects. The method additionally includes returning the modified object code to the client.04-12-2012
20120324424SOFTWARE ACCESSIBILITY TESTING - According to exemplary embodiments, method and systems for software accessibility testing are provided. Aspects of the exemplary embodiments include: obtaining accessibility information on content of a graphical user interface (GUI) of software under test, wherein accessibility information is content of the GUI for which describing text is available or content of the GUI which is accessible by keyboard use; determining content of the GUI which should not be available in a test due to a lack of accessibility information; restricting the GUI to restrict access to the content not available; and providing the restricted GUI to a user for testing.12-20-2012
20120096432Adding Funtionality To Existing Code At Exits - New code is added to existing object code in order to add new functionality. For example, a call to start a profiler function can be added at the beginning of a Java method and a call to stop the profiler function can be added at the exits of the Java method. A method may have many different exits. To insure that the profiler process is stopped regardless of which exit is performed, the byte code and exception table are modified.04-19-2012
20120096431METHOD AND APPARATUS FOR PROVIDING ADVERTISING DURING APPLICATION LOADING PROCESSES - A method and system in which a loading process of an application is controlled to present still or moving imagery such as advertisements, public service messages and the like to a user waiting for the application to load on a user device. Reporting and/or transacting mechanisms are provided to facilitate a business model between any of advertisement vendors (which supply the advertisements), application vendors (which adapt their code to display the advertisements) and advertising servers (which update user device advertisements and collect statistical data supporting the various transactions).04-19-2012
20120102454SOFTWARE DEVELOPMENT - A method, system and computer program product for developing software in which the software comprises a plurality of programs. A change to a program is received. A data structure checking procedure may then be invoked. The changed program is parsed for a reference to a data structure. Other instances of the data structure are located in other programs within the software. The referenced data structure is compared to the located other instances of the data structure. A predefined action (such as notifying a programmer or correcting the inconsistencies) is performed in response to any detected differences between the referenced data structure and the located other instances of the data structure. These steps are repeated for all data structures within the changed program.04-26-2012
20120291010DETERMINATION OF A SET OF CANDIDATE CODE INSERTIONS FOR INSERTION IN PROGRAM CODE - A code assistance feature provides a user with a set of suggested program code insertions at a given point in the program code being edited. For example, in response to a user command, the feature identifies syntactically correct possible insertions derived from a search for insertions of a compatible type. The feature identifies members in the set of possible code insertions that can be expanded via a field dereference or subroutine call to provide further possible code insertions for selection by the user.11-15-2012
20100131924METHOD OF BUILDING VIRTUAL KEYBOARD - A method of building and using of a virtual keyboard program that includes programming a virtual keyboard program by a scripting language programming tool is disclosed. The method includes registering an allowable execution action of a web browser to the virtual keyboard, such that the virtual keyboard is capable of being freely executed in the web browser based on scripting language. An event listener is used to monitor inputting actions.05-27-2010
20080216051System and method of interlocking to protect software-mediated program and device behaviours - Methods and devices for thwarting code and control flow based attacks on software. The source code of a subject piece of software is automatically divided into basic blocks of logic. Selected basic blocks are amended so that their outputs are extended. Similarly, other basic blocks are amended such that their inputs are correspondingly extended. The amendments increase or create dependencies between basic blocks such that tampering with one basic block's code causes other basic blocks to malfunction when executed.09-04-2008
20110219356CONFLICT RESOLUTION IN APPLICATIONS - A method, a system and computer program product for resolving conflicts in applications are disclosed, A first set of instructions configured to use a second set of instructions is identified during execution of a program having the first set of instructions. A third set of instructions couples the first set of instructions to the second set of instructions. I Incompatibility between the first set of instructions and the second set of instructions is identified, in response to compiling the first set of instructions and compiling the second set of instructions. A mechanism is provided for the third set of instructions to modify the second set of instructions, which result in a modified second set of instructions compatible with the first set of instructions.09-08-2011
20100287532METHOD AND SYSTEM FOR INTEGRATING MULTIPLE SCRIPTS - A method of testing the server implementation of the Domain Name System protocol by using a first body of computer code in a first programming language capable of sending and receiving DNS requests, and a second body of computer readable code in a second programming language capable of generating DNS requests and verifying responses. The second programming language may be tailored to writing code being capable of generating Domain Name System requests and verifying the response thereby allowing the program to be efficiently reconfigured to test different aspects of the server.11-11-2010
20130152043METHODS AND SYSTEMS FOR GENERATING TEST INFORMATION FROM A SOURCE CODE - Systems and methods for generating test information from a source code are described. One of the methods includes accessing the source code. The method further includes receiving a modification of the source code to generate a modified source code. The modification includes one or more instructions that do not affect functions performed by executing the source code. The modification further includes one or more instructions for generating test information regarding each executable line of the source code.06-13-2013
20130152042AUTOMATED AND HEURISTICALLY MANAGED SOLUTION TO QUANTIFY CPU AND PATH LENGTH COST OF INSTRUCTIONS ADDED, CHANGED OR REMOVED BY A SERVICE TEAM - Embodiments of the present invention provide a method, system, and computer program product for qualifying changes to an instruction set in source code. In an embodiment of the invention, a method for quantifying changes to an instruction set in source code can be provided. The method can include receiving text in a code editor as an edit to source code of a computer program querying a data store of code change costs with at least a portion of the edit. The method additionally can include retrieving in response to the query a code change cost associated with the edit. Finally, the method can include displaying in the code editor the retrieved code change cost.06-13-2013
20080256512OUT OF BAND DATA AUGMENTATION - Systems and methods facilitate data augmentation in a computer environment. Data collections of various forms are altered out of band with at least one augmentor specifying alterations thereto. The alterations are applied to an associated collection of data such as programmatic code. In this manner, data can be modified, extended and/or removed from the collection to enable specialization and/or personalization, among other things.10-16-2008
20120284688SYSTEM AND METHOD FOR BLURRING INSTRUCTIONS AND DATA VIA BINARY OBFUSCATION - Disclosed herein are systems, methods, and non-transitory computer-readable storage media for obfuscating a computer program. A system configured to practice the method identifies a set of executable instructions at a first location in an instruction section of the computer program and identifies a second location in a data section of the computer program. Then the system moves the set of executable instructions to the second location and patches references in the computer program to the set of executable instructions to point to the second location. The instruction section of the computer program can be labeled as _TEXT,_text and the data section of the computer program is labeled as _DATA,_data. The set of executable instructions can include one or more non-branching instructions optionally followed by a branching instruction. The placement of the first and second locations can be based on features of a target computing architecture, such as cache size.11-08-2012
20130185696MANIPULATING SOURCE CODE PATCHES - A computerized apparatus, a computer-implemented method and a computer program product for manipulating source code patches. The apparatus comprising a processor that is configured to: obtain a source code patch comprising plurality of source code modification instructions with respect to a source code and to automatically split the source code patch into plurality of sub-patches, wherein applying the plurality of sub-patches on the source code in an order is equivalent to applying the source code patch.07-18-2013
20110314447MULTI-INSTANCE "SHADOW" SYSTEM AND METHOD FOR AUTOMATED RESOURCE REDUNDANCY REDUCTION ACROSS DYNAMIC LANGUAGE APPLICATIONS UTILIZING APPLICATION OF DYNAMICALLY GENERATED TEMPLATES - A system and method are provided that allows, by adding a loadable module to the language runtime engine and overriding some of the core engine's operating system access functionality, the system to create a customizable copy of the installed application without creating complete copies of the actual files (scripts, executables, binaries, etc.) and without redundancies in content storage.12-22-2011
20110314446METHOD AND SYSTEM FOR SELECTIVELY COPYING PORTIONS OF A DOCUMENT CONTENTS IN A COMPUTING SYSTEM (SMART COPY AND PASTE - An improved method for generating text by using snippets of existing text and providing a command structure allowing a user to cut and paste from existing text.12-22-2011

Patent applications in class Editing

Patent applications in all subclasses Editing