Abstract: The present invention relates to a method of preventing sensitive data received via a remote access protocol from being output to a human operator. The method comprises receiving, from a remote server via a remote access protocol, a user interface of an application executing on the remote server; receiving, from the remote server, a text-based representation of the application; identifying sensitive data in the user interface and/or the text-based representation of the application using one or more preselected filters; modifying the user interface to remove the identified sensitive data; outputting the modified user interface to one or more output peripherals of a computer for receipt by the human operator.

Abstract: A single asynchronous enumerable object is generated that contains the data and methods needed to iterate through an enumerable asynchronously. The asynchronous enumerable object contains the code for traversing the enumerable one step at a time and the operations needed to suspend an iteration to await completion of an asynchronous operation and to resume the iteration upon completion of the asynchronous operation. The allocation of a single object to perform all of these tasks reduces the memory consumption needed to execute an asynchronous enumeration.

Abstract: A computationally-efficient object conversion system maintains multiple objects. Each object includes an array of characters and a hash value. Instructions include maintaining strings in a one-to-one relationship with the objects. The instructions include, for each object, calculating the hash value in response to values being written to the array of the object. The instructions include defining an equals method that, for first and second objects, returns a true value in response to values of the array of the first object matching values of the array of the second object. The instructions include defining a hash method that, for a selected object, returns the hash value. The instructions include, in response to a request including a request string, determining whether one of the strings is equal to the request string and, if so, returning the object related to the one of the strings.

Abstract: Systems, computer instructions and computer-implemented methods are disclosed for implementing space- and time-efficient enumerations. An instance of an enumeration class may be created with a constant, plurality of enumerations. A plurality of objects corresponding to the respective enumerations may be stored in memory along with a lookup table indexed by respective ordinal values of the plurality of enumerations, the lookup table including respective references to the stored objects of the instantiated enumeration class. A reference to an enumeration may be stored in a memory location by storing an ordinal value of the enumeration. A determination may then be made to convert a stored ordinal value to a reference to an object, and responsive to the determination, the ordinal value may be loaded and used as an index into the lookup table to obtain the reference to the object corresponding to the enumeration.

Abstract: A cognate specification system manages and enforces digital, canonical representations of entities that are added to and in the system by creating a composite entity key (“EntityKey”) that uniquely and immutably identifies each entity within the system, and that is created based upon the attributes of the entity rather than being arbitrarily assigned. Entities may be organized into various types or cognates, each associated with distinct sets of attributes. A physical or digital referent may be added to the system as an entity by specifying attributes. In such a system, any entity, whether a physical or digital referent, a process, or other type, is uniquely and verifiably identifiable, and may be linked to or associated with other entities, allowing users of the system to produce and access specification granularity beyond traditional approaches focused on systems interoperability.

Abstract: Provided is a process including: writing, with a computing system, a first plurality of classes using object-oriented modelling of modelling methods; writing, with the computing system, a second plurality of classes using object-oriented modelling of governance; scanning, with the computing system, a set of libraries collectively containing both modelling object classes among the first plurality of classes and governance classes among the second plurality of classes to determine class definition information; using, with the computing system, at least some of the class definition information to produce object manipulation functions, wherein the object manipulation functions allow a governance system to access methods and attributes of classes among first plurality of classes or the second plurality of classes to manipulate objects of at least some of the modelling object classes; and using at least some of the class definition information to effectuate access to the object manipulation functions.

Abstract: Embodiments are directed to improving boot process for early display initialization and visualization. An embodiment of a system includes a plurality of processor cores; a cache coupled to the plurality of processor cores; and a controller circuit to: initialize a portion of the cache as static memory for hardware initialization code usage before beginning execution of the hardware initialization code after a power on of the hardware processor; and cause initialization of a display device to be performed using the portion of the cache, the initialization of the display device performed independently of initialization of dynamic memory of the hardware processor.

Abstract: A search apparatus causes a first learning process using a first sample size and a first hyperparameter value to be executed, and causes a second learning process using the first sample size and a second hyperparameter value to be executed. When a third learning process using a second sample size larger than the first sample size and the first hyperparameter value has not been executed, the search apparatus calculates total resources associated with the first sample size based on resources used by the first and second learning processes. If the total resources exceed a threshold, the search apparatus allows the third learning process to be executed. If the total resources are equal to or less than the threshold, the search apparatus withholds the execution of the third learning process, and allows a fourth learning process using the first sample size or smaller and a third hyperparameter value to be executed.

Abstract: Memory is partitioned and isolated in container-based memory enclaves. The container-based memory enclaves have attestable security guarantees. During provisioning of the container-based memory enclaves from a container image, a purported link in the container to a memory address of the enclave is modified to verifiably link to an actual memory address of the host, such as partitioned memory enclave. In some instances, enclave attestation reports can be validated without transmitting corresponding attestation requests to remote attestation services, based on previous attestation of one or more previous container attestation reports from a similar container and without requiring end-to-end attestation between the container and remote attestation service for each new attestation request.

Abstract: Methods, computer readable media, and devices for rapid prototyping of both user experience and technical features in a combined approach. One method may include creating a set of known user experience (UX) components including a user interface element representing at least one of a data element and a data interaction, creating a UX screen including a set of UX elements within a UX prototyping tool, translating the UX screen into a set of standardized UX components, publishing the set of standardized UX components by mapping the set of standardized UX components to synthetic data, and validating a technical aspect of the published set of standardized UX components based on user interaction with the published set of standardized UX components.

Abstract: Arrangements for automatically implementing bucket policy management making it automatic that all affected members are always completely and consistently informed of changes to a policy code as they occur, and making it automatic that a complete and accurate historical record is maintained regarding all policy code changes as they occur over time.

Abstract: A system and method for establishing application identities including application runtime properties. A method includes signing at least one artifact of a first application communicating with a second application, wherein each of the at least one artifact includes data used for executing the first application, wherein a signing result of each artifact is a signed cryptographic hash of the artifact; monitoring events related to communications between the first application and the second application to identify a file event; generating at least one runtime hash for the file event, wherein the at least one runtime hash represents runtime properties of the first application; and generating an application identity for the first application, the application identity for the first application including the signed cryptographic hash of each of the at least one artifact and the at least one runtime hash of the file event.

Abstract: A method is provided for determining command-to-process correspondence. The method includes identifying, by the hardware processor, initial processes resulting from executions of container immutability change events for each of multiple containers in a cluster, based on an execution time, a process identifier and a process group identifier for each of the container immutability change events. The method further includes checking, by the hardware processor, if an initial process from among the identified initial processes matches an entry in a database that stores external container commands and at least one respective process resulting from executing each of the external container commands.

Abstract: Methods for intelligent automatic merging of source control queue items are performed by systems and apparatuses. Project changes are submitted in build requests to a gated check-in build queue requiring successful builds to commit changes to a code repository according to source control. Multiple pending build requests in the build queue are intelligently and automatically merged into a single, pending merged request based on risk factor values associated with the build requests. For merged requests successfully built, files in the build requests are committed and the build requests are removed from the queue. Merged requests unsuccessfully built are divided into equal subsets based on updated risk factor values using information from the unsuccessful build. Successful builds of subsets allow for committing of files and removal from the build queue, while unsuccessful builds are further divided and processed until single build requests are processed to identify root cause errors.

Abstract: Various embodiments of the present technology generally relate to methods and systems for providing a flexible, updatable, and backward compatible programmable logic controller (“PLC”) and instruction set library. The instruction set library in the PLC can be updated without downtime of the PLC or the machines controlled by the PLC. The instruction set library is decoupled from the PLC firmware and bound via an API so that instructions in the executable code are bound to the firmware such that updates to the instruction set library can happen between scans of the executable without requiring the firmware be updated. Further, the instruction set library may be partitioned to limit updates and the amount of the complete instruction set library that is stored on the PLC to only those used by the PLC.

Abstract: An embodiment performs escape analysis of a function as a compiler optimization and stack-allocates an object referenced by the function. At runtime, the embodiment includes detecting a hot code replacement of a portion of the function while the referenced object is stored in stack memory. Responsive to detecting the hot code replacement, the embodiment includes allocating heap memory for the object and moving the object from the stack memory to the allocated heap memory. The embodiment also updates references to the object that were pointing to the object in the stack memory to instead point to the object in the heap memory.

Abstract: Techniques for inferring code deprecation from module deprecation are disclosed. A system detects a reference to a type. The system determines that a particular module, in a plurality of modules in a module system, exposes the referenced type. The system determines that the particular module is associated with a deprecation status. Responsive to determining that the particular module is associated with the deprecation status, the system presents information indicating that the reference references a deprecated module.

Abstract: Systems and methods are disclosed for improving data modeling and translating. The system receives network-related data from external systems, wherein the data is formatted in various modeling languages corresponding to the system or network components from which it is transmitted. The system parses and extracts the network-related data for identifying parameters within the data, wherein the parameters correspond to the system or network component's operational status. The system translates the extracted data to a human-readable format for displaying the data to a system user and allowing the user to modify or provide additional parameters. The system generates a new instance of the network-related data including the user-provided parameters, wherein the new instance is translated into a format in accordance with the modeling language of the initially received network-related data.

Abstract: Technologies for storing and accessing data from persisted data objects of an object-oriented system are provided. The disclosed techniques include a system that receives, a first request to perform an operation on data of data objects, where the data objects are capable of being persisted in a database. The system generates a second request by translating the first request from a first programming language to a second programming language. The system uses an object relational mapping data structure, which maps data object attributes to database properties, to map the second request parameters to corresponding database operation parameters. The system generates one or more database requests based on the corresponding database operation parameters and causes the one or more database requests to be executed on the database. The disclosed techniques describe creating and running a RESTful microservice to persist JSON objects in a relational database.

Abstract: In one approach, a method comprises: a virtual machine receiving an invocation instruction from a caller that invokes a callee, wherein the caller represents a first set of instructions and the callee represents a second set of instructions, wherein the invocation instruction is associated with a first set of arguments; in response to receiving the invocation instruction and determining that the callee requires one or more additional parameters to be supplied by the virtual machine, the virtual machine causing the one or more additional parameters to be appended to the first set of arguments to create a second set of arguments; wherein the virtual machine prevents the caller from providing the one or more additional arguments that are to be supplied by the virtual machine; the virtual machine invoking the callee using the second set of arguments.

Abstract: The techniques described herein may provide techniques to detect, categorize, and diagnose synchronization issues that provide improved performance and issue resolution. For example, in an embodiment, a method may comprise detecting occurrence of synchronization performance problems in software code, when at least some detected synchronization performance problems occur when a contention rate for software locks is low, determining a cause of the synchronization performance problems, and modifying the software code to remedy the cause of the synchronization performance problems so as to improve synchronization performance of the software code.

Abstract: According to examples, an apparatus may include a processor and a computer readable medium on which is stored machine readable instructions that may cause the processor to assign the activities in user activity data into a plurality of groups based on common user identifiers corresponding to the pairs of activities. The instructions may also cause the processor to determine a correlation between a user event and the plurality of groups, determine whether the user event is suspicious based on the determined correlation, and based on a determination that the user event is suspicious, output an indication that the user event is suspicious.

Abstract: A computer-implemented method that includes receiving source code for a user interface program, generating, using the source code, the user interface program, generating, using the source code, a faux backend program, and generate, using the source code, a skeleton Application Programing Interface (API) file is disclosed. The user interface program and the faux backend program are capable of operating together as part of a test build. The skeleton API data provides a specification for an interface of production software suitable for replacing the faux backend, the specification including respective specifications for a plurality of API calls.

Abstract: Memory is partitioned and isolated in container-based memory enclaves. The container-based memory enclaves have attestable security guarantees. During provisioning of the container-based memory enclaves from a container image, a purported link in the container to a memory address of the enclave is modified to verifiably link to an actual memory address of the host, such as partitioned memory enclave. In some instances, enclave attestation reports can be validated without transmitting corresponding attestation requests to remote attestation services, based on previous attestation of one or more previous container attestation reports from a similar container and without requiring end-to-end attestation between the container and remote attestation service for each new attestation request.

Abstract: In accordance with an embodiment, described herein is a system and method for providing support for custom hooks during patching in an application server, enterprise, cloud computing, or other computing environment. A patch orchestration engine generates a patching workflow including a series of steps that apply patches to update one or more targeted nodes in a controlled manner with minimal downtime. Custom hooks provide a flexible mechanism that enables modifying phases of the patching workflow that can be associated with extension points. When an extension, for example an additional Java software code, script or other command, is specified to be run at a particular extension point associated with a particular phase of a patching workflow, the patch orchestration engine causes the extension to be inserted into the patching workflow, for execution during patching of the targeted nodes, to modify that phase of the patching workflow.

Abstract: A method and a system for garbage collection on a system. The method includes initiating a garbage collection process on a system by a garbage collector. The garbage collector includes one or more garbage collector threads. The method also includes marking a plurality of referenced objects using the garbage collector threads and one or more application threads during a preemption point. The method includes replicating the referenced objects using the garbage collector threads and marking for replication any newly discovered referenced objects found by scanning the application thread stack from a low-water mark. The method also includes replicating the newly discovered referenced objects and overwriting any reference to the old memory location.

Abstract: A computer-implemented method that includes receiving source code for a user interface program, generating, using the source code, the user interface program, generating, using the source code, a faux backend program, and generate, using the source code, a skeleton Application Programing Interface (API) file is disclosed. The user interface program and the faux backend program are capable of operating together as part of a test build. The skeleton API data provides a specification for an interface of production software suitable for replacing the faux backend, the specification including respective specifications for a plurality of API calls.

Abstract: The present invention relates to methods for operating a respiration apparatus and a respiration system, and also a respiration apparatus and a respiration system. The respiration system comprises a respiration apparatus and a computer software program for an external computer to operate the respiration apparatus. The respiration apparatus comprises a processor device and an apparatus software program and an apparatus configuration. The validities of the computer software, the apparatus software and the apparatus configuration are in each case characterized by a version. The versions are compared with one another to detect a version conflict. If invalid versions are present, the computer software is provided with a program component with a limit value and a plausibility rule, or the setting parameters are sorted into a first group and a second group. The setting parameters of the first group are retained.

Abstract: A computer-implemented method for automated test script generation for application testing, more particularly for testing one or more functions of Application Under Test (AUT) where, in operation, a test case flow sequence is ascertained, including a data list defining one or more methods, where each method is further representative of an automation code corresponding to a manual step of the test case, and a test class for testing a function of AUT is generated using the test case flow sequence if each of the one or more methods are available in the framework, such that the disclosure provides for generating a test class for testing the function of AUT by automatically generating the one or methods if the methods are not available in the framework.

Abstract: Methods, systems, and devices for fast partial scalarization are described. A device may generate a representation of a set of vectors and a set of vector instructions associated with the set of vectors. The device may determine information associated with a vector in the set of vectors based on the representation, the information including an indication of splitting the vector and splitting one or more vector instructions associated with the vector. In some aspects, the device may associate the vector to one or more other vectors in the set of vectors based on one or more vector instructions related to the set of vectors. The device may update the information based on the associating and generate partially scalarized instructions based on the updating. The device may generate the partially scalarized instructions by excluding a subset of vector instructions and generating additional subsets of vector instructions and scalar instructions.

Abstract: One or more processors of a computing device may receive, from an external computing device, a first one or more application elements of a plurality of application elements of a first application that is to be installed at the computing device. The one or more processors may further obtain from a second application that is installed at the computing device, a second one or more application elements of the plurality of application elements of the first application that is to be installed at the computing device. The one or more processors may further install, using the first one or more application elements and the second one or more application elements, the first application at the computing device.

Abstract: Embodiments of the present invention disclose a method, computer program product, and system for class splitting in object-oriented environments in which objects are created by classes. Data is analyzed, in response to generating an instance of an original class in a code component. Fields are separated into sets based on the code paths that access the fields. A split class is generated for a set of fields which shares a common interface with the original class. Cells are replaced in the code component to the original class with a split class.

Abstract: A method including receiving designation of an input node for which a node value is generated from collected data, an option node to which a node value is arbitrarily provided, and an estimation target node to be a target of a node value estimation, in a graph including nodes and directional edges; and identifying a directional edge for which a conditional probability is to be acquired to measure the node value of the estimation target node, from among the directional edges, by traversing a directional edge that can propagate an effect to a node value from the estimation target node. The identifying includes, for the option node, traversing both a directional edge that can propagate an effect if a node value is provided to the option node and a directional edge that can propagate an effect if a node value is not provided to the option node.

Abstract: A computer-implemented method comprises receiving source code for a user interface program, generating, using the source code, the user interface program, generating, using the source code, a faux backend program, and generate, using the source code, a skeleton Application Programming Interface (API) file. The user interface program and the faux backend program are capable of operating together as part of a test build. The skeleton API file provides a specification for an interface of production software suitable for replacing the faux backend, the specification including respective specifications for a plurality of API calls.

Abstract: A session filtering method including displaying session page entries corresponding to at least a part of communication sessions in which a user at a local end participates via a preset communication application, presentation areas of the session page entries containing filterable labels associated with corresponding communication sessions; when a filterable label is triggered, filtering one or more communication sessions associated with the filterable label from communication sessions corresponding to the displayed session page entries; and presenting one or more session page entries corresponding to the filtered communication sessions to the user at the local end. Through the technical solution of the present disclosure, a communication session is quickly filtered and found, which is conducive to improve communication efficiency.

Abstract: A software development environment supports grammatical-number enforcement on the names of different data types. The development environment, a computer system that programmers use to create and maintain a computer program, employs a namespace of symbolic names that are unique within a set of expressions available to the program. A type checker ensures that each name identifying an expression in a namespace does not have more than one data type. Thus, for instance, the variable “chair” cannot be both an integer and a character string. A grammatical-number enforcer with access to a dictionary enforces a naming convention within the namespace that groups grammatical-number name variants by data type to reduce type errors and thus speeds up the development environment.

Abstract: Devices and techniques for host adaptive memory device optimization are provided. A memory device can maintain a host model of interactions with a host. A set of commands from the host can be evaluated to create a profile of the set of commands. The profile can be compared to the host model to determine an inconsistency between the profile and the host model. An operation of the memory device can then be modified based on the inconsistency.

Abstract: Systems, methods, and devices of various embodiments may receive first and second text strings for performing a symmetric text replacement. An original recitation of the first or second text strings may be located, wherein at least one intervening other text string is disposed between the first and second text strings. Each original recitation of the first text string may be replaced with a substituted recitation of the second text string in response to determining the located original recitation of the first and second text strings matches the first text string. Similarly, each original recitation of the second text string may be replaced with a substituted recitation of the first text string in response to determining the located original recitation of the first and second text strings matches the second text string.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for constructing and processing computational graphs that represent dynamically structured machine learning models are disclosed. An example system receives data identifying a plurality of operations that can be performed on input data for processing by a dynamically structured machine learning model. The system also receives a plurality of labels corresponding to arguments for the plurality of operations. A directed computational graph representing a comprehensive layer of the dynamically structured machine learning model is generated from the identified operations and labels. An example system then receives an input for processing by the machine learning model and specifies data flow through the directed computational graph.

Abstract: Methods, systems, and computer-readable media for providing a virtualization layer for mobile applications are presented. A computing device may parse code of an application to identify a first set of one or more classes in the application. The computing device may transmit code usable by the first set of one or more classes to a module accessible to the application and create a second set of one or more classes in the application to replace the first set of one or more classes, wherein the second set of one or more classes does not inherit from the first set of one or more classes in an object hierarchy. In some embodiments, the second set of one or more classes provides at least one different function from the first set of one or more classes. The computing device may execute the application comprising the second set of one or more classes.

Abstract: Computer-implemented techniques described herein provide efficient data decoding using runtime specialization. In an embodiment, a method comprises a virtual machine executing a body of code of a dynamically typed language, wherein executing the body of code includes: querying a relational database, and in response to the query, receiving table metadata indicating data types of one or more columns of a first table in the relational database. In response to receiving the table metadata: for a first column of the one or more columns, generating decoding machine code to decode the first column based on the data type of the first column, and executing the decoding machine code to decode the first column of the one or more columns.

Abstract: Computing systems, database systems, and related methods are provided for supporting dynamic validation workflows. One exemplary method involves a server of a database system receiving a graphical representation of a validation process from a client device coupled to a network, converting the graphical representation of the validation process into validation code, and storing the validation code at the database system in association with a database object type. Thereafter, the validation process is performed with respect to an instance of the database object type using the validation code in response to an action with respect to the instance of the database object type in a database of the database system. The action triggering the validation process can be based on user-configurable triggering criteria, and the validation process may generate user-configurable notifications based on one or more field values of the database object instance.

Abstract: A collaborative content management system allows users to create, edit, and share collaborative content items among a plurality of other users. The system enables a collaboration event between author client devices and recipient client devices. During a collaboration event, a collaborative content item is created by an author. The collaborative content item is converted into a model collaborative content item and stored in the collaborative content management system. Access to the model collaborative content item is shared with recipient client devices. A derivative copy of the collaborative content item is generated based on the model collaborative content item, for instance in response to a request from a user of a recipient client device. The created derivative collaborative content items are editable by users corresponding to the derivative collaborative content item such that edits made to a first derivative collaborative content item are not accessible to other derivative collaborative content items.

Abstract: Techniques for managing multi-container builds are described herein. A software build task description specifies a build environment and the build environment specifies a set of parameters for building a version of a software object. A container is instantiated that corresponds to the build environment and build commands are sent to the container. As the container completes the build command, it sends a response that is used to determine a second command to send to the container. A status of the software build task is provided based at least in part on the response.

Abstract: A system and method can support compatibility checking in a programming language environment. The programming language environment can check whether a target type associated with an expression in the programming language environment is functional, wherein the target type is functional when it has exactly one method meeting one or more criteria that define that method as relevant in a counting system. Then, the programming language environment can derive a function descriptor from the target type, which is context-dependent. Furthermore, the programming language environment can type-check the expression with the function descriptor associated with the target type.

Abstract: A hostable compiler interacts with a host application to enable the host application to execute program code supported by the hostable compiler. The host application and the hostable compiler exchange data through an interface that allows the hostable compiler to receive type information pertaining to data elements used applications executing within the host application process. This type information may then be used by the hostable compiler in the compilation of source code to infer a type for data elements used in the source code that are not declared yet associated with a value of an expression used in an application executed within the host application process.

Abstract: According to some illustrative embodiments of the invention, a method is performed that includes using a representation of a computer software program, using identified addresses which correspond to a part of the representation, and converting the representation into a created binary program, which includes reserving spaces at the identified addresses in the created binary program's address space at the same addresses as the identified addresses in the representation.

Abstract: Disclosed are the details about our computer system based software, and dedicated server system. The software is composed of a physics engine created with C++, and blueprinting techniques used to create an online web development platform. The physics engine acts as a base system on the computer that greatly enhances the features of a contemporary html, or java website. This system allows us to create more tools within a 3d metaverse, that is simple to use, and solves the 2d traditional website only problem in the internet. The invention has a wide variety of functions that allow 3d objects to be placed inside of the metaverse; customizing the site with a plethora of features including, color, material, images, and shape.

Abstract: A method and system provides for asynchronous two-way binding between a user interface and a data model which are implemented on different frameworks. The system includes data, data model, and bridge controllers. The data controller provides a front-end binding framework that interacts with a user interface of a user device to manage a bindable property or method for a view on the user device. The data model controller provides a back-end binding framework that manages a data model, the front-end binding framework and the back-end binding framework being different types of frameworks. The bridge controller implements asynchronous two-way binding for the bindable property or method between the front-end binding framework and the back-end binding framework to update the bindable property or method in the data model when data changes at the user interface and to update the view on the user device when data changes at the data model.

Abstract: Customizations, made at various levels in the customization channel, are saved as separate sets of customization deltas that are applied to a base computing system in order to generate a given solution. In a multi-tenant environment, groups of tenants access different solutions or customization deltas. The tenants are automatically grouped, based upon the solution or customization deltas that they access, and the deltas for those customizations are applied to the base system at runtime, for each group.