Abstract: Aspects of the present disclosure involve systems, methods, devices, and the like for creating an application lifecycle management platform for big data applications. In one embodiment the lifecycle management platform can include a multiple-layer container file that integrates multiple big-data tools/platforms. The system may create a generic template application, create a build environment for the generic template application, create a test environment for the generic template application, and run the built generic template application in the test environment prior to the user writing any new code in the generic template application. In one embodiment, the test environment includes a container management system or virtual machine that launches the big data application (which may be the generic template application before a developer edits the file) on a separate big-data server cluster.

Abstract: A method, computer program product and system are provided for preloading debug information based on the presence of incremental source code files. Based on parsed input parameters to a source code debugger, a source code repository and a local storage area are searched for an incremental file. In response to the incremental file being located, a preload indicator in the incremental file, which is a source code file, is set. Based on the preload indicator being set, debug symbol data from the incremental file is merged to a preload symbol list. In response to receiving a command to examine the debug symbol data from the incremental file, the preload symbol list is searched for the requested debug symbol data.

Abstract: An embodiment of a semiconductor package apparatus may include technology to identify workload control variables, add workload flags to respective edges in a static single assignment graph, and propagate constants based on the identified workload control variables and the workload flags. Other embodiments are disclosed and claimed.

Abstract: Techniques are described for a software modernization service to provide the ability to re-platform software application binaries from one ISA and hardware platform to another. The software modernization service can generate assessment reports for users' legacy applications, including recommendations for hardware platforms available in a cloud provider network for use. Responsive to a user requesting to re-platform an application from one ISA and hardware platform to another, an application re-platforming service automates steps to perform a static and dynamic binary translation of an application and to combine the results into a re-platformed executable. Among other benefits, the described techniques enable the deployment of legacy software applications onto a wider set of target ISA and hardware platforms, thereby enabling such applications to take advantage of the performance, scalability, availability, and other benefits of certain types of hardware platforms as desired by a user.

Abstract: Some embodiments provide a compiler for optimizing the implementation of a machine-trained network (e.g., a neural network) on an integrated circuit (IC). The compiler of some embodiments receives a specification of a machine-trained network including multiple layers of computation nodes and generates a graph representing options for implementing the machine-trained network in the IC. In some embodiments, the graph includes nodes representing options for implementing each layer of the machine-trained network and edges between nodes for different layers representing different implementations that are compatible. The graph is used, in some embodiments, to select an optimum set of cores for implementing the received machine-trained network. The compiler, in some embodiments, optimizes memory storage such that input and output layers of a single layer are not stored in a same memory unit.

Abstract: Embodiments described herein are generally directed to testing a microservice to determine whether the microservice leaks sensitive information. According to an example, prior to deployment of a microservice within a production environment, a test suite for the microservice is generated based at least in part on a specification of an application programming interface (API) of the microservice defining operations supported by the API and information regarding parameters of each of the operations. The microservice is subjected to the test suite. A potential security leak by the microservice is then detected by analyzing a dataset to which the microservice outputs information, including applying security rules to the dataset.

Abstract: Various methods, systems, apparatuses, and media for implementing a log file processing module are disclosed. A database stores a plurality of log files each having one or more lines with keywords for searching common keywords of errors and warnings appearing in testing an application. A receiver receives a log file from the database via a communication network. A processor operatively connected to the receiver and the database via the communication network dynamically and automatically summarizes contents of the log file by generating a reduced data file in a human readable format by automatically executing a summarization algorithm.

Abstract: According to some embodiments, methods and systems may be associated with trustworthy application integration. A formalization platform may facilitate definition of pattern requirements by an integration developer. The formalization platform may also formalize singe pattern compositions and compose single patterns to template-based formalized compositions. A correctness platform may then check for structural correctness of the formalized compositions and execute a semantic transformation or binding to pattern characteristics and associated interactions. The correctness platform may also check composition semantics and generate a formal model. An implementation platform may translate the formal model generated by the correctness platform and configure implementation parameters of the translated formal model. The implementation platform may then execute the translated formal model in accordance with the configured implementation parameters.

Abstract: The syntax elements of a source code program used to represent the context of a focal method are selected based on a priority order. The selected syntax elements are input into a fixed-size context window that is used to train a neural transformer with attention model to learn to generate source code and used by the neural transformer model to generate source code. The context window contains prioritized sequences of tokens that extend beyond the target focus in order to provide a longer visibility back into the source code program for the model to learn predictive patterns. This gives the model a file-level context of the source code program without increasing the size of the context window.

Abstract: An apparatus, computer-readable medium, and computer-implemented method for data subsetting, including receiving a request comprising a criterion indicating a criterion table in a plurality of tables of a database, as schema of the database corresponding to an entity graph, the entity graph comprising a plurality of entities corresponding to the plurality of tables and a plurality of directed edges connecting the plurality of entities, determining directed edges in the plurality of directed edges that must be traversed in both directions in order to traverse all entities in the entity graph starting from a criterion entity corresponding to the criterion table, generating, an ordered list of edges for the entity graph based on the directed edges that must be traversed in both directions and topological ordering, and generating a subset of data from the plurality of tables based on the ordered list of edges for the entity graph and the request.

Abstract: A computer-implemented low-code development platform is provided including a user interface and having access to a library of step macros configured for user configuration and interconnection via the user interface to generate executable code. Each step macro includes a step configuration generator and an execution code generator. The step configuration generator is configured to generate a step configuration file based on user-configurable data points configurable via the user interface. The execution code generator is configured to generate executable code in the form of a compiled step file configured for storage in memory and execution by a processor of a computing system. The execution code generator receives and inputs the step configuration file into a metaprogramming component configured to interpret the user-configurable data points of the step configuration file and to generate and output the compiled step file.

Abstract: Techniques are described for enabling a software modernization system to automatically map binary executable files and other runtime artifacts (e.g., application binaries, Java ARchive (JAR) files, .NET Dynamic Link Library (DLL) files, process identifiers, etc.) to source code associated with the binary executable files, e.g., as part of modernization processes aimed at migrating users' applications to a cloud service provider's infrastructure. A software modernization service of a cloud provider network provides discovery agents and other tools that are capable of creating an inventory of users' software applications and collecting profile data about the software applications. Various techniques are described for automatically identifying the source code associated with software applications identified by a discovery agent in a user's computing environment, thereby improving the efficiency of various software modernization analyses and other modernization processes.

Abstract: A technique for computationally-efficient privacy-preserving homomorphic inferencing against a decision tree. Inferencing is carried out by a server against encrypted data points provided by a client. Fully homomorphic computation is enabled with respect to the decision tree by intelligently configuring the tree and the real number-valued features that are applied to the tree. To that end, and to the extent the decision tree is unbalanced, the server first balances the tree. A cryptographic packing scheme is then applied to the balanced decision tree and, in particular, to one or more entries in at least one of: an encrypted feature set, and a threshold data set, that are to be used during the decision tree evaluation process. Upon receipt of an encrypted data point, homomorphic inferencing on the configured decision tree is performed using a highly-accurate approximation comparator, which implements a “soft” membership recursive computation on real numbers, all in an oblivious manner.

Abstract: A processing device identifies an object that is assigned an object version indicating a modification operation has been performed on the object, and a signature version representing a version of data of the object for which a first signature has been created. The first signature is stored in a data store. The processing device determines whether the object is currently under modification by comparing a value of the object version to a value of the signature version, creates a second signature for the object using the data of the object, responsive to a determination that the object is not under modification, and performs a data integrity analysis on the data of the object by determining whether the first signature matches the second signature.

Abstract: Aspects of reusing neural network instructions are described herein. The aspects may include a computing device configured to calculate a hash value of a neural network layer based on the layer information thereof. A determination unit may be configured to determine whether the hash value exists in a hash table. If the hash value is included in the hash table, one or more neural network instructions that correspond to the hash value may be reused.

Abstract: In one embodiment, a method receives execution timelines that include nodes representing function calls and execution times from executing a first version of an application and a second version of the application. The method selects pairs of nodes from a first set of nodes from a first execution timeline and a second set of nodes from a second execution timeline. The method then iterates through the pairs of nodes to determine (1) whether a node in the second execution timeline is not included in the first execution timeline and has an execution time slower than a set difference; or (2) whether a first node in the second execution timeline has an execution time slower than a second node in the first execution timeline by the set difference. A critical graph is generated that defines a path of nodes that lead to a node that has been identified as a performance regression cause.

Abstract: Disclosed aspects relate to operation efficiency management in a shared pool of configurable computing resources. A first set of processing operations of a first application may be detected. A second set of processing operations of a second application may be detected. The first set of processing operations of the first application may be compared with the second set of processing operations of the second application. A substantial match of the first and second processing operations of the first and second applications may be determined. A single set of processing operations for both the first and second applications may be compiled.

Abstract: Embodiments of the present disclosure relate to techniques for maintaining a state of a distributed system. In particular, certain embodiments relate to identifying a function. Some embodiments relate to, upon determining that the function comprises an annotation indicating that the function is capable of modifying the state of the distributed system, transforming the function to allow the function to generate updates to a state machine.

Abstract: Embodiments relate to optimizing an indirect call function. More specifically, an indirect call function configuration comprises a first application module having a target function of the indirect function call, a second application module with a symbolic reference to the target function of the indirect function call, and a third application module to originate an indirect function call. A compiler is provided to identify potential target functions and indicate the potential target functions in the program code. Additionally, the compiler determines and indicates in the program code that the function pointer value resulting from a non-call reference of a function symbol is solely used to perform indirect calls in the same module. A linker can read the indication the compiler made in the program code and optimize the indirect call function.

Abstract: Embodiments relate to optimizing an indirect call function. More specifically, an indirect call function configuration comprises a first application module having a target function of the indirect function call, a second application module with a symbolic reference to the target function of the indirect function call, and a third application module to originate an indirect function call. A compiler identifies potential target functions and indicates the potential target functions in the program code. Additionally, the compiler determines and indicates in the program code that the function pointer value resulting from a non-call reference of a function symbol is solely used to perform indirect calls in the same module. A linker can read the indication the compiler made in the program code and optimize the indirect call function.

Abstract: The present disclosure provides an automated technique to detect and rectify input-dependent evasion code in a generic manner during runtime. Pattern-based detection is used to detect the evasion code and trigger an identification process. The identification process marks the evasion code and rectifies the execution flow to a more “significant” path. The execution then moves on by following this path to bypass the evasion code. Other embodiments, aspects and features are also disclosed.

Abstract: A modeling environment is provided allowing a user to generate, from a source representation of a model, a target representation of a model and a listing of the optimization performed during generation of the target representation which is associated with the target representation or the source representation. The model may represent a system, such as a dynamic system. The source representation of the model may be a graphical or textual representation. In some embodiments a user may specify whether to implement the optimization.

Abstract: A medical device including a non-transitory storage device storing a plurality of modular software components programmed to provide medical device functionality is disclosed. The software components can be configured to run independently as a daemon, to be modified without recompiling unchanged software components and to communicate to each other through a software component. A system including a central unit configured to communicate with a medical device is also disclosed. A medical device software architecture stored on a non-transitory, computer readable storage medium including a plurality of modular software components programmed to provide medical device functionality is also disclosed.

Abstract: Aspects of the disclosure relate to managing code origination data for a stream computing environment. A first set of code origination data which corresponds to a first computing object and a second set of code origination data which corresponds to a second computing object may be detected for utilization to develop a streaming application in the stream computing environment. Based on the first and second sets of code origination data, a code assembly arrangement with respect to the first and second computing objects may be determined. The code assembly arrangement may be established with respect to the first and second computing objects to develop the streaming application.

Abstract: Described herein is a transcompiling framework. In accordance with one aspect, the framework generates a source abstract syntax representation corresponding to source code written in a source language. The framework may determine validity of constraints of a common denominator language by parsing the source abstract syntax representation, wherein the common denominator language is a set of intersects provided by the source language and reachable by a target language. In response to determining the constraints are valid, the source abstract syntax representation may be transformed to a target syntax representation associated with the target language. The target syntax representation is then printed as transcompiled source code in the target language.

Abstract: The invention relates to a system and method of context aware adaption of content for a mobile device. This involves identifying context parameters and associated values, selection of content layout based on context parameters. Content layout is selected from pre-configured content layouts based on context parameters. The content is retrieved from a content store. Content style is selected from pre-configured content styles based on context parameters. Rendering content on the device display based on the selected content layout, content style and at least one context parameter.

Abstract: Systems, methods, and apparatuses are provided for code injection and code interception in an operating systems having multiple subsystem environments. Code injection into a target process can rely on generation of a virtual process that can permit analysis of information loaded in a memory image of the target process regardless of the host environment in which the target process is executed. Based at least on information collected via the analysis, code can be injected into the target process while preserving integrity of the target process. Code interception also can exploit the analysis for suitable hooking that preserves integrity of target process. Code interception can utilize relocatable tokenized code that can be parameterized through token replacement.

Abstract: Systems and methods are provided that service a JavaServer Page (“JSP”), including receiving a request for a JSP page, parsing source code for the JSP page, creating a tree of the parsed source code. executing the tree in memory, and returning the requested JSP page. Accordingly, JSP pages do not require repeated recompilation, and JSP pages with customized content may be quickly regenerated with a low performance overhead.

Abstract: Techniques are provided herein for the offline static analysis of a stable code base in order to build a compiler and tools specialized to that code base. This allows global code base knowledge to be applied earlier in the compilation process giving better opportunities for optimization. The offline static analysis produces specialized compiler components that are then used to rebuild the compiler. This results, over time, in a compiler specialized to the code base with improved optimization after every compiler release cycle.

Abstract: An optimizing compiler includes a strength reduction mechanism that optimizes a computer program that includes operations that have an unknown stride by analyzing the instructions in the computer program in a single pass, determining whether instruction substitution is profitable for original instructions in the code, and performing instruction substitution for one or more original instructions for which instruction substitution is deemed profitable, including operations with unknown strides. The substituted instructions result in strength reduction in the computer program.

Abstract: An optimizing compiler includes a strength reduction mechanism that optimizes a computer program that includes operations that have an unknown stride by analyzing the instructions in the computer program in a single pass, determining whether instruction substitution is profitable for original instructions in the code, and performing instruction substitution for one or more original instructions for which instruction substitution is deemed profitable, including operations with unknown strides. The substituted instructions result in strength reduction in the computer program.

Abstract: A method is presented for notifying a user of a broadcast communication channel problem. At a broadcast distribution facility, a problem involving a first broadcast communication channel from the broadcast distribution facility to a broadcast communication receiver associated with the user is detected. A cause of the problem is ascertained at the facility. The broadcast distribution facility then relays an indication of the cause of the problem to the receiver over a second broadcast communication channel from the facility to the receiver. The receiver informs the user of the cause of the problem.

Abstract: A method for diagnosing an error associated with a software is provided. The method may include receiving a stack trace associated with the error. The method may also include fetching a source code associated with the received stack trace. The method may further include parsing the fetched source code associated with the received stack trace. The method may also include generating an abstract syntax tree (AST) based on the parsed fetched source code. Additionally, the method may include inserting at least one logging call into the generated abstract tree. The method may include recompiling the captured code based on the generated abstract tree with the at least one inserted logging call. The method may also include uploading the recompiled code onto at least one deployment server.

Abstract: A method for diagnosing an error associated with a software is provided. The method may include receiving a stack trace associated with the error. The method may also include fetching a source code associated with the received stack trace. The method may further include parsing the fetched source code associated with the received stack trace. The method may also include generating an abstract syntax tree (AST) based on the parsed fetched source code. Additionally, the method may include inserting at least one logging call into the generated abstract tree. The method may include recompiling the captured code based on the generated abstract tree with the at least one inserted logging call. The method may also include uploading the recompiled code onto at least one deployment server.

Abstract: There is provided a module management apparatus, that coordinates, in a time of start of a module management infrastructure carrying out integrated management of: a bundle having a module formed by a program described by an object oriented language and definition information including an attribute of the module; and a module group including a plurality of pieces of the bundle, when the bundle is loaded from a folder, and, if the definition information collides between different bundles, a reference relationship of the bundle by changing the definition information dynamically.

Abstract: A system obtains first code that includes one or more lines of code, the lines of code including first information associated with one or more data types or one or more routine types. The system removes the first information from the lines of code; and generates one or more instructions that, when executed, enable the system to obtain the first information or second information. The second information is associated with at least one data type that is different than the one or more data types or at least one routine type that is different than the one or more routine types. The system modifies the lines of code based on the one or more instructions; generates second code based on the first code and the modified lines of code; and outputs the second code.

Abstract: A firmware extension method is provided, particularly adaptable for an embedded system. Firstly, a baseline firmware image is provided with a header file. Secondly, an extension firmware image is generated based on the header file, comprising one or more extended functions. Thereafter, a callback table is generated, comprising pointers pointing to entries of the extended functions in the extension firmware image. Further, memory allocation parameters are provided. The memory allocation parameters comprise a base address where the extension firmware image starts. The baseline firmware image, the extension firmware image and the callback table are then merged to generate a merged firmware image based on the memory allocation parameters.

Abstract: Methods and systems for facilitating incremental software development are disclosed. For example, a method can include receiving a plurality of binary software libraries sufficient for building a software project. A request from a user to modify source code for at least one of the plurality of binary libraries is received. In response to receiving the request, the source code for the at least one of the plurality of binary libraries is retrieved. The source code for the at least one of the plurality of binary libraries is presented to the user. Modified source code for the at least one of the plurality of binary libraries is received. The modified source code is compiled to produce compiled modified code. A revised version of the software project is built using the compiled modified code and the plurality of binary libraries.

Abstract: The creation of an application for any mobile appliance, for example Apple's iPhone, requires several elements to be present at compile time. In the Apple example of an enterprise application where an entity wishes to develop applications internally for its staff, two of these elements are the source code and a digital certificate. These must be combined in the compiler so that the application may be properly authorized to run in the appliance. Where the owner of the source code and the owner of the digital certificate are not the same, serious concerns arise because each element must be secured. An intermediating system and method are described that allows each party to cooperate securely through a third party escrow service to produce the complied application while leaving no unwanted residue of the independent parts.

Abstract: Synchronizing real and virtual software environments. A first input of an entity identifier that identifies a software development entity and a second input of an operation identifier that identifies a software development operation that has been performed on the entity in a physical environment are received. The entity identifier and the operation identifier are on a first and second physical medium, respectively. The entity and the operation are identified in response to receiving the inputs. A virtual software development environment is updated to reflect that the operation has been performed on the entity in the physical environment. The entity and the operation are associated with a software development model that is also associated with the virtual environment.

Abstract: During a first execution of software, historical data is logged that indicates which locale objects were used. During a second execution of the software, the historical data is read, and locale objects or subsections of locale objects are dynamically built from locale source files based on the historical data in the log that indicates which locale objects were used during the first execution. Any other locale objects or subsections that are needed that are not built initially during the second execution are dynamically built from locale source files when requested at run-time. Dynamically building locale objects or subsections based on which locale objects were used in one or more previous executions saves time that would otherwise be required to build the locale objects when they are needed at run-time. The result is significant savings in system-wide resources while still allowing for access to a large number of possible locales.

Abstract: During a first execution of software, historical data is logged that indicates which locale objects were used. During a second execution of the software, the historical data is read, and locale objects or subsections of locale objects are dynamically built from locale source files based on the historical data in the log that indicates which locale objects were used during the first execution. Any other locale objects or subsections that are needed that are not built initially during the second execution are dynamically built from locale source files when requested at run-time. Dynamically building locale objects or subsections based on which locale objects were used in one or more previous executions saves time that would otherwise be required to build the locale objects when they are needed at run-time. The result is significant savings in system-wide resources while still allowing for access to a large number of possible locales.

Abstract: Disclosed are systems, methods and computer program products for efficient and reliable analysis, optimization and detection of obfuscated malware. One disclosed example method for malware detection includes loading an executable software code on a computer system and disassembling the software code into an assembly language or other low-level programming language. The method then proceeds to simplifying complex assembly instructions and constructing a data flow model of the simplified software code. The dependencies and interrelations of code elements of the data flow model are analyzed to identify obfuscated software codes therein. The identified obfuscated codes are then optimized. Based on the results of optimization, determination is made whether the software code is malicious and/or whether further antimalware analysis of the optimized software code is necessary.

Abstract: A method is provided for providing consistent logical code across specific programming languages. The method incorporates preprocessor macros in a source computer program code to generate a program control flow. The preprocessor macros can be used to describe program control flow in the source programming language for execution in the source computer program code. The preprocessor macros can also be used to generate control flow objects representing the control flow, which converts the source computer program code into a general language representation. The general language representation when executed is used to output computer programming code in specific programming languages representing the same logical code as that of the source computer program code.

Abstract: In one example, a device includes one or more processors configured to determine an allocated time for execution of an optimization pass for optimizing code for a software program, execute at least some instructions of the optimization pass on the code, and, in response to determining that an actual time for execution of the optimization pass has exceeded the allocated time for execution, preventing execution of subsequent instructions of the optimization pass.

Abstract: A method and an apparatus to execute a code with value profiling are described. The code may include an access to an untyped variable. During the execution, runtime values of the untyped variable may be randomly inspected. A value profile may be established to predict one or more expected types of future runtime values for the untyped variable. The code may be recompiled according to the value profile to optimize the access of the untyped variable for the future runtime values.

Abstract: A method, computer, and computer program for speculatively optimizing a code. The method includes speculatively optimizing the code characterized by searching in a predetermined order in at least one dictionary; extracting a value associated with a symbol name from a dictionary using the symbol name as a key; performing optimization to replace a symbol in the code with the value; compiling the code to be compiled including some or all of the optimized code; comparing, in response to detection of a change related to one dictionary among at least one dictionary, an order m in the predetermined order of the dictionary with the detected change to an order n of the dictionary with the extracted value; and invalidating the optimized code in the compiled code associated with the dictionary having the detected change in response to the results from the orders comparison and the type of change.

Abstract: Methods and systems for processing computer code modules in order to avoid polluting the global namespace. According to one embodiment, the system or method comprises a server that receives a request for an additional computer code module to be added to the namespace. Prior to delivering the module, the server processes the module by identifying all references to global symbols that are not to be explicitly exported to a global scope and moving the identified symbols to a synthetic namespace prior. The server further wraps the processed module in a function that receives the synthetic global scope as a parameter, and delivers the wrapped module to the requesting namespace.

Abstract: Techniques are described for unifying static and dynamic compiler optimizations in source code bases. In an embodiment, a first compiler compiles source code of a target function to generate ahead-of-time (AOT) compiled machine code. A second compiler compiles the source code to generate an intermediate representation (IR) of the target function. In response to determining that the target function should be just-in-time (JIT) compiled, the AOT-compiled machine code for the target function is linked to the IR of the target function. During runtime, a physical processor executes AOT-compiled machine code of an executable program. When the target function is encountered for the first time, a JIT compiler is invoked. The JIT compiler generates JIT-compiled machine code for the target function. The physical processor executes the JIT-compiled machine code in place of the AOT-compiled machine code for the target function.

Abstract: A system, method, and computer-readable medium for static analysis of large-scale computer programs that uses a compiler to shard the computer programs by source files. Original compilation information is received for one or more groups of source files that reference modules in module containers. The compiler is run to determine a set of modules in the module containers and other source files that are referenced by a source file of the groups of source files. The compilation information is modified on the basis of the source file, the set of modules and the referenced source files. Static analysis is performed on the source file using the modified compilation information. Static analysis is efficiently performed over large-scale computer programs.