US20040031017A1 - System and method for context-sensitive help in a design environment - Google Patents

System and method for context-sensitive help in a design environment Download PDF

Info

Publication number
US20040031017A1
US20040031017A1 US10218222 US21822202A US2004031017A1 US 20040031017 A1 US20040031017 A1 US 20040031017A1 US 10218222 US10218222 US 10218222 US 21822202 A US21822202 A US 21822202A US 2004031017 A1 US2004031017 A1 US 2004031017A1
Authority
US
Grant status
Application
Patent type
Prior art keywords
entry
method
system
associated
code
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Abandoned
Application number
US10218222
Inventor
Shankar Vaidyanathan
Randy Kimmerly
Biliana Kaneva
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Microsoft Technology Licensing LLC
Original Assignee
Microsoft Corp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/30Creation or generation of source code
    • G06F8/33Intelligent editors

Abstract

An intelligent tool for assisting a developer during the creation or maintenance of software generates an icon when triggered by input. Upon selection of the icon, options are displayed for potential selection. Upon selection of an entry, event associated with the entry are deployed.

Description

    FIELD OF THE INVENTION
  • This invention relates to the field of computing and in particular to the field of development tools. [0001]
  • BACKGROUND
  • Programming languages have become more powerful over time through the addition of features and capabilities. The increased power and capability of languages has been accompanied by an increase in complexity. As software increases in complexity, the development of software is becoming more and more difficult. Source code may exceed hundreds of pages in length and may involve the use of many different source code files and programming libraries. The number and complexity of functions available to a software developer has greatly increased. For example, multiple functions or methods within a class hierarchy may share the same name (or identifier), but have different numbers of parameters or different parameter types. A large number of identifiers may be used, including typedefs, variables, macros, parameters, namespaces, templates, attributes and so on. Each of these identifiers typically requires a type declaration and/or definition specified. Hence programming tools that make development efforts easier and more accurate are widely desired. [0002]
  • One way to make the task of the developer more manageable is to establish an Integrated Development Environment (IDE). These environments typically include browsers and editors enabling developers to edit multiple source files. For object oriented languages, the IDE may also provide a browser that enables a developer to navigate and view the class hierarchy. To further assist the programming effort an IDE may support some kind of on-line statement building mechanism such as the one described in U.S. Pat. No. 6,311,323 B1 issued Oct. 30, 2001, entitled “Computer Programming Language Statement Building and Information Tool”. A help information mechanism may enable a developer to refer to on-line documentation describing varying function definitions. In addition, an IDE may provide automatic help modules displaying reference information associated with identifiers and so on, as described in U.S. patent application Ser. No. 09/191,757, filed Nov. 13, 1998, entitled “Automated Help Information for Reference Information”. A completion module for auto-completion of programming statements may also be available within the IDE, as described in U.S. Pat. No. 6,305,008 B1, issued Oct. 16, 2001 entitled, “Automatic Statement Completion”. Such a tool may be invoked as a developer is writing code, and may display a list of potential completion candidates to the developer. The developer may then pick the desired candidate or continue typing, freeing the developer from having to consult printed or on-line documentation, class hierarchies or other source code files. [0003]
  • To date however, a tool that can intelligently understand what the user (e.g., developer) is doing and help the user accomplish the next set of tasks is not known. It would be helpful if there were a tool that could track the intentions of a user and proffer up a list of options of potential next tasks, based on the user's action. [0004]
  • SUMMARY OF THE INVENTION
  • A context-sensitive design time tool monitors user input during a program development or program maintenance operation and displays an icon when user input triggers a potential next task or tasks. Upon selection of the icon, the tool proffers a list of possible next tasks. Upon selection of an entry in the list, the task is automatically performed.[0005]
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • The foregoing summary, as well as the following detailed description of preferred embodiments, is better understood when read in conjunction with the appended drawings. For the purpose of illustrating the invention, there is shown in the drawings exemplary constructions of the invention; however, the invention is not limited to the specific methods and instrumentalities disclosed. In the drawings: [0006]
  • FIG. 1 is a block diagram of an exemplary computing environment in which aspects of the invention may be implemented; [0007]
  • FIG. 2 is a block diagram of a system that generates a context-sensitive list of potential next tasks in accordance with one embodiment of the invention; [0008]
  • FIG. 3 is a block diagram illustrating a representative screen shot of a section of source code in an editor, showing the appearance of an icon in accordance with one aspect of the invention; [0009]
  • FIG. 4 is a block diagram illustrating a representative screen shot of a section of source code in an editor, showing a list of potential tasks in accordance with one aspect of the invention; and [0010]
  • FIG. 5 is a flow diagram of a method for generating a context-sensitive list of potential next tasks in accordance with one embodiment of the invention.[0011]
  • DETAILED DESCRIPTION OF THE INVENTION
  • Exemplary Computing Environment [0012]
  • FIG. 1 and the following discussion are intended to provide a brief general description of a suitable computing environment in which the invention may be implemented. It should be understood, however, that handheld, portable, and other computing devices of all kinds are contemplated for use in connection with the present invention. While a general purpose computer is described below, this is but one example, and the present invention requires only a thin client having network server interoperability and interaction. Thus, the present invention may be implemented in an environment of networked hosted services in which very little or minimal client resources are implicated, e.g., a networked environment in which the client device serves merely as a browser or interface to the World Wide Web. [0013]
  • Although not required, the invention can be implemented via an application programming interface (API), for use by a developer, and/or included within the network browsing software which will be described in the general context of computer-executable instructions, such as program modules, being executed by one or more computers, such as client workstations, servers, or other devices. Generally, program modules include routines, programs, objects, components, data structures and the like that perform particular tasks or implement particular abstract data types. Typically, the functionality of the program modules may be combined or distributed as desired in various embodiments. Moreover, those skilled in the art will appreciate that the invention may be practiced with other computer system configurations. Other well known computing systems, environments, and/or configurations that may be suitable for use with the invention include, but are not limited to, personal computers (PCs), automated teller machines, server computers, hand-held or laptop devices, multi-processor systems, microprocessor-based systems, programmable consumer electronics, network PCs, minicomputers, mainframe computers, and the like. The invention may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network or other data transmission medium. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices. [0014]
  • FIG. 1 thus illustrates an example of a suitable computing system environment [0015] 100 in which the invention may be implemented, although as made clear above, the computing system environment 100 is only one example of a suitable computing environment and is not intended to suggest any limitation as to the scope of use or functionality of the invention. Neither should the computing environment 100 be interpreted as having any dependency or requirement relating to any one or combination of components illustrated in the exemplary operating environment 100.
  • With reference to FIG. 1, an exemplary system for implementing the invention includes a general purpose computing device in the form of a computer [0016] 110. Components of computer 110 may include, but are not limited to, a processing unit 120, a system memory 130, and a system bus 121 that couples various system components including the system memory to the processing unit 120. The system bus 121 may be any of several types of bus structures including a memory bus or memory controller, a peripheral bus, and a 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 (also known as Mezzanine bus).
  • Computer [0017] 110 typically includes a variety of computer readable media. Computer readable media can be any available media that can be accessed by computer 110 and includes both volatile and nonvolatile media, removable and non-removable media. By way of example, and not limitation, computer readable media may comprise computer storage media and communication media. Computer storage media includes both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CDROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by computer 110. Communication media typically embodies computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared, and other wireless media. Combinations of any of the above should also be included within the scope of computer readable media.
  • The system memory [0018] 130 includes computer storage media in the form of volatile and/or nonvolatile memory such as read only memory (ROM) 131 and random access memory (RAM) 132. A basic input/output system 133 (BIOS), containing the basic routines that help to transfer information between elements within computer 110, such as during start-up, is typically stored in ROM 131. RAM 132 typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by processing unit 120. By way of example, and not limitation, FIG. 1 illustrates operating system 134, application programs 135, other program modules 136, and program data 137.
  • The computer [0019] 110 may also include other removable/non-removable, volatile/nonvolatile computer storage media. By way of example only, FIG. 1 illustrates a hard disk drive 141 that reads from or writes to non-removable, nonvolatile magnetic media, a magnetic disk drive 151 that reads from or writes to a removable, nonvolatile magnetic disk 152, and an optical disk drive 155 that reads from or writes to a removable, nonvolatile optical disk 156, such as a CD ROM or other optical media. Other removable/non-removable, volatile/nonvolatile computer storage media that can be used in the exemplary operating environment include, but are not limited to, magnetic tape cassettes, flash memory cards, digital versatile disks, digital video tape, solid state RAM, solid state ROM, and the like. The hard disk drive 141 is typically connected to the system bus 121 through a non-removable memory interface such as interface 140, and magnetic disk drive 151 and optical disk drive 155 are typically connected to the system bus 121 by a removable memory interface, such as interface 150.
  • The drives and their associated computer storage media discussed above and illustrated in FIG. 1 provide storage of computer readable instructions, data structures, program modules and other data for the computer [0020] 110. In FIG. 1, for example, hard disk drive 141 is illustrated as storing operating system 144, application programs 145, other program modules 146, and program data 147. Note that these components can either be the same as or different from operating system 134, application programs 135, other program modules 136, and program data 137. Operating system 144, application programs 145, other program modules 146, and program data 147 are given different numbers here to illustrate that, at a minimum, they are different copies. A user may enter commands and information into the computer 110 through input devices such as a keyboard 162 and pointing device 161, commonly referred to as a mouse, trackball or touch pad. Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner, or the like. These and other input devices are often connected to the processing unit 120 through a user input interface 160 that is coupled to the system bus 121, but may be connected by other interface and bus structures, such as a parallel port, game port or a universal serial bus (USB).
  • A monitor [0021] 191 or other type of display device is also connected to the system bus 121 via an interface, such as a video interface 190. A graphics interface 182, such as Northbridge, may also be connected to the system bus 121. Northbridge is a chipset that communicates with the CPU, or host processing unit 120, and assumes responsibility for accelerated graphics port (AGP) communications. One or more graphics processing units (GPUs) 184 may communicate with graphics interface 182. In this regard, GPUs 184 generally include on-chip memory storage, such as register storage and GPUs 184 communicate with a video memory 186. GPUs 184, however, are but one example of a coprocessor and thus a variety of coprocessing devices may be included in computer 110. A monitor 191 or other type of display device is also connected to the system bus 121 via an interface, such as a video interface 190, which may in turn communicate with video memory 186. In addition to monitor 191, computers may also include other peripheral output devices such as speakers 197 and printer 196, which may be connected through an output peripheral interface 195.
  • The computer [0022] 110 may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 180. The remote computer 180 may be a personal computer, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to the computer 110, although only a memory storage device 181 has been illustrated in FIG. 1. The logical connections depicted in FIG. 1 include a local area network (LAN) 171 and a wide area network (WAN) 173, but may also include other networks. Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets and the Internet.
  • When used in a LAN networking environment, the computer [0023] 110 is connected to the LAN 171 through a network interface or adapter 170. When used in a WAN networking environment, the computer 110 typically includes a modem 172 or other means for establishing communications over the WAN 173, such as the Internet. The modem 172, which may be internal or external, may be connected to the system bus 121 via the user input interface 160, or other appropriate mechanism. In a networked environment, program modules depicted relative to the computer 110, or portions thereof, may be stored in the remote memory storage device. By way of example, and not limitation, FIG. 1 illustrates remote application programs 185 as residing on memory device 181. It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers may be used.
  • One of ordinary skill in the art can appreciate that a computer [0024] 110 or other client device can be deployed as part of a computer network. In this regard, the present invention pertains to any computer system having any number of memory or storage units, and any number of applications and processes occurring across any number of storage units or volumes. The present invention may apply to an environment with server computers and client computers deployed in a network environment, having remote or local storage. The present invention may also apply to a standalone computing device, having programming language functionality, interpretation and execution capabilities.
  • Context-Sensitive Help in a Development Environment [0025]
  • A context-sensitive design-time tool dynamically monitors user (e.g., developer) input during software development. When the tool intelligently determines a potential next task or tasks, an icon is generated. Upon selection of the icon, a list of potential next task(s) is displayed. Upon selection of an entry, the task is automatically performed. Automatically-performed tasks include, but are not limited to, automatically inserting code into a source program. [0026]
  • FIG. 2 is a block diagram illustrating an exemplary system for monitoring user input and proffering a list of potential next tasks in accordance with one embodiment of the invention. The system includes a context-sensitive potential next task determiner [0027] 205, a file/database 203 (optional), a language service 204 and an editor 202 within a design environment 201 for drafting and editing source code 206. Those of ordinary skill in the art will appreciate that the design environment 201 may also include other components, not shown in FIG. 2. Source code 206 typically is a set of instructions that a programmer or developer types or edits, and is written in a given programming language or combination of programming languages. Source code typically comprises one or more statements, each statement typically comprising one or more expressions and/or entities. The expressions and/or entities in the statement can be made up of multiple components. Source code 206 may be persisted onto a stable storage medium.
  • Editor [0028] 202 in one embodiment is part of an Integrated Development Environment (IDE) 201, and facilitates the development of the source code 206 of a computer program. Editor 202 may be a C++ editor, a C# editor, a Visual Basic editor, a J# editor or the like.
  • Language service [0029] 204 may be optimized for use with Visual C++ code, with Visual C# code, with Visual Basic code, with Visual Java# code or the like. The programming languages anticipated for inclusion in the list of available language services includes the above mentioned, COBOL and any other suitable languages associated with program development.
  • Language service [0030] 204 may include a dynamic parser as described in U.S. Pat. No. 6,367,068 B1 issued on Apr. 2, 2002, entitled “Dynamic Parsing”. Such a parser may operate to parse the source code 206 according to the parsing rules applicable to the programming language (e.g., a C++ parser, a C# parser, a Visual Basic parser, a J# parser or the like). The parser may parse only a subset of the source code, (e.g., the current function or method being edited). The parser may include heuristics to ignore certain non-fatal errors, such as but not limited to missing statement terminators, missing closing parenthesis, missing function terminators and the like. Similarly language service 204 may include an automatic statement completion module, an automated help module and/or a statement building and information tool as described above.
  • Language service [0031] 204 may include a compiler, such as but not limited to, a C++ compiler, a C# compiler, a Visual Basic compiler and/or a J# compiler. Typically a compiler includes a parser and a component that builds executable code. A parser receives input in the form of sequential source program instructions, interactive online commands, markup tags, or some other defined interface and breaks them up into parts. For example a parser may break source code into nouns (objects), verbs (methods), and their attributes or options. A parser may also check to see that all necessary input has been provided.
  • Language service [0032] 204 preferably includes context-sensitive tool 205. Alternatively, the context-sensitive tool may exist external to language service 204. The context-sensitive next-task help tool 205 parses user keystrokes for a triggering character or sequence of characters, as the keystrokes are input. Upon detection of a triggering character or sequence of characters, the tool determines potential next tasks.
  • For example, in the case of adding method stubs to an interface, entering the interface name as part of the class definition is the triggering event. [0033]
  • For example, suppose the user types: [0034]
  • class CFoo : public IBar [0035]
  • the input of “IBar” following “class Cfoo : public ” triggers the display of an icon. Upon further user input, as described below, the automatic addition of stubs for all the methods of IBar can be effected. [0036]
  • As another example, assume that a developer has written an interface such as the following: [0037]
    interface IEmployee
    {
    string Name { get; set; }
    int Age { get; set; }
    }
  • Assume also, that the developer has written several classes that implement this interface. Each of these classes therefore have a ‘Name’ property and an ‘Age’ property, as required by the contract of the interface. [0038]
  • Next, say the developer realizes that the IEmployee interface also needs a ‘Salary’ property. Using the code editor, the developer may change the interface to look like this: [0039]
    interface IEmployee
    {
    string Name { get; set; }
    int Age { get; set; }
    decimal Salary { get; set; }
    }
  • At the point when the newly added property is complete in the editor, an icon would appear, and when clicked or otherwise selected, an option to automatically add stub implementations of the ‘Salary’ property to all classes that implement Iemployee would be displayed. [0040]
  • Another exemplary triggering sequence is usage of some specific API (Application Programming Interface) such as “SQLConnect”. Entering “SQLConnect” indicates that the next set of tasks to be performed is to use the SQL connection to retrieve or input data to the database. It should be understood that the particular examples are exemplary only and other suitable triggering sequences are contemplated. [0041]
  • In determining potential next tasks, file/database [0042] 203 may be accessed. File/database 203 may include information on entities in the source code. File/database 203 typically is a file comprising a database that, in one embodiment of the invention, is used by the parser to store information including, but not limited to, class definitions, member data types, and reference information such as source file names and line numbers where an identifier, token, or function name is defined or referenced, as described in co-pending application Attorney Docket No. MSFT-1249 filed concurrently herewith, entitled “System and Method for Browse Information Parsing Without Compilation”, and is populated and maintained by the parser. File/database 203 typically also includes information not only from source code 206, but also includes information from other sources including system header files, Microsoft Foundation Class (MFC) header files and ActiveX Template Libraries (ATL), all of which are known in the art. In one embodiment of the invention, file/database 203 is referred to as a No Compile Browse (NCB) file. File/database 203 may include a compiler symbol table (for example, a C# or J# symbol table stored in a database), or a separate file (for example, a C++ file generated by a portion of the language service 204). Alternatively, a file or database in memory (not shown) may be accessed, (for example, a Visual Basic compiler symbol table stored in a database in memory). Tables, files, databases and the like, whether stored in memory on persisted to a stable storage medium are contemplated by the invention. Alternatively, file/database 203 while appearing as one database to the user, actually may be comprised of multiple stores or databases. For example, a first database (e.g., a project database) may be dynamically updated by the parser, as described above. In addition, the pre-built database may contain information that seldom changes, such as the operating system definitions and header files, and MFC/ATL class definitions and header files referred to above. Those of ordinary skill in the art will recognize that other class definitions and header files could be included in the pre-built database. One or more pre-built databases may exist.
  • Continuing the example described above, in which method stubs for an interface can be automatically generated, assume the following line of code was entered: [0043]
  • class CFoo : public IBar [0044]
  • Upon entering “IBar” following “class CFoo : public ”, the methods of IBar are retrieved by accessing database [0045] 203. In this case database 203 includes a list of all the methods of IBar.
  • As another example, assume the developer is authoring a new class, and declares it to implement an interface called ‘IEnumerable’. At this point in accordance with one embodiment of the invention, an icon would be displayed, which, upon selection, provides an entry offering to provide stub implementations of all the members of IEnumerable to the new class, since that is a requirement of implementing the interface. The database [0046] 203 contains the information about the interface IEnumerable, including the names and signatures of the methods it has, what interfaces it extends, etc. It should be understood that the examples recited above are exemplary only and any suitable content for and use of database 203 is contemplated by the invention.
  • Thus, in accordance with one embodiment of the invention, the system of FIG. 2 operates as follows. A user (e.g., a developer) drafts source code [0047] 206 with editor 202. As the developer generates the source code 206, one of the components of IDE 201 detects an event and invokes context-sensitive help module 205. Context-sensitive help module 205 then displays an icon. If the icon is selected, context-sensitive help module 205 parses the code fragment using information from file/database 203 to provide context-sensitive choices to the developer concerning potential next-tasks. Upon selection of one or more entries, the task or tasks associated with the entry or entries is performed. In one embodiment of the invention, the event invoking the context-sensitive help module 205 is the entry of certain pre-determined programming-language-defined constructs.
  • The icon in one embodiment of the invention is displayed in the editor near the triggering character or sequence of characters. In response to user selection of the icon by positioning a cursor over the icon or by selecting the icon in other ways known in the art, a window is generated, displaying a list. The list preferably includes one or more potential next task(s). Upon selection of an entry or a series of entries in the list by clicking on the entry (or entries) or by selecting the entry (or entries) using other ways known in the art, the task associated with the list entry is automatically performed. [0048]
  • FIG. 3 is a block diagram illustrating a representative screen shot of a section of source code in an editor, showing the appearance of an icon in accordance with one aspect of the invention. FIG. 4 is a block diagram illustrating a representative screen shot of a section of source code in an editor, showing a list of potential tasks in accordance with one aspect of the invention. [0049]
  • Within a design environment such as an Integrated Design Environment (IDE) [0050] 201, a C++ editor 202 enables the creation or editing of C++ source code 306 as depicted in window 308. Source code 306 is displayed within window 308. Context-sensitive help tool 205 generates icon 302 when triggered by the keystrokes input by the user. Upon selection of icon 302, icon 302 is dismissed and a list 402 of potential tasks is displayed.
  • For example, assume that a developer is writing C++ code using the C++ language service [0051] 202. Assume a public interface class: “IFoo” exists in database 203, interface IFoo having two member methods, method1 and method2. Because IFoo is an interface, method1 and method2 are pure methods and are not implemented. If, for example, a user types “class MyClass : public IFoo {” into source code 306, the context-sensitive tool will detect that the user may intend to implement the IFoo interface so that the pure virtual methods of IFoo will need to be overridden in MyClass. Context-sensitive help tool 205 is triggered by the colon, the colon indicating to the tool 205 that the word that follows, (i.e., “IFoo”) probably is a class such as an interface or base class). The tool includes heuristics for determining possible next tasks (i.e., implement the interface by overriding any pure methods of interface IFoo) and thereby determines that the user will probably want to write function bodies for method1 and method2. Upon determining the possible next task or tasks, the tool displays an icon 302 in the vicinity of the user input, indicating that a potential next task has been determined. Upon selection of the icon by hovering the cursor over the icon, or otherwise selecting the icon using methods known in the art, the user is prompted with a statement such as but not limited to: “Do you want to implement stubs for interface IFoo?”. Upon selection of the entry, or otherwise indicating assent, using methods known in the art, the function body stub code would be automatically generated in the user's source code instance. For example, in this case, the following code may be generated:
    void method1 ()
    {
    }
    void method2 ()
    {
    }
  • eliminating the need for the user to type in this code, and eliminating any mistakes the user might make in the process, and potentially increasing the productivity of the developer. [0052]
  • In the case of MFC/ATL in C++, accepting the icon's changes preferably would also involve making the appropriate changes to the COM map, a macro wrapped structure used to track all the interfaces implemented by a given class. While the example above relates to interfaces, it will be understood that the tool is intended to handle regular base classes as well as interfaces. With base classes, a subset or all of the base's virtual methods can be overridden. [0053]
  • Similarly, it should be understood that although the above example is simple, to aid in understanding, the generation of code is not restricted to beginning and ending braces. For example, perhaps method1 is defined with attribute “integer”. In this case, the return type, in accordance with C++ programming conventions, is an integer, which is reflected in the code generated by the tool. For example, in this case, the tool may generate the following: [0054]
    int method1 ()
    {
    return 0;
    }
  • Alternatively, the return type may be HRESULT, resulting in generation of: [0055]
    HRESULT method1 ()
    {
    result S_OK;
    }
  • Similarly, if method1 has an input parameter of int i and an output parameter of an integer pointer, (method1 ([in] int i, [out] int *p); the tool may generate code to make sure that p is not equal to null, and may initialize the pointer so that the following may be generated by the tool: [0056]
    HRESULT method1 (int i, int *p);
    {
    assert (p ≠ null);
    *p=0;
    }
  • As much of the function body can be generated as can be determined from the information available. In addition, for example, address modifiers and parameters and the like can be generated. [0057]
  • As another example, in C#, interfaces may be implemented publicly or privately. When stubs are generated, methods can be marked private, in which case the method can only be called by casting an object to that specific interface. The context-sensitive tool provides the option of generating either. [0058]
  • When typing code to make a connection to a database (e.g., SQL/OleDB), the context-sensitive tool generates code to retrieve a dataset and subsequently close the database, using ATL or SQL or other suitable database-handling languages. For example, suppose a user types the following connection string into source code: [0059]
  • SQL Connect (“Database=MySQL, user=Shankar, PWD=“hello”). [0060]
  • The context-sensitive tool, triggered in this case by the reference to a database and user followed by the sequence of letter “PWD”, denoting “password”, generates an icon which, when selected, proffers the option of hiding the password in a registry, for example. Upon selection of the option, code including that code needed to create the necessary user classes, etc. is generated, the appropriate existing code is removed and replaced with the tool-generated code. [0061]
  • When typing code, if a user sees a squiggly, a wavy line commonly used to denote an error condition of some sort, and hovers over the squiggly, the context-sensitive tool preferably generates an icon proffering ways to correct the code. The fix may include adding a missing semicolon or closing brace, or identifying and correcting a typographical error in an undefined type. Alternatively, Knowledge Base (KB) articles (a good source of information regarding common issues or questions) or websites such as www.msdn.com may be accessed by establishing a connection to the Internet to identify an appropriate correction. [0062]
  • When typing in a declaration of a function or method or other element, implementation can be automatically generated by accessing files generated by a compiler or dynamic parser. [0063]
  • Wizards presently invoked by identifying a correct node and right-clicking on classview followed by filling in requested information are preferably eliminated by providing an option in the list to perform the task previously performed by the wizard. [0064]
  • Preferably, the IDE is open such that third parties can author their own language services, thereby augmenting the features of the standard text editor to conform to their language (such as colorization of their syntax elements, providing formatting and automatic indent capabilities, and the like). Language services are also employed in the environment to provide information to the various browsers and help systems, and also to provide useful information to the debugger if appropriate. In the context of this invention, the language service is given the opportunity to make use of the context-sensitive help functionality in accordance with one embodiment of the invention so as to present the “next-task” options while editing. [0065]
  • FIG. 5 is a flow diagram of a method of providing context-sensitive help in accordance with one embodiment of the invention. At step [0066] 501, as source code is entered or edited, each keystroke or sequence of keystrokes is parsed to determine if the keystroke or sequence of keystrokes is a context-sensitive help trigger.
  • At step [0067] 503, if it is determined that the keystroke or sequence of keystrokes is not a context-sensitive help trigger, processing returns to step 501. At step 503, if it is determined that the keystroke or sequence of keystrokes is a context-sensitive help trigger, a context-sensitive help icon is generated and displayed close to the triggering keystroke(s) at step 505. At step 507, if the icon is not selected within a designated time period, the icon is dismissed at step 509 and processing returns to step 501. At step 507, if the icon is selected, a list of entries is generated and displayed at step 511. The list of entries includes possible next actions that a user might take. If one or more of the entries is selected at step 513, the action associated with the entry or entries is performed at step 515 and a section of code within a source code file may be added or a section of code originally included within the source code file may be removed and replaced with a section of code generated by the context-sensitive help engine or a section of code originally included within the source code file may be modified.
  • For example, suppose a user is modifying the declaration/definition of a type or method, an icon may be displayed. Upon selection of the icon, an entry may be displayed suggesting to modify all the places where the type/method is being referenced. Upon selection of the action, all the places where the type/method are referenced are modified. It should be understood that the example cited is merely exemplary and any suitable actions and entries are contemplated by the invention. [0068]
  • If an entry is not selected at step [0069] 513, the list is dismissed at step 517, after a specified period of time or upon positioning the cursor elsewhere, and processing returns to step 501.
  • CONCLUSION
  • It is noted that the foregoing examples have been provided merely for the purpose of explanation and are in no way to be construed as limiting of the present invention. While the invention has been described with reference to various embodiments, it is understood that the words which have been used herein are words of description and illustration, rather than words of limitation. Further, although the invention has been described herein with reference to particular means, materials and embodiments, the invention is not intended to be limited to the particulars disclosed herein; rather, the invention extends to all functionally equivalent structures, methods and uses, such as are within the scope of the appended claims. Those skilled in the art, having the benefit of the teachings of this specification, may effect numerous modifications thereto and changes may be made without departing from the scope and spirit of the invention in its aspects. [0070]

Claims (25)

    What is claimed is:
  1. 1. A method of providing context-sensitive help for potential next-tasks in a development environment, the method comprising:
    displaying at least a section of source code for a computer program, said section of source code including an entity associated with a pre-determined event;
    detecting the pre-determined event;
    determining at least one potential task associated with the pre-determined event; and
    displaying an icon proximate to the at least one section of source code.
  2. 2. The method of claim 1, further comprising:
    upon selection of the icon, displaying at least one entry associated with an action.
  3. 3. The method of claim 2, further comprising, upon selection of the at least one entry, performing the action associated with the at least one entry.
  4. 4. The method of claim 3, wherein performing the action associated with the at least one entry comprises inserting a section of code into the source program.
  5. 5. The method of claim 3, wherein performing the action associated with the at least one entry comprises removing a section of code from the source program.
  6. 6. The method of claim 3, wherein performing the action associated with the at least one entry comprises modifying a section of code from the source program.
  7. 7. The method of claim 3, wherein performing the action associated with the at least one entry comprises modifying a file associated with the action.
  8. 8. The method of claim 1, wherein the section of source code is displayed utilizing an editor.
  9. 9. The method of claim 1, wherein the pre-determined event comprises detecting entry of one of a triggering character or a triggering sequence of characters.
  10. 10. The method of claim 9, wherein the triggering character or triggering sequence of characters is a separator.
  11. 11. The method of claim 1, wherein the icon is selectable by one of hovering a cursor over the icon and clicking on the icon.
  12. 12. The method of claim 2, wherein the at least one entry is displayed proximate to the section of source code.
  13. 13. The method of claim 2, wherein the at least one entry is selectable by clicking on the entry.
  14. 14. A system for providing context-sensitive help in a development environment for potential next tasks in a development environment, the system comprising:
    an editor to provide for developing source code for a computer, the source code including at least one entity;
    a datastore including information associated with the at least one entity;
    a language service for parsing the source code and generating information for the datastore; and
    an option-generator for determining at least one potential next task.
  15. 15. The system of claim 14, wherein the language service further comprises a C++ parser.
  16. 16. The system of claim 14, wherein the language service comprises a C# parser.
  17. 17. The system of claim 14, wherein the language service comprises a J# parser.
  18. 18. The system of claim 14, wherein the language service comprises a Visual Basic parser.
  19. 19. The system of claim 14, wherein the option-generator includes a set of heuristics for determining potential next tasks.
  20. 20. The system of claim 14, wherein the datastore includes a dynamically updated component and a pre-built component.
  21. 21. The system of claim 14, wherein the option-generator further comprises means for displaying an icon next to the modifiable code.
  22. 22. The system of claim 14, wherein the option-generator further comprises means for selecting at least one of a list of next tasks to be performed, the at least one of the list associated with inserting code in a source program.
  23. 23. The system of claim 22, further comprising inserting the code associated with the selected one of the list of next tasks into the source program.
  24. 24. A computer-readable medium including computer-executable instructions for:
    developing at least a section of source code for a computer program, said section of source code including an entity associated with a pre-determined event;
    detecting the pre-determined event;
    determining at least one potential task associated with the pre-determined event;
    displaying an icon proximate to the at least one section of source code; and
    upon selection of the icon, displaying at least one entry associated with an action.
  25. 25. The computer-readable medium of claim 24, further comprising computer-readable instructions for in response to receiving a selection of the at least one entry, performing the action associated with the at least one entry.
US10218222 2002-08-12 2002-08-12 System and method for context-sensitive help in a design environment Abandoned US20040031017A1 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
US10218222 US20040031017A1 (en) 2002-08-12 2002-08-12 System and method for context-sensitive help in a design environment

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US10218222 US20040031017A1 (en) 2002-08-12 2002-08-12 System and method for context-sensitive help in a design environment
US11672558 US7937688B2 (en) 2002-08-12 2007-02-08 System and method for context-sensitive help in a design environment

Related Child Applications (1)

Application Number Title Priority Date Filing Date
US11672558 Continuation US7937688B2 (en) 2002-08-12 2007-02-08 System and method for context-sensitive help in a design environment

Publications (1)

Publication Number Publication Date
US20040031017A1 true true US20040031017A1 (en) 2004-02-12

Family

ID=31495260

Family Applications (2)

Application Number Title Priority Date Filing Date
US10218222 Abandoned US20040031017A1 (en) 2002-08-12 2002-08-12 System and method for context-sensitive help in a design environment
US11672558 Active 2025-05-03 US7937688B2 (en) 2002-08-12 2007-02-08 System and method for context-sensitive help in a design environment

Family Applications After (1)

Application Number Title Priority Date Filing Date
US11672558 Active 2025-05-03 US7937688B2 (en) 2002-08-12 2007-02-08 System and method for context-sensitive help in a design environment

Country Status (1)

Country Link
US (2) US20040031017A1 (en)

Cited By (14)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20040123186A1 (en) * 2002-12-21 2004-06-24 Kulp Richard L. Fault-tolerant dynamic editing of GUI display and source code
US20050235255A1 (en) * 2004-04-20 2005-10-20 International Business Machines Corporation Method and system for switching between prototype and real code production in a graphical call flow builder
US20060041870A1 (en) * 2004-08-19 2006-02-23 Microsoft Corporation Systems and methods for varying software build properties using primary and supplemental build files
US20060041879A1 (en) * 2004-08-19 2006-02-23 Bower Shelley K System and method for changing defined user interface elements in a previously compiled program
US20070192740A1 (en) * 2006-02-10 2007-08-16 Jobling Jeremy T Method and system for operating a device
US20070288867A1 (en) * 2006-06-09 2007-12-13 Srimanth Gunturi Visual helps while using code assist in visual tools
US20080126932A1 (en) * 2006-09-14 2008-05-29 Rafi Elad GUI modeling of knowledge base in a modeling environment
EP1962185A2 (en) 2007-01-18 2008-08-27 Sap Ag Condition editor for business process management and business activity monitoring
US20090254880A1 (en) * 2008-04-03 2009-10-08 Microsoft Corporation Techniques for offering and applying code modifications
US20100235730A1 (en) * 2009-03-13 2010-09-16 Microsoft Corporation Consume-first mode text insertion
US7865870B2 (en) 2004-07-29 2011-01-04 International Business Machines Corporation Automatic content completion of valid values for method argument variables
US8464148B1 (en) * 2011-06-29 2013-06-11 Google Inc. Intelligent editing of web pages in a web browser
US8745581B2 (en) 2010-06-21 2014-06-03 Touch Technologies, Inc. Method and system for selectively copying portions of a document contents in a computing system (smart copy and paste
US20170123766A1 (en) * 2015-10-30 2017-05-04 International Business Machines Corporation Gui-driven symbol management and code generator

Families Citing this family (23)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
WO2007122639B1 (en) * 2006-04-26 2008-12-04 Ravindra Naik A system and method for pattern based services extraction
US8453104B2 (en) * 2006-10-27 2013-05-28 Microsoft Corporation Thin client software development environment
US20090328000A1 (en) * 2007-05-07 2009-12-31 Nextair Corporation System, apparatus and method for programming a computing device
US8146059B2 (en) * 2007-12-12 2012-03-27 International Business Machines Corporation Feeding test metrics into an integrated development environment to aid software developers to improve code quality
US20090217254A1 (en) * 2008-02-22 2009-08-27 Microsoft Corporation Application level smart tags
US8635593B2 (en) * 2008-05-13 2014-01-21 Hewlett-Packard Development Company, L.P. Dynamic autocompletion tool
US8979538B2 (en) * 2009-06-26 2015-03-17 Microsoft Technology Licensing, Llc Using game play elements to motivate learning
US20100331075A1 (en) * 2009-06-26 2010-12-30 Microsoft Corporation Using game elements to motivate learning
US9141344B2 (en) * 2010-02-05 2015-09-22 Red Hat, Inc. Hover help support for application source code
US8621438B2 (en) * 2010-02-22 2013-12-31 Red Hat, Inc. Generating debug information on demand
US9697500B2 (en) 2010-05-04 2017-07-04 Microsoft Technology Licensing, Llc Presentation of information describing user activities with regard to resources
US8667456B1 (en) * 2011-04-20 2014-03-04 Google Inc. Cloud-based indexing for integrated development environments
US8819009B2 (en) 2011-05-12 2014-08-26 Microsoft Corporation Automatic social graph calculation
US9477574B2 (en) 2011-05-12 2016-10-25 Microsoft Technology Licensing, Llc Collection of intranet activity data
US9026446B2 (en) 2011-06-10 2015-05-05 Morgan Fiumi System for generating captions for live video broadcasts
US8532469B2 (en) 2011-06-10 2013-09-10 Morgan Fiumi Distributed digital video processing system
US8749618B2 (en) 2011-06-10 2014-06-10 Morgan Fiumi Distributed three-dimensional video conversion system
US9383973B2 (en) * 2011-06-29 2016-07-05 Microsoft Technology Licensing, Llc Code suggestions
WO2013077846A1 (en) * 2011-11-21 2013-05-30 Hewlett-Packard Development Company, L.P. Management of context-sensitive help links
WO2014117241A1 (en) * 2013-02-04 2014-08-07 602531 British Columbia Ltd. Data retrieval by way of context-sensitive icons
US20140310681A1 (en) * 2013-04-12 2014-10-16 Microsoft Corporation Assisted creation of control event
US20160295463A1 (en) * 2015-03-30 2016-10-06 Wipro Limited System and method for software reuse
US9733933B1 (en) 2016-09-19 2017-08-15 International Business Machines Corporation Automatic comment editing for a smart integrated development environment

Citations (17)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4674065A (en) * 1982-04-30 1987-06-16 International Business Machines Corporation System for detecting and correcting contextual errors in a text processing system
US5267155A (en) * 1989-10-16 1993-11-30 Medical Documenting Systems, Inc. Apparatus and method for computer-assisted document generation
US5392386A (en) * 1994-02-03 1995-02-21 Inter Hi-Tec Ag Method and apparatus for adding functionality to computer programs executing under graphical user interfaces
US5452449A (en) * 1991-07-03 1995-09-19 Itt Corporation Interactive multi-module source code analyzer that matches and expands call and entry statement parameters
US5815830A (en) * 1994-12-23 1998-09-29 Anthony; Andre Charles Automatic generation of hypertext links to multimedia topic objects
US5859636A (en) * 1995-12-27 1999-01-12 Intel Corporation Recognition of and operation on text data
US5946647A (en) * 1996-02-01 1999-08-31 Apple Computer, Inc. System and method for performing an action on a structure in computer-generated data
US6085201A (en) * 1996-06-28 2000-07-04 Intel Corporation Context-sensitive template engine
US6122647A (en) * 1998-05-19 2000-09-19 Perspecta, Inc. Dynamic generation of contextual links in hypertext documents
US6163879A (en) * 1998-08-20 2000-12-19 Iomega Corporation Interface and method for facilitating writing and modifying of lines of programming code
US6269475B1 (en) * 1997-06-02 2001-07-31 Webgain, Inc. Interface for object oriented programming language
US6305008B1 (en) * 1998-11-13 2001-10-16 Microsoft Corporation Automatic statement completion
US6311323B1 (en) * 1997-05-27 2001-10-30 Microsoft Corporation Computer programming language statement building and information tool
US6314559B1 (en) * 1997-10-02 2001-11-06 Barland Software Corporation Development system with methods for assisting a user with inputting source code
US6367068B1 (en) * 1998-11-13 2002-04-02 Microsoft Corporation Dynamic parsing
US6502233B1 (en) * 1998-11-13 2002-12-31 Microsoft Corporation Automated help system for reference information
US6697825B1 (en) * 1999-11-05 2004-02-24 Decentrix Inc. Method and apparatus for generating and modifying multiple instances of element of a web site

Family Cites Families (25)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4796179A (en) * 1986-08-20 1989-01-03 Integrated Systems, Inc. Multirate real time control system code generator
US5699310A (en) * 1990-06-29 1997-12-16 Dynasty Technologies, Inc. Method and apparatus for a fully inherited object-oriented computer system for generating source code from user-entered specifications
US5522079A (en) * 1993-06-14 1996-05-28 International Business Machines Corporation Compiler merging new and preexisting modules while preserving function order
WO1995003586A1 (en) * 1993-07-21 1995-02-02 Persistence Software, Inc. Method and apparatus for generation of code for mapping relational data to objects
US5813019A (en) * 1995-07-06 1998-09-22 Sun Microsystems, Inc. Token-based computer program editor with program comment management
US6182274B1 (en) * 1997-05-01 2001-01-30 International Business Machines Corporation Reusing code in object-oriented program development
US6066181A (en) * 1997-12-08 2000-05-23 Analysis & Technology, Inc. Java native interface code generator
WO2000070531A3 (en) * 1999-05-17 2001-07-12 Foxboro Co Methods and apparatus for control configuration
US6289513B1 (en) * 1999-06-01 2001-09-11 Isaac Bentwich Interactive application generation and text processing
US6571232B1 (en) * 1999-11-01 2003-05-27 Sun Microsystems, Inc. System and method for browsing database schema information
US6681383B1 (en) * 2000-04-04 2004-01-20 Sosy, Inc. Automatic software production system
US6968536B2 (en) * 2000-07-14 2005-11-22 Borland Software Corporation Frame component container
DE10041111A1 (en) * 2000-08-22 2002-03-14 Infineon Technologies Ag Reworking computer program acquired in programming language involves computer searching program for predefined rule damage, computing potential correction, altering program
US6788317B2 (en) * 2001-05-18 2004-09-07 Sun Microsystems, Inc. Generation of delegating implementation for IDL interfaces which use inheritance
US7017148B2 (en) * 2001-07-10 2006-03-21 Intel Corporation Apparatus and method for UPnP device code generation using XML
US7325194B2 (en) * 2002-05-07 2008-01-29 Microsoft Corporation Method, system, and apparatus for converting numbers between measurement systems based upon semantically labeled strings
US7707496B1 (en) * 2002-05-09 2010-04-27 Microsoft Corporation Method, system, and apparatus for converting dates between calendars and languages based upon semantically labeled strings
US20030221184A1 (en) * 2002-05-22 2003-11-27 Gunjal Atul Narayan Template-based application development system
US7707024B2 (en) * 2002-05-23 2010-04-27 Microsoft Corporation Method, system, and apparatus for converting currency values based upon semantically labeled strings
US7742048B1 (en) * 2002-05-23 2010-06-22 Microsoft Corporation Method, system, and apparatus for converting numbers based upon semantically labeled strings
US20030233632A1 (en) * 2002-06-12 2003-12-18 Lockheed Martin Corporation Automatically generated client application source code using database table definitions
US7003522B1 (en) * 2002-06-24 2006-02-21 Microsoft Corporation System and method for incorporating smart tags in online content
US7065745B2 (en) * 2002-12-16 2006-06-20 Sun Microsystems, Inc. System and method for evaluating and executing hierarchies of rules
US7346892B2 (en) * 2003-05-27 2008-03-18 Microsoft Corporation Prediction and pre-selection of an element in syntax completion
US20060090154A1 (en) * 2004-10-07 2006-04-27 International Business Machines Corp. System and method for contributing remote object content to an integrated development environment type-ahead

Patent Citations (17)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4674065A (en) * 1982-04-30 1987-06-16 International Business Machines Corporation System for detecting and correcting contextual errors in a text processing system
US5267155A (en) * 1989-10-16 1993-11-30 Medical Documenting Systems, Inc. Apparatus and method for computer-assisted document generation
US5452449A (en) * 1991-07-03 1995-09-19 Itt Corporation Interactive multi-module source code analyzer that matches and expands call and entry statement parameters
US5392386A (en) * 1994-02-03 1995-02-21 Inter Hi-Tec Ag Method and apparatus for adding functionality to computer programs executing under graphical user interfaces
US5815830A (en) * 1994-12-23 1998-09-29 Anthony; Andre Charles Automatic generation of hypertext links to multimedia topic objects
US5859636A (en) * 1995-12-27 1999-01-12 Intel Corporation Recognition of and operation on text data
US5946647A (en) * 1996-02-01 1999-08-31 Apple Computer, Inc. System and method for performing an action on a structure in computer-generated data
US6085201A (en) * 1996-06-28 2000-07-04 Intel Corporation Context-sensitive template engine
US6311323B1 (en) * 1997-05-27 2001-10-30 Microsoft Corporation Computer programming language statement building and information tool
US6269475B1 (en) * 1997-06-02 2001-07-31 Webgain, Inc. Interface for object oriented programming language
US6314559B1 (en) * 1997-10-02 2001-11-06 Barland Software Corporation Development system with methods for assisting a user with inputting source code
US6122647A (en) * 1998-05-19 2000-09-19 Perspecta, Inc. Dynamic generation of contextual links in hypertext documents
US6163879A (en) * 1998-08-20 2000-12-19 Iomega Corporation Interface and method for facilitating writing and modifying of lines of programming code
US6305008B1 (en) * 1998-11-13 2001-10-16 Microsoft Corporation Automatic statement completion
US6367068B1 (en) * 1998-11-13 2002-04-02 Microsoft Corporation Dynamic parsing
US6502233B1 (en) * 1998-11-13 2002-12-31 Microsoft Corporation Automated help system for reference information
US6697825B1 (en) * 1999-11-05 2004-02-24 Decentrix Inc. Method and apparatus for generating and modifying multiple instances of element of a web site

Cited By (29)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7331042B2 (en) * 2002-12-21 2008-02-12 International Business Machines Corporation Fault-tolerant dynamic editing of GUI display and source code
US20040123186A1 (en) * 2002-12-21 2004-06-24 Kulp Richard L. Fault-tolerant dynamic editing of GUI display and source code
US20050235255A1 (en) * 2004-04-20 2005-10-20 International Business Machines Corporation Method and system for switching between prototype and real code production in a graphical call flow builder
US7797676B2 (en) * 2004-04-20 2010-09-14 International Business Machines Corporation Method and system for switching between prototype and real code production in a graphical call flow builder
US7865870B2 (en) 2004-07-29 2011-01-04 International Business Machines Corporation Automatic content completion of valid values for method argument variables
US20060041879A1 (en) * 2004-08-19 2006-02-23 Bower Shelley K System and method for changing defined user interface elements in a previously compiled program
US8701083B2 (en) 2004-08-19 2014-04-15 Microsoft Corporation Systems and methods for varying software build properties using primary and supplemental build files
US20100313180A1 (en) * 2004-08-19 2010-12-09 Microsoft Corporation Systems and methods for varying software build properties using primary and supplemental build files
US20060041870A1 (en) * 2004-08-19 2006-02-23 Microsoft Corporation Systems and methods for varying software build properties using primary and supplemental build files
US7802228B2 (en) 2004-08-19 2010-09-21 Microsoft Corporation Systems and methods for varying software build properties using primary and supplemental build files
US20070192740A1 (en) * 2006-02-10 2007-08-16 Jobling Jeremy T Method and system for operating a device
US8108796B2 (en) * 2006-02-10 2012-01-31 Motorola Mobility, Inc. Method and system for operating a device
US20070288867A1 (en) * 2006-06-09 2007-12-13 Srimanth Gunturi Visual helps while using code assist in visual tools
US7568162B2 (en) * 2006-06-09 2009-07-28 International Business Machines Corporation Visual helps while using code assist in visual tools
US8527939B2 (en) * 2006-09-14 2013-09-03 Sap Ag GUI modeling of knowledge base in a modeling environment
US20080126932A1 (en) * 2006-09-14 2008-05-29 Rafi Elad GUI modeling of knowledge base in a modeling environment
US8732595B2 (en) 2007-01-18 2014-05-20 Sap Ag Condition editor for business process management and business activity monitoring
EP1962185A2 (en) 2007-01-18 2008-08-27 Sap Ag Condition editor for business process management and business activity monitoring
EP1962185A3 (en) * 2007-01-18 2009-04-29 Sap Ag Condition editor for business process management and business activity monitoring
US8245186B2 (en) 2008-04-03 2012-08-14 Microsoft Corporation Techniques for offering and applying code modifications
US20090254880A1 (en) * 2008-04-03 2009-10-08 Microsoft Corporation Techniques for offering and applying code modifications
US20100235730A1 (en) * 2009-03-13 2010-09-16 Microsoft Corporation Consume-first mode text insertion
US8745581B2 (en) 2010-06-21 2014-06-03 Touch Technologies, Inc. Method and system for selectively copying portions of a document contents in a computing system (smart copy and paste
US8464148B1 (en) * 2011-06-29 2013-06-11 Google Inc. Intelligent editing of web pages in a web browser
US20170123766A1 (en) * 2015-10-30 2017-05-04 International Business Machines Corporation Gui-driven symbol management and code generator
US20170123763A1 (en) * 2015-10-30 2017-05-04 International Business Machines Corporation Gui-driven symbol management and code generator
US9851955B2 (en) * 2015-10-30 2017-12-26 International Business Machines Corporation GUI-driven symbol management and code generator
US9921812B2 (en) * 2015-10-30 2018-03-20 International Business Machines Corporation GUI-driven symbol management and code generator
US9971572B2 (en) 2015-10-30 2018-05-15 International Business Machines Corporation GUI-driven symbol management and code generator

Also Published As

Publication number Publication date Type
US7937688B2 (en) 2011-05-03 grant
US20070168909A1 (en) 2007-07-19 application

Similar Documents

Publication Publication Date Title
Richters et al. Validating UML models and OCL constraints
Ousterhout et al. Tcl and the Tk toolkit
US6598052B1 (en) Method and system for transforming a textual form of object-oriented database entries into an intermediate form configurable to populate an object-oriented database for sending to java program
US7370275B2 (en) System and method for providing context to an input method by tagging existing applications
US6259445B1 (en) Computer-based documentation and instruction
US7334216B2 (en) Method and apparatus for automatic generation of information system user interfaces
US6574792B1 (en) Dynamically generating expanded user messages in a computer system
US7694272B2 (en) Method, a language and a system for the definition and implementation of software solutions by using a visualizable computer executable modeling language
Cunningham et al. Developing language processing components with GATE version 7 (a user guide)
US6606632B1 (en) Transforming transient contents of object-oriented database into persistent textual form according to grammar that includes keywords and syntax
US5999942A (en) Method and apparatus for enforcement of behavior of application processing systems without modifying application processing systems
Black et al. Pharo by example
Martelli Python in a Nutshell
US8332828B2 (en) System for translating diverse programming languages
US6356920B1 (en) Dynamic, hierarchical data exchange system
US6269475B1 (en) Interface for object oriented programming language
Nentwich et al. Flexible consistency checking
US20030200537A1 (en) Apparatus and method for using database knowledge to optimize a computer program
US5761510A (en) Method for error identification in a program interface
US6781609B1 (en) Technique for flexible inclusion of information items and various media types in a user interface
US8032860B2 (en) Methods for type-independent source code editing
US20070011651A1 (en) Customized annotation editing
US20030074634A1 (en) Interactive server side components
US7349837B2 (en) Systems and methods for a programming environment for a simulation of a computer application
US20040199516A1 (en) Source information adapter and method for use in generating a computer memory-resident hierarchical structure for original source information

Legal Events

Date Code Title Description
AS Assignment

Owner name: MICROSOFT CORPORATION, WASHINGTON

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:VAIDYANATHAN, SHANKAR;KANEVA, BILIANA K.;REEL/FRAME:013216/0465

Effective date: 20020807

Owner name: MICROSOFT CORPORATION, WASHINGTON

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:KIMMERLY, RANDY S.;REEL/FRAME:013216/0472

Effective date: 20020809

AS Assignment

Owner name: MICROSOFT TECHNOLOGY LICENSING, LLC, WASHINGTON

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MICROSOFT CORPORATION;REEL/FRAME:034766/0001

Effective date: 20141014