Abstract: Technology is described for receiving time series data to be transmitted to a server. A network connectivity problem may be determined to exist for a computer network with the server which prevents the time series data from being transmitted to the server. A downsampling function may be applied to the time series data to produce reduced granularity data points that represent an approximation of the time series data to be transmitted to the server after the network connectivity problem has occurred with the server. The reduced granularity data points may be transmitted to the server.

Abstract: A resource dependency system may track data dependencies and data transformations for individual columns of the data sets over the span of the data pipeline (referred to as a provenance or lineage of a column). Column provenance/lineage can be logged using metadata or graph-like data structures, which the resource dependency system can generate, store, manage, and access. Column provenance/lineage can be used to generate user interfaces displaying visual node graphs with columns as nodes and the data dependencies and data transformations associated with the columns as edges between the nodes.

Abstract: Methods, systems, and computer program products are included for incorporating functionalities of a version control system into a package manager. An example method includes providing to a package manager a source file path corresponding to a source. A software version control system corresponding to the source is determined from the source file path. A command translation driver corresponding to the software version control system of the source is loaded by the package manager. The loaded command translation driver translates a package manager command to a corresponding command of the software version control system. The translated package manager command is executed by the package manager.

Abstract: In general, the disclosed technology relates to a method for generating a web application. The method includes selecting a webpage in the web application and implementing a custom user interface (UI) action on the webpage. Implementing the custom UI action on the webpage may include creating a hidden component on the webpage, associating a custom UI action with the hidden component, specifying at least one input for the hidden component based on the custom UI action, specifying at least one target output for the hidden component based on the custom UI action, and associating the hidden component with a custom UI action trigger event. The method further includes deploying the web application after implementing the custom UI action on the webpage.

Abstract: A process receives, via a processor, a software application model. Further, the process determines, with the processor, one or more core operations to be performed by a software application to be built. The one or more core operations are based on the software application model. Additionally, the process generates, with the processor, one or more functionality criteria based on the one or more core operations. Moreover, the process generates, with the processor, one or more device-specific graphical user interfaces corresponding to each of a plurality of devices that implement the software application to be built according to the one or more functionality criteria. Finally, the process generates, with the processor, the software application based on the one or more core operations, the one or more functionality criteria, and the one or more device-specific graphical user interfaces.

Abstract: An electronic mail (email) system generates an email user interface display, with a timeslot actuator, for composing an email message. Actuation of the timeslot actuator is detected and the email system accesses available timeslots from a calendar system corresponding to the user. User selectable display elements, corresponding to each available timeslot, are displayed on the email user interface display, along with message content. When a user selectable display element corresponding to an available timeslot is selected, the email message content is populated with a selectable timeslot element, corresponding to the available timeslot, that can be sent to recipients in the email message.

Abstract: A test automation platform may receive a test case for testing a data ingestion pipeline. The test automation platform may determine a test intent of the test case using a test intent identification model. The test automation platform may determine a type of entity associated with the data ingestion pipeline that the test case is to test using a test entity identification model. The test automation platform may generate a prediction of a data ingestion scenario for which the test case is to be applied based at least in part on the test intent of the test and the type of entity. The test automation platform may generate a mapping file representing the prediction of the data ingestion scenario. The test automation platform may execute, using test cases of the mapping file, a set of tests on a new data ingestion pipeline.

Abstract: Techniques for privilege escalation protection are disclosed. In some embodiments, a system/process/computer program product for privilege escalation protection includes monitoring a process executed on a computing device, detecting an unauthorized change in a token value associated with the process, and performing an action based on a policy (e.g., a kernel protection security policy/rule(s), which can include a whitelisted set of processes and/or configured actions/responses to perform for other/non-whitelisted processes) in response to an unauthorized change in the token value associated with the process.

Abstract: A computing device receives template files and parameters associated with the template files, where the template files comprise scripts, and where the associated parameters comprise a user preference associated with an efficiency of the image. The computing device may determine dependencies between layers of the scripts based on a unified image model. The unified image model may generate a logic tree that includes nodes, where each one of the nodes represents each one of the layers of the scripts. The computing device may generate an efficient logic tree based on the logic tree and the user preference of a generated image model. The generated image model may generates the efficient logic tree by changing the dependencies of the nodes in the logic tree based on the user preference. Based on the generated efficient logic tree the computing device may build the image.

Abstract: Described embodiments provide a method, computer program product, and computer system for generating, by a computing device, a data file including at least one property from a first cascading style sheet (CSS) file, the at least one property defining a scripting language object. A scripting language file may be generated, the scripting language file may include a scripting language variable for the scripting language object. A second CSS file may be generated by replacing the at least one property from the data file with the scripting language variable of the scripting language file. An element of a webpage referenced by the scripting language object may be rendered based upon, at least in part, the scripting language variable of the second CSS file.

Abstract: Disclosed herein are techniques for identifying software dependencies based on functional line-of-code behavior and relation models. Techniques include accessing a first line-of-code behavior and relation model representing execution of functions of a first portion of executable code, the first portion of executable code being associated with a first symbol; detecting a change to the first portion of executable code; constructing, based on the changed first portion of executable code, a second line-of-code behavior and relation model representing execution of functions of the changed first portion of executable code; determining, based on the constructed second model, a dependency between (i) the changed first portion of executable code or the first symbol and (ii) a second symbol; and generating, based on the determined difference, a report identifying the dependency.

Abstract: The technology disclosed relates to causing delivery of Segmentation as a Service™ (SegAAS) instrumentation code and segment processing code to run on a user's machine and generate data that tracks a user session on a website, receiving and processing data from the user session and invoking callback function code, configured to run on the user's machine, that performs actions specified by the website's operator, as triggered by delivery of segment codes. Also included is receiving readings from the user session, analyzing the data to track progress of the session, and generating segment codes that characterize results of the analysis in an actionable way specified by rules provided by the website operator. Further included are repeatedly causing delivery of updated lists of the segment codes based on the analyzing of the progress and timing delivery of unsolicited actions directed to retaining the visitor and extending the user session with the website.

Abstract: A microservice executing in a distributed computing system may receive a request to delete a target object stored in the distributed computing system. The microservice may identify dependent objects for the target object using information received in the request. The microservice may generate a new object that includes the data from the target object and the data from the one or more dependent objects. The new object may be stored in the distributed computing system, and the target object may be removed from the distributed computing system.

Abstract: The current document is directed to an automated-application-release-management subsystem that executes application-release-management pipelines that includes one or more tasks and/or stages, execution of which launch execution of scripts on specified host computers. The capability for launching scripts from application-release-management-pipeline tasks and stages provides flexibility in design and development of application-release-management pipelines and provides an incremental path for migration of legacy-script-based application-release management to automated pipeline-based application-release management.

Abstract: The disclosure generally describes methods, software, and systems for using open APIs. API and event information is received from plural API providers. The API and event information for each API provider is received in a format specific to the API provider. An open API format version of the API and event information is created for the API and event information of each API provider. The open API format version is stored in an open API format that provides a common ontology for expressing information about APIs and events available from the plural API providers. The open API format version of the API and event information is published.

Abstract: Methods and apparatuses are described for enforcing referential integrity of database columns across a plurality of tables in a database. A server periodically captures a database schema comprising relationships between a primary key column in a first table and a foreign key column in a second table. The server executes a first procedure call to determine a discrepancy between the primary key column and the foreign key column with respect to a data length value or a data type value. The server executes database queries against data in the first table or second table to confirm the discrepancy. The server executes a second procedure call to change the data length value or the data type value. After the second procedure call finishes, the data length value and the data type value of the primary key column and the foreign key column match.

Abstract: Systems and methods of network-based learning models for natural language processing are provided. Information may be stored information in memory regarding user interaction with network content. Further, a digital recording of a vocal utterance made by a user may be captured. The vocal utterance may be interpreted based on the stored user interaction information. An intent of the user may be identified based on the interpretation, and a prediction may be made based on the identified intent. The prediction may further correspond to a selected workflow.

Abstract: According to some embodiments, system and methods are provided comprising receiving, via a communication interface of a platform comprising a segmentation module and a processor, a defined geometry for one or more geometric structures forming one or more parts, wherein the parts are manufactured with an additive manufacturing machine; generating a build file including an initial parameter set to fabricate each part; fabricating the part based on the build file; receiving sensor data for the fabricated part; generating a parameter set for each layer that forms the part, via execution of an iterative learning control process for each layer; generating raw power data for each layer that forms the part, using the processor, based on the generated parameter set; applying a noise reduction process to the raw power data; and generating a segmented build file, using the segmentation module, via application of the noise reduction process on the raw power data. Numerous other aspects are provided.

Abstract: A continuous integration and delivery (CID) pipeline may deploy code in a state of incomplete testing to at least one user. While the code is deployed, a callback address manager of at least one processor in communication with the CID pipeline may hand the code off to a simulation manager of the at least one processor. The simulation manager may test the code and generate a score decision based on a result of the testing. The simulation manager may send the score decision to the callback address manager. The callback address manager may modify deployment of the code based on the score decision.

Abstract: In one embodiment, a method comprises creating and storing an ontology for a data store in response to receiving first user input defining the ontology, wherein the ontology comprises a plurality of data object types and a plurality of object property types; creating one or more parser definitions in response to receiving second user input defining the parser definitions, wherein each of the parser definitions specifies one or more sub-definitions of how to transform first input data into modified input data that is compatible with one of the object property types; and storing each of the one or more parser definitions in association with one of the plurality of object property types.

Abstract: Techniques for performing type-constrained operations for plug-in types are disclosed. A runtime environment encounters a request to perform a type-constrained operation that requires evaluating a type constraint associated with a particular plug-in type. The runtime environment lacks sufficient native instructions to evaluate type constraints associated with plug-in types. The runtime environment accesses a plug-in type framework to obtain a particular type descriptor instance associated with the particular plug-in type. The plug-in type framework is designated, prior to encountering any request to perform the type-constrained operation, for obtaining type descriptor instances which define constraints on plug-in types, to an extent that any such constraints exist. The particular type descriptor instance defines a particular type constraint that does not match any single built-in type.

Abstract: A method is provided for orchestrating a workflow. In some embodiments, the method includes executing a workflow including a first controller that includes a first callout function and a first callback function and corresponds to a first microservice. Execution of the workflow includes execution of the first callout function that causes invocation of the first call to the first microservice. The method further includes receiving a notification of an execution state from the first microservice and transmitting the execution state to the first callback function. The method also includes in response to transmitting the execution state to the first callback function, receiving a function output based on the execution state from the first callback function. The method further includes determining, based on the function output, whether to execute a subsequent controller. The method also includes in response to a determination to execute the subsequent controller, executing the subsequent controller.

Abstract: In some examples, a plurality of nodes may each host a respective logical database (LDB) that includes database data that references external resources stored in a storage system. Further, each node may maintain, for each external resource referenced by the respective LDB on that node, a reference count of a number of references in the respective LDB to each external resource and a timestamp associated with the reference count. In response to addition of a reference to a particular external resource in a particular LDB, a node that hosts the particular LDB may be programmed to increment the reference count and update the timestamp for the particular external resource. Similarly, in response to removal of the reference to the particular external resource in the particular LDB, the node hosting the particular LDB is programmed to decrement the reference count and update the timestamp for the particular external resource.

Abstract: An application for dynamic, granular access permissions can include a database interface, a user interface, a login process, an administrator, an event handler and an authorization process. The database interface can be an interface to an access control permissions database that stores roles, actions, or policies for users of the application. The login process can authenticate a user and determine a default set of access control permissions for that user when they are using the user interface. The administrator can provide access control permissions for a user by using the database interface. The event handler can dynamically modify access to functionality in the user interface based on an event. The authorization process can determine whether a request from the user interface is authorized before process the request. The authorization process can use access control permissions from the administrator and either a scope limited or a temporally limited access permission.

Abstract: A multi-user application system environment engine has an application system that, in turn, includes a simulation engine and a virtualized software environment. The simulation engine runs on top of the virtualized software environment and includes a declaration processor, a scene tree object manager, a viewer, an editor listener, and a rendering processor, coupled to the virtualized software environment, to requisition hardware resources to cause physical manifestation of an instantiated scene tree. The viewer presents to the local user a visual representation of the instantiated scene tree in its current state.

Abstract: A container cloud platform that allows software functions to be shared by multiple applications in different application containers is provided. The service functions are containerized and disaggregated from the application containers. The containerized services are delivered as a capsule for applications that invoke the service functions at application runtime. The images of the service containers are deployed at the host computing devices operating the corresponding application containers. The container cloud platform monitors the deployed service containers for their execution as well as their termination.

Abstract: A method, system and computer program product for locating business rules in application source code. Static code analysis is performed on the application source code to collect variable usage and statement information, which is stored in a repository. Variables that are used in conditions and computational statements are identified using the stored information, including determining the usage distribution of these variables in such conditions and computational statements and whether such conditions and computational statements are within copybooks. A score is assigned to these identified variables based on usage and if their usage is shared in copybooks. Those variables with a score exceeding a threshold value are selected to be inserted in a list of business terms. Usage locations of the variables in the list are extracted. The business rules in the application source code containing the logic using these variables are then identified based on the extracted usage locations.

Abstract: While receiving a user input of content of a first document, a computer system, dynamically and in real time, identifies relevant information items from a plurality of information feeds. Specifically, one or more other documents is obtained in a collection of documents that are relevant to the first document being entered by a user. When it is determined that changes in member documents of the set of one or other documents satisfies a stabilization criterion while receiving the user input, related terms are extracted from the content of the first document and the one or more other documents and used to identify the relevant information items including the related terms from the plurality of information feeds that is distinct from the collection of documents. The relevant information items are then presented on a display for the user.

Abstract: A system is described which recognizes patterns or conventions that programmers follow when writing source code and creates a repository for these patterns. The system makes suggestions for variable names based on the stored patterns. The system can suggest variable names that are closest to the convention (e.g., the convention demonstrated by the stored pattern) and alert the programmer when the programmer deviates from the convention.

Abstract: In some examples, a computing device may predict, using a machine learning module, scenarios and transactions associated with a usage of a software package. The computing device may select at least a portion of the scenarios and the transactions to cover a predetermined percentage of a predicted usage of the software package. The computing device may select a subset of unit test cases (e.g., created by software designers to test software units that are components of the software package) and execute the test cases to generate test results to determine whether the software package is ready to be deployed to customers. The computing device may train the machine learning module using at least one of the test results, the portion of the scenarios and the transactions, or the test cases. The test results may be evaluated to determine an effectiveness of the set of test cases.

Abstract: A provisioning system of a first party provisions a mobile software application to one or more remotely-located mobile computing devices, each mobile computing device running a same device-native mobile operating system (OS). The mobile software application comprises an application bundle comprising computer program code and computer code libraries that together comprise at least one component used to: adapt an abstraction layer to the same device-native mobile OS, receive data from said device-native OS, generate modification data objects, process modification data objects, generate a change list of modification data objects, translate modification data objects into a list of instructions for execution, and send a list of instructions to said same device-native operating system for execution.

Abstract: A method for operating a network includes combining modules, which are lower-level service functions of the network, to compose a service, which is a higher-level service function of the network. At least two modules of the modules interact according to a policy for providing and/or monitoring and/or optimizing the service. The modules have an awareness, that includes a location-awareness and/or a proximity-awareness, with respect to at least one other module for deciding and/or varying: the amount and/or kind of interaction between the modules and/or the at least one other module; and/or a location of at least one of the at least one other module and/or the modules, at runtime depending on the awareness of a location and/or a proximity and on the policy.

Abstract: A method of securely executing a Just-In-Time (JIT) compiled code in a runtime environment, comprising using one or more processors for receiving from a JIT executing process a request to compile in runtime a code segment, initiating a JIT compiling process to compile the code segment in order to generate an executable code segment, storing the executable code segment in a shared memory and providing to the JIT executing process a pointer to the executable code segment in the shared memory. Wherein the JIT executing process having read-execute access rights to the shared memory and the JIT executing process and the JIT compiling process are different processes.

Abstract: Techniques for migrating source code to a virtual compute service are described. The migration of source code is assisted by metadata that identifies portions of the source code—for example, one or more classes, methods, functions, subroutines, and so forth—desired to be replicated by one or more virtual compute service functions executing in the virtual compute service. One or more virtual compute service functions are created at the virtual compute service that implement the functionality of the identified portions of source code. The identified source code can be refactored to invoke the corresponding virtual compute service function(s) in the virtual compute service using, for example, application programming interface (API) calls sent over a network to the service provider system. In this manner, the external functional behavior of the source code can remain the same while internally taking advantage of the benefits offered by a virtual compute service.

Abstract: Techniques for serverless performance testing of applications are provided. A user can indicate an application to test within a serverless computing framework. The user can specify parameters for testing the application. A performance test execution file can be generated based on the indicated application and the specified testing parameters. Serverless functions for implementing the testing of the application can be generated based on the performance test execution file. The serverless functions can be executed to implement the testing of the application code on a cloud-based computing resource. Test outputs can be generated and stored for review and analysis in real-time during the testing and after the testing is concluded.

Abstract: An apparatus has a processor and a memory connected to the processor. The memory stores instructions executed by the processor to ingest and store a semi-structured document within a database. A template is suggested based upon an evaluation of the semi-structured document. The template includes a context specification of a template path that corresponds to a path within the semi-structured document. The template further includes an index specification characterizing data to be extracted from the semi-structured document. A template selection is received. The template selection is executed to form an index entry for the semi-structured document within an index.

Abstract: An efficient reusable, extensible light weight framework statelessly orchestrates system activities in any application which involves a series of sequential or parallel set of activities involving computational logic, data retrieval and persistence services. Actual orchestration steps and activities and computational logic are specified into configuration files, separate from the orchestration engine itself, thereby eliminating the need to code for such logic and activities. The framework can eliminate the need to code business logic and orchestration of data retrieval services by externalizing them into configuration files, resulting in lower costs to implement, test and maintain such system during its lifespan.

Abstract: In certain embodiments, an instance-specific user interface may be facilitated via entity-associated application metadata. In some embodiments, access information associated with an entity may be provided to one or more servers via a first executable instance of a same user application during a launch of the first executable instance. Based on the access information, application metadata associated with the entity may be obtained via the first executable instance from among a set of application metadata during the launch of the first executable instance, where the application metadata indicates data fields that correspond to data accessible to the entity. Based on the application metadata, the data fields may be loaded for a user interface of the first executable instance during the launch of the first executable instance. One or more of the data fields may be presented via the user interface of the first executable instance.

Abstract: A method for modifying an industrial control program is provided, the industrial control program comprising a first program element having a safety classification and a second program element not having the safety classification. The method comprises: identifying, in program source code of the first program element, a call to the second program element, and generating a modified program source code, comprising replacing, in the program source code, the call to the second program element by an auxiliary program element, the auxiliary program element being compliant with the safety classification.

Abstract: An electronic mail (email) system generates an email user interface display, that allows the user to enter message content. A context-sensitive calendar preview can be triggered and displayed on the email user interface display. The email system detects a user drag and drop input dragging at least a portion of the message content onto the calendar preview, and automatically generates a calendar event based upon the detected drag and drop input, and the particular portion of the message content dragged onto the context-sensitive calendar preview.

Abstract: Scalable task scheduling systems and methods for cyclic interdependent tasks using semantic analysis include, for a software application including a plurality of tasks which are cyclic interdependent tasks, segmenting the plurality of tasks into a task graph with vertices including the plurality of tasks and edges including interdependencies between the plurality of tasks; processing the task graph into a dependency graph which is a Directed Acyclic Graph (DAG); and causing execution of the plurality of tasks in a parallel manner based on the dependency graph.

Abstract: Embodiments disclosed herein are related to computing systems, and methods for extracting web API endpoint data from source code. Source code for various web services may be accessed. The source code may include portions of web Application Programming Interface (API) endpoint data that includes data necessary to invoke the underlying API. The source code may be automatically parsed to identify the portions of web API endpoint data. The identified portions of web API endpoint data may be translated into a format different from the source code that is usable by various applications that interact with the web services via the web API endpoint data.

Abstract: According to an aspect of an embodiment, a method may include receiving vocal input that includes conversational language describing a computer program to be generated. The method may also include generating input text based on the vocal input. The input text may be representative of the conversational language describing the computer program. The method may additionally include generating an intent layout based on the input text. The method may include generating an execution layout based on the intent layout. The execution layout may include computer programming language based on the intent layout. The method may also include generating the computer program based on the computer programming language included in the execution layout.

Abstract: A service platform for routing intent-based API requests to the most relevant APIs, comprising: a data ingestion subsystem, configured to retrieve API schema definitions and context information from external sources and store them in an API schema library; an ontology mining subsystem, configured to identify ontologies for said stored APIs, cluster the identified ontologies hierarchically and label said hierarchies with meaningful labels; an evaluation subsystem, configured to evaluate a set of APIs based on chosen datasets and metrics or by externally provided quality signals; an API dispatcher subsystem, configured to receive an intent-based request and identify the API schema and API Endpoint that match the request; and an API integration subsystem, configured to receive said intent-based request and said matched API schema and API Endpoint and synthesize an integration code.

Abstract: A method may include extracting information regarding a software project based on source code of the software project, where the information includes a description of the source code and computer-readable source code. The method may also include identifying at least two application programming interface (API) calls within the information, and extracting metadata regarding at least one of the APIs from the information. The method may additionally include, using the metadata, analyzing the computer-readable source code to determine a correlation between the two API calls. The method may also include, based on the correlation and using a first of the two API calls, generating computer source code that combines the first API call and an additional API call in an API mashup.

Abstract: Various embodiments include a classification platform system. A user can define a classification experiment on the classification platform system. For example, the user can define an input data space by selecting at least one of data sources interfaced with the classification platform system and defining a workflow configuration including a directed graph (DG) connecting a plurality of transformation blocks to represent an experiment workflow. The DG can specify how one or more outputs of each of the transformation blocks are fed into one or more other transformation blocks. The DG can be executed by various types of computation platforms. The classification platform system can schedule the experiment workflow to be executed on a distributed computation platform according to the input data space and the workflow configuration.

Abstract: A method for allocating resources for a machine learning model is disclosed. A machine learning model to be executed on a special purpose machine learning model processor is received. A computational data graph is generated from the machine learning model. The computational dataflow graph represents the machine learning model which includes nodes, connector directed edges, and parameter directed edges. The operations of the computational dataflow graph is scheduled and then compiled using a deterministic instruction set architecture that specifies functionality of a special purpose machine learning model processor. An amount of resources required to execute the computational dataflow graph is determined. Resources are allocated based on the determined amounts of resources required to execute the machine learning model represented by the computational dataflow graph.

Abstract: A computing system comprising a monitoring engine to generate and save a plurality of monitoring rules based on virtualized network function (VNF) types and VNF components. Each monitoring rule corresponds to a unique combination of a VNF type and a VNF component. The monitoring engine further receives a VNF monitoring notification for monitoring a new VNF provisioned in a network function virtualization environment. The VNF monitoring notification indicates a key performance indicator (KPI) to be monitored for the new VNF and KPI parameters corresponding to the KPI. Further, the monitoring engine determines a monitoring rule corresponding to the new VNF, from among the plurality of monitoring rules, based on the KPI. The monitoring engine subsequently executes the monitoring rule corresponding to the new VNF for monitoring KPIs for determining performance of the new VNF.

Abstract: A method of automatically generating a source code for implementing a function in hardware according to specifications defining a communication protocol includes: obtaining input data including the specifications; preprocessing the input data by extracting a table including a plurality of fields from the input data and classifying the table; generating structured data by performing lexical analysis on values of the plurality of fields according to a desired rule; and generating the source code from the structured data.

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.