Abstract: A graphical user interface display symbols for actuators and components for selection and creation of a graph by a user. The actuators represent resources of a provider, and the components include, as components of the actuators, technical implementations for interacting with programming interfaces of one or more providers of the resources, wherein the components are implemented as ontological classes that include declarative definitions of properties of the respective component; wherein, in response to selection of a new actuator by the user, the actuator is represented as a node in the graph, and wherein, in response to selection of a new component for an actuator in the graph, contact is made with the resource, and wherein the actuator and/or the components of the graph indicate technical properties of the resources as well as indicate user elements enabling the user to access the resources by means of functionalities of the components.

Abstract: Embodiments use a multi-modal approach to generate software programs that match a solution program description. The solution program description may include natural language, input-output examples, partial source code, desired operators, or other hints. Some embodiments use optimized prompts to a pre-trained language model to obtain initial candidate programs. Maximal program components are extracted and then recombined variously using component-based synthesis. Beam search reduces a solution program search space by discarding some candidates from a given synthesis iteration. Relevance metrics, string similarity metrics, operator frequency distributions, token rareness scores, and other optimizations may be employed. By virtue of optimizations and the multi-modal approach, a solution program may be obtained after fewer iterations than by use of a language model alone.

Abstract: Infusion pump interfaces providing simple and intuitive user experiences. A controller display subsystem for implementing infusion pump interfaces includes a processor, a memory, display logic, keypad I/O, and screen I/O. Display logic can command the processor via the memory to implement desirable displays on screen I/O.

Abstract: A method of building a natural language understanding application is provided. The method includes receiving at least one electronic record containing programming code and creating executable code from the programming code. Further, the executable code, when executed by a processor, causes the processor to create a parse and an interpretation of a sequence of input tokens, the programming code includes an interpret-block and the interpret-block includes an interpret-statement. Additionally, the interpret-statement includes a pattern expression and the interpret-statement includes an action statement.

Abstract: Techniques for context-based word embedding for programming artifacts are described herein. An aspect includes determining a plurality of keywords based on a corpus of programming artifacts, the corpus of programming artifacts including source code corresponding to a software project. Another aspect includes determining a plurality of context/keyword pair sets based on the plurality of keywords and the corpus of programming artifacts, wherein each context/keyword pair set of the plurality of context/keyword pair sets includes a first keyword, a second keyword, and a context type corresponding to a co-occurrence of the first keyword and the second keyword in the corpus of programming artifacts. Another aspect includes constructing a word embedding matrix based on the plurality of context/keyword pair sets.

Abstract: Embodiments promote searcher productivity and efficient search engine usage by using extraquery context to detect a searcher's intent, and using detected intent to match searches to well-suited search providers. Extraquery context may include cursor location, open files, and other editing information, tool state, tool configuration or environment, project metadata, and other information external to actual search query text. Search intent may be code (seeking snippets) or non-code (seeking documentation), and sub-intents may be distinguished for different kinds of documentation or different programming languages. Search provider capabilities may reflect input formats such as natural language or logical operator usage, or content scope such as web-wide or local, or other search provider technical characteristics.

Abstract: Apparatus, devices, systems, methods, and articles of manufacture for intent-based machine programming are disclosed. An example system categorize source code blocks includes a code repository accessor to access a code repository and select a source code block. The example system also includes a signature generator to generate a signature for the source code block, a collateral miner to extract collateral associated with the source code block, and a tokenizer to transform the source code block into tokens. In addition, the example system includes a function assessor to determine a function of the source code block based on the collateral and the tokens and an input/output determiner to determine an input and an output of the source code block based on the collateral and the signature. The example system further includes a tagger to categorize the source code block with the function, input, and output.

Abstract: In one example, a system comprises one or more processors to execute a business event processing module. The business event processing module is configured to receive a request to perform an operation on a listing published by an online marketplace, identify at least one additional listing having certain characteristics in common with the listing from a plurality of published listings including the listing, and automatically perform the operation on the at least one additional listing. The system includes a last event processor to determine a performance of the operation on a last instance of the at least one additional listing.

Abstract: Various embodiments synchronize comments in a source code file with text of a source code document. In one embodiment, a source code file is analyzed. A set of source code comment text within the source code file is identified. A set of text is extracted from the set of source code comment text that has been identified. A set of metadata is generated for at least the set of text. A plurality of markup tags is applied to the set of text. The plurality of markup tags at least one of format and stylize the set of text when presented to the user. A source code document is generated that includes one or more of the set of text, the set of metadata, and the plurality of markup tags.

Abstract: A data operation method for a storage system is applied to a storage system that includes an access node and at least two internet protocol (IP) hard disks, including sending, by the access node, a data migration instruction to a first IP hard disk, where the data migration instruction includes an identifier of a target virtual storage partition, the data migration instruction is used to instruct data in the target virtual storage partition to be migrated to a second IP hard disk; and receiving, by the first IP hard disk, the data migration instruction, reading the data in the target virtual storage partition according to the identifier of the target virtual storage partition, and writing the data in the target virtual storage partition into the second IP hard disk. The present system and method can be applied to migration of data in an IP hard disk.

Abstract: Static type checking can be performed on types and values defined in modules in a system that dynamically composes programs from modules. The types and values do not share a global namespace. Each module defines its own module universe, disjoint from other modules. A language mechanism can establish a local name binding to one module within the content of another module. When type checking at compile time an environment can be established that corresponds to a runtime instance of the program. The static type system can be arranged to align with the runtime values, such that the names used to refer to objects at runtime are the same as the names used to refer to the types of those objects in the static type system. Aliases of a particular type are resolved to a known compile time description of the type.

Abstract: A system including first and second memory and a control module. The first memory stores a first lookup table with first metadata that includes a first mapping between logical and physical addresses and is lost due to an unexpected power down event. The second memory stores a second lookup table with second metadata and an event log. The second metadata includes a second mapping between the logical and physical addresses. The event log includes entries indicating updated associations between respective ones of the logical addresses and one of the physical addresses as included in the first metadata prior to the power down event. The control module: prior to the power down event, performs segmented flushes each including updating a segment of the second metadata with a corresponding segment of the first metadata; and walks the event log to recover a full flush cycle of segments of the first metadata.

Abstract: In accordance with embodiments disclosed herein, there are provided methods, systems, and apparatuses for implementing a session table framework including, for example, receiving a request at a host organization from a client device, in which such a request specifies an application available via the host organization; generating a user session unique to the client device in a memory of the host organization; creating a user session data table within the user session; processing the request via the application specified by the request on behalf of the client device; updating the user session data table based on the processing of the request; and transmitting a response to the client device responsive to the request.

Abstract: A device may receive input text via a programming environment associated with a programming language. The device may tokenize the input text to generate tokenized text. The device may identify an invalid token string, based on the tokenized text, that is invalid for the programming language. The device may identify a token category pattern based on the invalid token string. The token category pattern may be a first sequence of token categories. The device may identify a replacement pattern based on the token category pattern. The replacement pattern may be a second sequence of token categories that is different from the first sequence of token categories. The device may identify a replacement token string based on the replacement pattern. The device may determine valid program code, associated with the programming language, based on the replacement token string. The device may provide the valid program code.

Abstract: A user interface component is displayed according to an implementation language independent description. An implementation language dependent specification for the user component is created from the implementation language independent description. The user interface component is created and displayed according to the implementation language dependent specification.

Abstract: Guide information according to a hierarchy of a given character string is sequentially acquired in response to an input of character strings for describing a source program, and only the guide information is displayed depending on an input status of the character string. Characters input from an input device for software description are coupled with each other to create an input character string. The created input character string is divided for each of the number of hierarchies on the basis of the number of hierarchies sectioned by a member access operator indicative of an access to a member of a structure or a class to acquire hierarchical character strings and hierarchy numbers thereof. The corresponding hierarchy of the hierarchical database is searched with the hierarchical character string as a search key for each of the acquired hierarchy numbers.

Abstract: Under the present invention, a method, computer program product, and system for non-blocking dynamic update of statically-typed class-based object-oriented software executing as byte-code on a virtual machine within an actively running computer system is provided. A set of objects instantiated from an existing module or multiple modules (identifiable collections of application resources and class definitions in the form of byte-code representations) is ready for execution on a virtual machine in an actively running computer system. New versions of one or more modules corresponding to those already loaded into the actively running virtual machine are dynamically loaded into the virtual machine for the purpose of updating the running software. The class definitions within the loaded modules are prepared for dynamic update by inserting byte-code that enables transparent state transfer and shared object identity between objects of a former version and the new version of a class.

Abstract: A machine vision system program editing environment including synchronized selection and/or identification of related features in a plurality of different user interface windows is provided. In particular, one of the windows is an editing window where a part program representation is displayed for editing by a user. In one embodiment, a user may select data or another feature of interest in a window that is not the editing window (e.g., a results window, or graphical workpiece inspection feature display window) and the associated part program instruction representation is automatically highlighted and/or selected in the editing window. Conversely, a part program instruction representation may be selected by a user in the editing window and the associated results or feature in another window is automatically highlighted and/or selected. User interface navigation, rapid program quality assessment, and overall part program creation and editing efficiency are significantly enhanced in such an editing environment.

Abstract: Briefly, in accordance with one embodiment, a method of processing non-transitory stored binary digital signal quantities using a computing device is disclosed. For example, a computing device transforms between at least first and at least second non-transitory stored binary digital signal quantities respectively representing at least a first and at least a second expression. The represented expressions have a common view for non-common expression types of the represented expressions and have a non-common view for common expression types of the represented expressions. The represented expressions include at least one of the following expression types: a hierarchical edge and/or node labeled tree or a symbol string.

Abstract: A method is provided to automatically correct an original source code. An abstract syntax tree (AST) is created from the original source code where the AST includes AST nodes. AST node filter queries are evaluated on the AST to filter out AST nodes with defect patterns. Automatic fixes are applied to the filtered AST nodes to transform the AST. A modified source code is created by deserializing the transformed AST.

Abstract: In an embodiment, a data processing method comprises obtaining access to computer program code; identifying a plurality of code segments in the computer program code; reorganizing the computer program code into reorganized code, by re-ordering the plurality of code segments into a new order that is potentially different than an original order of the plurality of code segments; wherein the new order is unpredictable based on the original order; rewriting one or more pointers of the reorganized code to point to new locations in the reorganized code consistent with the order of the reorganized code; wherein the method is performed by one or more computing devices.

Abstract: Methods, systems, and apparatus, including computer programs encoded on a computer storage medium, for a device aware social graph. In one aspect, a method includes deciding to send a message to a user, the user being associated with devices. The method also includes selecting a user device from among the devices. The method also includes determining a message method. The method also includes obtaining an identifier associated with the user and the message method. The method also includes sending a message to the device using the message method and the identifier.

Abstract: Within a system comprising a processor and a memory, a method for, within integrated development environment (IDE), presenting a custom view in the IDE based on a variable selection. The method can include selecting a first instance of the first variable in a first portion of program code. Via the processor, the program code can be searched to identify at least a second instance of the first variable in at least a second portion of the program code. Further, via the processor, the custom view can be presented in the IDE to present at least the first portion of the program code and the second portion of the program code based on the identification of the first variable in the second portion of the program code.

Abstract: A machine vision system program editing environment includes near real time context generation. Rather than requiring execution of all preceding instructions of a part program in order to generate a realistic context for subsequent edits, surrogate data operations using previously saved data replace execution of certain sets of instructions. The surrogate data may be saved during the actual execution of operations that are recorded in a part program. An edit mode of execution substitutes that data as a surrogate for executing the operations that would otherwise generate that data. Significant time savings may be achieved for context generation, such that editing occurs within an operating context which may be repeatedly refreshed for accuracy in near real time. This supports convenient program modification by relatively unskilled users, using the native user interface of the machine vision system, rather than difficult to use text-based or graphical object-based editing environments.

Abstract: Techniques are described herein that are capable of deep cloning (a.k.a. deep copying) objects using a binary format. A deep clone of a designated object includes references to other objects (and potentially copies of the other objects) included in the designated object. A binary representation of each object in an object graph is generated to provide a binary clone of the object graph. Objects created by a dynamic language engine are called dynamic language objects. Objects created by a host (e.g., that hosts the dynamic language engine) are called host objects. Each host object is associated with an intermediate representation thereof via a property bag that describes properties of that host object. Each intermediate representation is understandable by the dynamic language engine. A binary representation of each dynamic language object and each host object may be generated in accordance with the binary format to provide the binary clone.

Abstract: The present invention extends to methods, systems, and computer program products for creating and manipulating custom compound data types in declarative programs. The present invention allows a developer to create and use custom compound data types without requiring the custom type to be specifically defined (e.g. via registering a custom assembly) in the underlying framework. This is accomplished by providing a data container that is configurable to represent virtually any combination of primitive or compound types defined within the framework. The present invention also provides a declarative model for interacting with data containers representing custom compound data types. This declarative model employs a path-based syntax (or other type of syntax) for accessing the elements of a custom compound data type. Multiple paths can be defined within a single unit of developer input so that multiple elements of a custom data type can be manipulated by the single unit of input.

Abstract: A computer-implemented method for providing an informal interface and a formal interface to a computing application using a computer is provided. The informal interface includes first routines, the first routines using an informal input format. The method also includes providing a formal interface using the computer, where the formal interface includes second routines. The second routines support developer functionality, and the second routines using a formal input format. The method includes receiving a first input having a first routine input format, the first routine input format complying with the informal input format, or a second input having a second routine input format, the second routine input format complying with the formal input format. The method includes processing the received first input or the received second input and performing a computing operation based on the processing.

Abstract: A machine vision system editing environment is provided for a part program in which a continuous stream of image acquisition operations are performed during a run mode. In one embodiment, a new common syntax and representations are utilized wherein continuous image acquisition operations are recorded in the same way as regular operations, with the running of the part program being performed in two stages. In the first stage, the portion of the part program that is to have the continuous stream of image acquisition is scanned for image acquisition operations, and the most efficient order for acquiring the images is determined, after which the image acquisition process is begun. Then, in the second stage, while the image acquisition process is being performed, the portion of the part program is scanned again, with the image analysis operations then being performed.

Abstract: A method is provided that includes receiving a first triple including a subject, predicate and object, where the object is of a literal-type. For the first triple, then, the method includes identifying a subtype of the object; semantically marking the object with the identified subtype, including generating second and third triples; and storing the second and third triples in a triple store. In this regard, the second triple includes the subject and predicate of the first RDF triple as the subject and predicate thereof, and the third RDF triple includes the object of the first RDF triple or a representation of the object of the first RDF triple as the object thereof.

Abstract: A method (300) of editing program code is proposed. The program code consists of main instructions written in a high-level language. Typically, the program code further includes one or more sets of service instructions, which are not directly connected to a desired algorithm (such as tracing instructions for debugging purposes, performance measuring instructions, and the like). In the solution of the invention, each set of service instructions is enclosed (321-322) between a pair of predefined comments defining a starting tag and an ending tag. An editor of the program code is provided with commands for automatically disabling (341) the service instructions (converting them into corresponding comments); at the same time, the disabled instructions are condensed (340) on the monitor. Additional commands are available for automatically enabling (368) and restoring (367) the service instructions.

Abstract: A system and method for supporting the development and instantiation of web and locally installed interactive software applications that are configurable through editing and processing of formatted XML files originating through programmed or manual means. Software applications load and instantiate native applications embedded within in combination with core framework/runtime supported components. The application runtime environment and framework has the ability to implement runtime-configurable design templates to facilitate object reuse. This, in combination with de-coupled integration with custom data sets and services in addition to support for dynamic layout calculations make for efficient development and maintenance of applications.

Abstract: An object-oriented query to retrieve data from a data source stored on a data storage device connected to a computer is processed. One implementation involves receiving a Java Query Language (JQL) user query, compiling the JQL query using a Java compliant compiler, and detecting any compilation error due to a syntax error in the JQL query. If a compilation error is detected, then informing the user of the compilation error such that the user may correct the syntax error in the JQL query. Otherwise if a compilation error is not detected, then processing the JQL query for execution.

Abstract: An online integrated development environment (IDE) providing code assist is described. A method for providing code assist within the online IDE comprises receiving a request from a client device to access a software development project, storing code assist information related to the software development project, and sending code assist information to the client device. The client device stores the received code assist information and uses it for local code assist operations at the client device. The client device can receive a subset of a database of code assist information stored at a server environment providing the online IDE. The client device accesses the online IDE via a web browser.

Abstract: A method, system and program product for providing execution feedback of peer submitted code snippets executed for correction of semantic errors in code. A first developer executing a code snippet to correct a semantic error in the use of a third-party library within a first IDE results in the transmission of an execution result to a collaboration datastore. If the code snippet execution completed with no errors, a result indicating a success is automatically transmitted by the IDE. Further, if the code snippet execution resulted in an error due to error within the code snippet, a result indicating code snippet failure along with error details is automatically transmitted. When a second developer is working on code within a second IDE that contains semantic errors, code snippets to correct the semantic error are presented to the second developer, ranked based on previous execution feedback provided by peer developers.

Abstract: A source code comparison device includes a difference extraction portion extracting a difference between a source code before correction and the source code after correction, a syntax analysis portion dividing the extracted difference into divided differences which are portions corresponding to components usable in the source code, and generating a syntax analysis result having associated the divided difference with the component corresponding to the divided difference, a feature analysis portion setting a feature division for each of the divided differences included in the syntax analysis result, and an output portion outputting a comparison result having associated the divided difference with the feature division set for the divided difference. The feature analysis portion sets the feature division associated with the component in a correction history for the divided difference associated with the component in the syntax analysis result.

Abstract: A system for monitoring processes of a distributed business application an integration builder tool. The integration builder tool includes a condition editor having a user interface providing an editing area on a display in which to receive a text-based expression of one or more conditions of a business application process. The editing area further includes an operator palette providing a plurality of operators for use in the text based expression of each of the one or more conditions, and a toolbar providing one or more editing tools for editing the text-based expressions.

Abstract: An aspect of the present invention facilitates analysis of software code written in a programming language. In one embodiment, a visual interface designed to receive values identifying constructs of the programming language is provided on a display unit. In response to receiving, from a user using the visual interface, values corresponding to a construct of interest, a rule indicating a string of characters (that would constitute the construct of interest) is generated based on the received values. The generated rule is then applied to the software code to identify blocks matching the string of characters, each block representing a corresponding occurrence of the construct of interest in the software code.

Abstract: Providing for generation of a task oriented data structure that can correlate natural language descriptions of computer related tasks to application level commands and functions is described herein. By way of example, a system can include an activity translation component that can receive a natural language description of an application level task. Furthermore, the system can include a language modeling component that can generate the data structure based on an association between the description of the task and at least one application level command utilized in executing the computer related task. Once generated, the data structure can be utilized to automate computer related tasks by input of a human centric description of those tasks. According to further embodiments, machine learning can be employed to train classifiers and heuristic models to optimize task/description relationships and/or tailor such relationships to the needs of particular users.

Abstract: A computer-implemented method, a computer system and a computer program product are for displaying a user interface component according to an implementation language independent description of the user interface component are provided. The method may comprise selecting, based on a characteristic of the implementation language independent description, a description parser and receiving the implementation language independent description, and determining an implementation language for displaying the user interface component. Also, the method may comprise parsing, by the description parser, the implementation language independent description, identifying a presentation rule, and selecting a set of instructions for processing the parsed description. In addition, the method may comprise processing the parsed description according to the set of instructions in order to create an implementation language dependent specification of the user interface component.

Abstract: A method of processing natural language assertions (NLAs) can include identifying an NLA and then translating that NLA into a verification language assertion (VLA) using a natural language parser (NLP) and synthesis techniques. This VLA can be translated into an interpreted NLA (NLA*) using a VLA parser and pattern matching techniques. At this point, the process can allow user review of the NLA* and the NLA. When the user determines that the NLA* and the NLA are the same or have insignificant difference, then verification can be performed using the VLA. The results of the verification can then be back annotated on the NLA. In one fully-automatic embodiment, in addition to comparing the NLA and the NLA*, the VLA and a VLA* (generated from the NLA*) can be compared, thereby providing yet another test of accuracy for the user during verification.

Abstract: A system and machine-implemented method modifying a source code file to reduce dependencies included therein. The source code file is parsed to identify a symbol within the source code file, and one or more header files are identified, each of which is capable of resolving the symbol for the source code file. A header file is selected from the one or more header files for inclusion in the source code file, based on a predetermined set of rules. The source code file is modified to include the selected header file.

Abstract: Solution packages for a product for deployment on a collection of servers can be designed using one or more designers that provide user interfaces for visually arranging and configuring elements of the product. A package object model includes a managed object model that represents a package or feature manifest as defined by a product manifest XML schema. The object model can be used to create references to other project item and feature definitions. The extended object model can be used to generate an equivalent package or feature manifest XML file.

Abstract: An end-to-end approach is provided for developing and maintaining network device management applications. The approach includes an XML-based development environment for network device management applications that uses Management Data API (MDA) schemas that define a hierarchical data model for components supported by a network device. The XML-based development environment also uses XML schemas to define a common XML-based interface used by management applications to access management data maintained on the network device. The approach provides programmatic access to network device management data and management data schema with an XML-based data model and interface that is consistent across all network device components. The approach includes mechanisms for automatically generating XML requests that conform to a hierarchical data model from requests that conform to a table-based data model.

Abstract: A method, system, and computer program product are disclosed for creating an OWL ontology from a Java source code, wherein the Java source code includes a plurality of Java classes. Each of these Java classes includes one or more Java members and one or more Java objects. The Java objects are used to instantiate each of the Java classes. An OWL class is created for each of the Java classes, and an OWL concept is created for each of the Java members. Further, an OWL instance is created for each of the Java objects. Each of the OWL classes, the OWL concepts, and the OWL instances are assigned data type properties and object properties. Subsequently, each of the OWL classes and relations between them, each of the OWL concepts, and each of the OWL instances are included to form the OWL ontology.

Abstract: In a computing environment, a method for treating display characteristics of input displayed via a user interface includes receiving input from a user interface, the input including at least one character, determining the scope of the input, categorizing input into at least one category, and applying at least one display treatment to the input associated with at least one category, wherein the display treatment is applied as each character is received from the user interface.

Abstract: Disclosed herein are systems, methods, and non-transitory computer-readable storage media for obfuscating a computer program. A system configured to practice the method identifies a set of executable instructions at a first location in an instruction section of the computer program and identifies a second location in a data section of the computer program. Then the system moves the set of executable instructions to the second location and patches references in the computer program to the set of executable instructions to point to the second location. The instruction section of the computer program can be labeled as _TEXT,_text and the data section of the computer program is labeled as _DATA,_data. The set of executable instructions can include one or more non-branching instructions optionally followed by a branching instruction. The placement of the first and second locations can be based on features of a target computing architecture, such as cache size.

Abstract: Embodiments of the present invention address deficiencies of the art in respect to defect classification for software development and provide a method, system and computer program product for automated defect classification in a software development tool. In an embodiment of the invention, a defect classification method can be provided. The method can include computing differences between versions of a line of source code, lexically analyzing the computed differences to produce a lexical construct, mapping the lexical construct to a classification, and assigning the defect classification to the line of source code.

Abstract: Software generates interfaces and functionality for an application program. At least a portion of an application is created by given names to data elements according to a syntax. Data tables are generated having fields that correspond to the elements and characteristics are associated with the fields specifying how the data in the fields interact with each other. Relationships among the elements are inferred as a function of their names. A functional interface can be generated from the inferred relationship.

Abstract: In general, the subject matter described in this specification can be embodied in methods, systems, and program products for selecting a first grammar rule in a programming language grammar. The grammar is used for determining a syntax validity of a programming code statement in a text editor and the first grammar rule includes a hard-to-type symbol that is syntactically correct for the programming code statement. A second grammar rule for the grammar is created. The created second grammar rule is substantially identical to the first grammar rule but the hard-to-type symbol is replaced with an easy-to-type symbol that is syntactically incorrect for the programming code statement. An action is associated with the grammar and is performed upon satisfying the second grammar rule. Performance of the second grammar rule causes the easy-to-type symbol in the programming code statement in the text editor to be replaced with the hard-to-type symbol.

Abstract: Systems and methods for active learning of statistical machine translation systems through dynamic creation and updating of parallel corpus. The systems and methods provided create accurate parallel corpus entries from a test set of sentences, words, phrases, etc. by calculating confidence scores for particular translations. Translations with high confidence scores are added directly to the corpus and the translations with low confidence scores are presented to human translations for corrections.