Patent Grant
10437565
The present invention relates to the field of computer programming, and more specifically, to a computer-implemented method, a system and a computer program product for code suggestion.
Today, many Integrated Development Environments (IDEs) have been developed to facilitate programming work of programmers, such as Visual Studio®, Eclipse®, JetBrains®, Jupyter Notebook® and etc. In many of these IDEs, a function referred to as code suggestion is provided to accelerate the input of codes. If a programmer types, in an editor of an IDE for Java language, a line of code “System.out.printl”, which has an incomplete name of method, a menu will pop up near the cursor in the editor, which shows names of methods starting with “printl”, such as “println( )”, “println(boolean x)”, “println(char x)”, “println(float x)” and etc. The programmer may choose one option from the menu to complement the incomplete name of method. For example, if the name of method “println(float x)” on the menu is chosen by the programmer, the code being edited will be automatically complemented as “System.out.println(float x)”.
In another example, if an incomplete variable “ttest_” is input by a programmer in an editor of an IDE, a menu will pop up near the cursor in the editor, which shows variable names starting with “ttest_”, such as “ttest_lsamp”, “ttest_ind”, “ttest_ind_from_stats” and etc. The programmer may choose one option from the menu to complement the incomplete variable. For example, if the variable name “ttest_ind” on the menu is chosen by the programmer, the incomplete variable will be automatically complemented as “ttest_ind” in full.
Additionally, the current IDEs can also provide code suggestion for keywords of a programming language. For example, in an editor for C language, if “siz” is input by a programmer, a code suggestion of “sizeof” will be presented to the programmer, which is a keyword of C language in its complete form. All of the above techniques are referred to as code suggestion, which help programmers to remind names of variables and methods, and keywords of programming languages and to input codes fast.
The inventors of the present invention found that there is a need for dynamic code suggestion on the basis of runtime context features.
To address the need, it is proposed a computer-implemented method, a system and a computer program product for code suggestion.
According to one aspect of the present invention, there is provided a computer-implemented method for code suggestion. The method comprises collecting a set of runtime context features of a program that is being edited. The method further comprises comparing the set of runtime context features with at least one set of stored context features to find at least one matching set of stored context features. Each of the at least one set of stored context features is extracted from a corresponding code segment. The method further comprises presenting at least one code segment with its set of stored context features matching the set of runtime context features, for the user to choose to add into the program.
According to another aspect of the present invention, there is provided a system for code suggestion. The system comprises one or more processors and a memory coupled to at least one of the one or more processors. The system further comprises a set of computer program instructions stored in the memory and executed by at least one of the one or more processors in order to perform an action of collecting a set of runtime context features of a program that is being edited. The system further comprises a set of computer program instructions stored in the memory and executed by at least one of the one or more processors in order to perform an action of comparing the set of runtime context features with at least one set of stored context features to find at least one matching set of stored context features. Each of the at least one set of stored context features is extracted from a corresponding code segment. The system further comprises a set of computer program instructions stored in the memory and executed by at least one of the one or more processors in order to perform an action of presenting at least one code segment with its set of stored context features matching the set of runtime context features, for the user to choose to add into the program.
According to a further aspect of the present invention, there is provided a computer program product for code suggestion. The computer program product comprises a computer readable storage medium having program instructions embodied therewith. The program instructions being executable by a device to perform a method. The method comprises collecting a set of runtime context features of a program that is being edited. The method further comprises comparing the set of runtime context features with at least one set of stored context features to find at least one matching set of stored context features. Each of the at least one set of stored context features is extracted from a corresponding code segment. The method further comprises presenting at least one code segment with its set of stored context features matching the set of runtime context features, for the user to choose to add into the program.
Some preferable embodiments will be described in more detail with reference to the accompanying drawings, in which the preferable embodiments of the present disclosure have been illustrated. However, the present disclosure can be implemented in various manners, and thus should not be construed to be limited to the embodiments disclosed herein. On the contrary, those embodiments are provided for the thorough and complete understanding of the present disclosure, and completely conveying the scope of the present disclosure to those skilled in the art.
Referring now to
As shown in
Bus 18 represents one or more of any of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. By way of example, and not limitation, such architectures include Industry Standard Architecture (ISA) bus, Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnect (PCI) bus.
Computer system/server 12 typically includes a variety of computer system readable media. Such media may be any available media that is accessible by computer system/server 12, and it includes both volatile and non-volatile media, removable and non-removable media.
System memory 28 can include computer system readable media in the form of volatile memory, such as random access memory (RAM) 30 and/or cache memory 32. Computer system/server 12 may further include other removable/non-removable, volatile/non-volatile computer system storage media. By way of example only, storage system 34 can be provided for reading from and writing to a non-removable, non-volatile magnetic media (not shown and typically called a “hard drive”). Although not shown, a magnetic disk drive for reading from and writing to a removable, non-volatile magnetic disk (e.g., a “floppy disk”), and an optical disk drive for reading from or writing to a removable, non-volatile optical disk such as a CD-ROM, DVD-ROM or other optical media can be provided. In such instances, each can be connected to bus 18 by one or more data media interfaces. As will be further depicted and described below, memory 28 may include at least one program product having a set (e.g., at least one) of program modules that are configured to carry out the functions of embodiments of the invention.
Program/utility 40, having a set (at least one) of program modules 42, may be stored in memory 28 by way of example, and not limitation, as well as an operating system, one or more application programs, other program modules, and program data. Each of the operating system, one or more application programs, other program modules, and program data or some combination thereof, may include an implementation of a networking environment. Program modules 42 generally carry out the functions and/or methodologies of embodiments of the invention as described herein.
Computer system/server 12 may also communicate with one or more external devices 14 such as a keyboard, a pointing device, a display 24, etc.; one or more devices that enable a user to interact with computer system/server 12; and/or any devices (e.g., network card, modem, etc.) that enable computer system/server 12 to communicate with one or more other computing devices. Such communication can occur via Input/Output (I/O) interfaces 22. Still yet, computer system/server 12 can communicate with one or more networks such as a local area network (LAN), a general wide area network (WAN), and/or a public network (e.g., the Internet) via network adapter 20. As depicted, network adapter 20 communicates with the other components of computer system/server 12 via bus 18. It should be understood that although not shown, other hardware and/or software components could be used in conjunction with computer system/server 12. Examples, include, but are not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data archival storage systems, etc.
The present invention may be implemented in the computer system/server 12.
The inventors of the present invention found that, current code suggestion technologies mainly focus on auto-completing for keywords, names of methods and variables in a program. This kind of code suggestion is only based on previously defined variables and methods in the program. That is, the code suggestion in the prior art is based on static code analysis, which only analyzes static source code and provides very limited information.
Further, the inventors of the present invention found that, it would be useful if the IDE could provide code suggestions on the basis of code segments (snippets) that have specific functions, which would lower the requirement for the programmer to master a package or software development kit (SDK), to ease the programming work. The inventors of the present invention found that, in some specific fields, it is feasible to suggest code segments since processes (functions or methods) involved in a specific field are limited. For example, in the field of graphics, involved processes may include: draw a line, draw a rectangle, draw an oval, draw a polygon and etc. In the field of data analytics, involved processes may include at least the following categories: data import, data cleaning, data exploration, feature engineering and modeling. These processes are repetitive in analytics programs and can be organized in a better way.
The inventors of the present invention also found that, even if there is code suggestion for code segments, it is not flexible and agile enough if it is only based on static code analysis. To address this problem, the inventors of the present invention introduce dynamic code suggestion.
With reference now to
Specifically, in the runtime context feature collecting step 210, a set of runtime context features of a program that is being edited is collected. In one embodiment of the invention, the method in
In one embodiment of the invention, the runtime context feature may be a feature collected at runtime and includes at least one of: programming language of the program, code comments in the program, input search keywords, imported packages, classes or functions in the program, data types and names of variables in the program, values of variables in the program, and value distribution of elements of a compound variable in the program. The programming language of a program can be obtained from the file name of the file being edited. For example, from a file named “abc.java”, it can be determined that the programming language of the program is Java. Code comments refer to comments written by the programmer to help understand the function or logic of a program, a method, a code segment or a statement, and are not necessarily a part of the source code. Some IDEs may provide a search field for the programmer to input keywords (e.g., in a help document), and the search results will help the programmer in the aspect described by the input keywords. The keyword input by the programmer is one kind of runtime context feature. In one embodiment of the invention, the imported packages, classes or functions will be explicitly written in the source code; but in another embodiment of the invention, the imported packages, classes or functions depend on values of variables and can be determined only at runtime.
Normally, data types and names of variables can be collected from the source code as static information. However, in some dynamic languages such as Python, data type of a variable is not predefined, which is automatically determined based on the value assigned to this variable at runtime. Thus, when using a dynamic language such as Python, data type of a variable can be collected only at runtime. Additionally, as known, values of variables can be collected at runtime.
In the field of data analytics, the object to be analyzed is data, which is normally organized in a table of database or a data structure. In many programming languages (e.g., R language) or SDKs (such as Python pandas and Apache Spark®), a data structure such as DataFrame is used to accommodate structured or semi-structured data. That is, the compound variable of the invention may be a DataFrame variable having columns, and name and data type of each column can be determined only at runtime. For a DataFrame variable, it is like a table and may have stored many data records, each of which corresponds to an element of the variable. In one embodiment of the invention, features of DataFrame variables (e.g., the value distribution of a column in the DataFrame) also belong to runtime context feature and can be collected only at runtime.
Although several examples for runtime context feature are given above, it does not mean to be exhaustive. Those skilled in the art can think of other runtime context features based the teaching of the invention. The runtime context features to be collected are not fixed, and any combination of these runtime context features may be collected as the set of runtime context features.
Recently, interactive development environment such as Jupyter Notebook® becomes popular. The interactive development environment is characterized in that it has an interactive runtime and is used with a dynamic programming language. It means that the source code does not need to be complied as files, whenever a segment of code is input, this segment of code will be interpreted and executed immediately, and the result of execution will reflect in variables. That is why it is called “interactive”. For example, if a code segment “a=1; c=a+2;” is input in an interactive development environment, this code segment will be interpreted and executed immediately, and variable c will instantly have a value of 3. This is different from a conventional development environment, in which source codes are compiled and executed as a file, and variable c will have a value only after compiling the whole source code file and executing it.
In one embodiment of the invention, for an interactive development environment, in the runtime context feature collecting step 210, the set of runtime context features can be collected directly from the interactive runtime. In another embodiment of the invention, for a non-interactive development environment in which the source code needs to be complied or interpreted, in the runtime context feature collecting step 210, the set of runtime context features can be collected by compilation execution or interpretation execution of the current source code.
The following embodiments of the present invention will be explained by way of examples of an interactive development environment, but the invention is not thus limited to the interactive development environment, and it is also applicable to those non-interactive development environments Likewise, the following embodiments of the present invention will be explained by way of an exemplary field of data analytics, but the invention is not thus limited to the specific field of data analytics, and it is also applicable to other fields such as graphics, and statistics.
In one embodiment of the invention, the collected set of runtime context features may be represented as pairs of key and value. For example, if the following codes in Python is input and executed, wherein df is a DataFrame variable.
df=SQL(“SELECT Model, Number FROM Table_A ORDER BY Number DESC”)
the interactive development environment will output the value of df in real time as
Then, the user inputs the following codes:
# Draw a pie chart of Model
import matplotlib as plt
At this time, if the collecting of runtime context features is triggered by the execution of the subsequent input codes or by the user pressing a suggestion button for example, the collected set of runtime context features may be:
Programming language: {Python 2.7}
Imported packages/classes/functions: {matplotlib}
Variables at runtime context: {df:DataFrame}
Schema of runtime context variable: {df:{
DataType:DataFrame,
Columns: {
“Model”: (“String”, [‘XL’, ‘M’, ‘S’]),
“Number” (“numeric”, [5000, 3000, 1900])}}}
Natural language: {“Draw a pie chart of Model”}
In the above example, the collected runtime context features are organized in written description that can be read by human. In other embodiments of the invention, the collected runtime context features can be organized in a self-defined data structure, in a XML file, in a plain text file or in other forms, as long as it can represent a correspondence between a feature and its value. The above written description shows the following context features of this example code segment: the programming language of this code segment is Python 2.7; a package named “matplotlib” is imported in this code segment; there is a variable df in this code segment and its data type is DataFrame; for the compound variable df, it has two columns “Model” and “Number”, the column “Model” has a data type of “String” and values of “XL”, “M” and “S”, the column “Number” has a data type of “numeric” and values of 5000, 3000 and 1900; and natural language “Draw a pie chart of Model” is found from code comments and/or search keywords. The collected runtime context features in this example are used to describe the invention, and do not include all possible runtime context features. In other embodiments, other context features may be collected, or some context features in the above set may not be collected.
Now referring back to
In one embodiment of the invention, the at least one set of stored context features is previously extracted from at least one of code segments written by experts or the user himself, code segments in package documentation, and code segments on websites on the Internet. The code segment library is a library containing code segments that may be reused in programming. In one embodiment of the invention, these code segments may be the ones written in the IDE by the current user or other users in the past. In another embodiment of the invention, these code segments may be obtained from package documentation or tutorials. In another embodiment of the invention, these code segments may be obtained by crawler from Internet websites such as SDK documentation, stackoverflow.com, and gist.github.com.
After a code segment is obtained, its context features can be extracted manually or automatically. In one embodiment of the invention, an expert may tag extracted context features for some code segments so that these extracted context features are well-formed. In another embodiment of the invention, context features of a code segment programmed locally may be recorded when it is at runtime. After context features are extracted for a code segment, the code segment is stored in the library based on its context features.
Now referring back to
Programming language: {Python 2.7}
Imported packages/classes/functions: { }
Variables at runtime context: { }
Schema of runtime context variable: { }
Natural language: { }
Considering that it is to write a program for data analytics in the interactive development environment designed for data analytics in
Programming language: Python 2.7
Imported packages/classes/functions: {DataLoader, csv_load}
Variables at runtime context: {df:DataFrame}
Schema of runtime context variable: {df:{ . . . }}
Natural language: { }
Considering that data has been imported and there are not any other inputs, it can be coarsely estimated that, next, data exploration such as descriptive analysis and correlation might be probably performed using SQL. Based on the collected set of runtime context features, code segments used for data exploration are matching code segments for this scenario. Therefore, in the panel on the right side of
Programming language: Python 2.7
Imported packages/classes/functions: {DataLoader, csv_load}
Variables at runtime context: {df:DataFrame}
Schema of runtime context variable: {df:{ . . . }}
Natural language: {“Outlier”}
Considering that data has been imported and the user is searching the keyword “Outlier”, it can be estimated that, next, processes relating to “Outlier” might be performed. Based on the collected set of runtime context features, for example, code segments used for outlier detection are matching code segments for this scenario. Therefore, in the panel on the right side of
In another embodiment of the invention, if there are not any inputs after the data import of DataFrame df is finished (like the situation in
The situations in
Natural language: {“Pie Chart”} (only in the situation of
Imported packages/classes/functions: {matplotlib} (only in the situation of
Natural language: {“Draw a pie chart of ColumnX”} (only in the situation of
Based on the above different collected runtime context features, for both of the situations, it can be predicted that it needs to draw a pie chart. Therefore, various code segments for drawing a pie chart may be suggested. For the situation in
In one embodiment of the invention, the comparing in the comparing step 220 can be performed based on some predefined rules. For example, some context features must be matched between the program being edited and the stored code segments, such as their program language. For other context features, the more matched features are found, the more appropriate the code segment is to be presented as a suggestion.
In another embodiment of the invention, the comparing step 220 may comprise for each context feature in the set of runtime context features, finding a corresponding context feature in a first set of the at least one set of stored context features to form a pair of corresponding context features. The comparing step 220 may further comprise calculating a similarity score for each pair of corresponding context features. The comparing step 220 may further comprise obtaining a final score for the first set of the at least one set of stored context features by summing up the calculated similarity scores with weights. The comparing step 220 may further comprise for other sets of the at least one set of stored context features, repeating the finding, the calculating and the obtaining to get their final scores. The comparing step 220 may further comprise determining at least one set of stored context features with top final scores as a set of stored context features that matches the set of runtime context features.
That is, in this embodiment, for each stored code segment, a score is calculated based on matching degree of its context features with respective runtime context features of the program being edited. Then, top code segments with the highest scores will be presented as suggestions. In one embodiment of the invention, the score may be a weighted sum S=a*A+b*B+c*C+ . . . Here, A, B, C . . . represent that, for different context features, whether it matches with the corresponding runtime context feature, and a, b, c . . . are their respective weights.
In one embodiment of the invention, a popular value is assigned to each stored code segment, which reflects popularity (that is, frequency of being accepted as a suggestion) for this code segment. When a code segment is matched for suggestion in the comparing step 220, its popular value is considered as a factor for its listing position in the sequence for suggestion. For example, for matched code segments, the higher the popular value is, the closer the code segment is to the top.
In one embodiment of the invention, after presenting at least one code segment, if the user does not choose any code segment, subsequent input code of the user and context features of the input code will be stored for further code suggestion. In this case, the popular values of the presented code segments may be reduced.
Although in the above embodiments, suggested code segments are added into the program being edited. Actually, in most situations, a suggested code segment could not fit in exactly, which needs to be adapted for the program being edited, by amending some names of variables or functions for example. Even in this case, the invention will still accelerate the programming.
Although in
The present invention may be a system, a method, and/or a computer program product. The computer program product may include a computer readable storage medium (or media) having computer readable program instructions thereon for causing a processor to carry out aspects of the present invention.
In an embodiment of the present invention, there is provided a system for code suggestion. The system comprises one or more processors and a memory coupled to at least one of the one or more processors. The system further comprises a set of computer program instructions stored in the memory and executed by at least one of the one or more processors in order to perform an action of collecting a set of runtime context features of a program that is being edited. The system further comprises a set of computer program instructions stored in the memory and executed by at least one of the processors in order to perform an action of comparing the set of runtime context features with at least one set of stored context features to find at least one matching set of stored context features. Each of the at least one set of stored context features is extracted from a corresponding code segment. The system further comprises a set of computer program instructions stored in the memory and executed by at least one of the processors in order to perform an action of presenting at least one code segment with its set of stored context features matching the set of runtime context features, for the user to choose to add into the program.
In one embodiment of the system, wherein the set of computer program instructions is performed in response to at least one of the user opening an editor for editing the program, the user executing a code segment, the user inputting a keyword for searching, and the user pressing a suggestion button.
In one embodiment of the system, wherein the runtime context feature is a feature collected at runtime and includes at least one of: programming language of the program, code comments in the program, input search keywords, imported packages, classes or functions in the program, data types and names of variables in the program, values of variables in the program, and value distribution of elements of a compound variable in the program.
In one embodiment of the system, wherein the at least one set of stored context features is previously extracted from at least one of code segments written by experts or the user himself, code segments in package documentation, and code segments on websites on the Internet.
In one embodiment of the system, wherein comparing the set of runtime context features with at least one set of stored context features to find at least one matching set of stored context features further comprises: for each context feature in the set of runtime context features, finding a corresponding context feature in a first set of the at least one set of stored context features to form a pair of corresponding context features; calculating a similarity score for each pair of corresponding context features; obtaining a final score for the first set of the at least one set of stored context features by summing up the calculated similarity scores with weights; for other sets of the at least one set of stored context features, repeating the finding, the calculating and the obtaining to get their final scores; and determining at least one set of stored context features with top final scores as a set of stored context features that matches the set of runtime context features.
In one embodiment of the system, wherein after presenting at least one code segment, if the user does not choose any code segment, subsequent input code of the user and context features of the input code will be stored for further code suggestion.
In one embodiment of the system, wherein the compound variable is a DataFrame variable having columns, and name and data type of each column can be determined only at runtime.
In an embodiment of the present invention, there is provided a computer program product for code suggestion. The computer program product comprises a computer readable storage medium having program instructions embodied therewith. The program instructions being executable by a device to perform a method. The method comprises collecting a set of runtime context features of a program that is being edited. The method further comprises comparing the set of runtime context features with at least one set of stored context features to find at least one matching set of stored context features. Each of the at least one set of stored context features is extracted from a corresponding code segment. The method further comprises presenting at least one code segment with its set of stored context features matching the set of runtime context features, for the user to choose to add into the program.
In one embodiment of the computer program product, wherein the method is performed in response to at least one of the user opening an editor for editing the program, the user executing a code segment, the user inputting a keyword for searching, and the user pressing a suggestion button.
In one embodiment of the computer program product, wherein the runtime context feature is a feature collected at runtime and includes at least one of: programming language of the program, code comments in the program, input search keywords, imported packages, classes or functions in the program, data types and names of variables in the program, values of variables in the program, and value distribution of elements of a compound variable in the program.
In one embodiment of the computer program product, wherein the at least one set of stored context features is previously extracted from at least one of code segments written by experts or the user himself, code segments in package documentation, and code segments on websites on the Internet.
In one embodiment of the computer program product, wherein comparing the set of runtime context features with at least one set of stored context features to find at least one matching set of stored context features further comprises: for each context feature in the set of runtime context features, finding a corresponding context feature in a first set of the at least one set of stored context features to form a pair of corresponding context features; calculating a similarity score for each pair of corresponding context features; obtaining a final score for the first set of the at least one set of stored context features by summing up the calculated similarity scores with weights; for other sets of the at least one set of stored context features, repeating the finding, the calculating and the obtaining to get their final scores; and determining at least one set of stored context features with top final scores as a set of stored context features that matches the set of runtime context features.
In one embodiment of the computer program product, wherein after presenting at least one code segment, if the user does not choose any code segment, subsequent input code of the user and context features of the input code will be stored for further code suggestion.
In one embodiment of the computer program product, wherein the compound variable is a DataFrame variable having columns, and name and data type of each column can be determined only at runtime.
The computer readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of the computer readable storage medium includes the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punch-cards or raised structures in a groove having instructions recorded thereon, and any suitable combination of the foregoing. A computer readable storage medium, as used herein, is not to be construed as being transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission media (e.g., light pulses passing through a fiber-optic cable), or electrical signals transmitted through a wire.
Computer readable program instructions described herein can be downloaded to respective computing/processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and/or a wireless network. The network may comprise copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers and/or edge servers. A network adapter card or network interface in each computing/processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium within the respective computing/processing device.
Computer readable program instructions for carrying out operations of the present invention may be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state-setting data, or either source code or object code written in any combination of one or more programming languages, including an object oriented programming language such as Smalltalk, C++ or the like, and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The computer readable program instructions may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGA), or programmable logic arrays (PLA) may execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present invention.
Aspects of the present invention are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer readable program instructions.
These computer readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer readable program instructions may also be stored in a computer readable storage medium that can direct a computer, a programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer readable storage medium having instructions stored therein comprises an article of manufacture including instructions which implement aspects of the function/act specified in the flowchart and/or block diagram block or blocks.
The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer implemented process, such that the instructions which execute on the computer, other programmable apparatus, or other device implement the functions/acts specified in the flowchart and/or block diagram block or blocks.
The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts or carry out combinations of special purpose hardware and computer instructions.
The descriptions of the various embodiments of the present invention have been presented for purposes of illustration, but are not intended to be exhaustive or limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terminology used herein was chosen to best explain the principles of the embodiments, the practical application or technical improvement over technologies found in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein.
| Number | Name | Date | Kind |
|---|---|---|---|
| 6314559 | Sollich | Nov 2001 | B1 |
| 6557010 | Kim | Apr 2003 | B1 |
| 8245186 | Gryko et al. | Aug 2012 | B2 |
| 8271939 | Krishnaiyer | Sep 2012 | B1 |
| 8510794 | Kaushik | Aug 2013 | B1 |
| 9116982 | Stern | Aug 2015 | B1 |
| 20050123202 | Hwang | Jun 2005 | A1 |
| 20070265814 | Moore | Nov 2007 | A1 |
| 20070288254 | Eisner | Dec 2007 | A1 |
| 20090297044 | Kokumai | Dec 2009 | A1 |
| 20100269095 | King | Oct 2010 | A1 |
| 20110246561 | Eshima | Oct 2011 | A1 |
| 20120174061 | McCollum | Jul 2012 | A1 |
| 20130007700 | Villar | Jan 2013 | A1 |
| 20140013299 | Bordeaux et al. | Jan 2014 | A1 |
| 20140109042 | Christensen | Apr 2014 | A1 |
| 20140173563 | Dias | Jun 2014 | A1 |
| 20140282375 | Gulwani et al. | Sep 2014 | A1 |
| 20150378692 | Dang et al. | Dec 2015 | A1 |
| 20170006135 | Siebel | Jan 2017 | A1 |
| Number | Date | Country | |
|---|---|---|---|
| 20180060044 A1 | Mar 2018 | US |
