Abstract:
A code stream provides a historical view of changes to program code and related actions. The code stream is displayed concurrently with the code for reference, navigation, editing, sharing, and to aid in interruption recovery. The code stream automatically constructs a list of visited code segments based on user changes to the code or navigation within the code. The code stream is an activity history that is constructed based on analysis of user navigation behavior, such as specific edits to the code or dwelling in a section of the code. The user has the ability to undo changes in the code in a non-linear fashion by individually reversing changes from the history listed in the code stream. The user may manually add other non-code items to the code stream.

Description:
BACKGROUND 
       [0001]    Developers frequently navigate to the same sections of code in projects in an integrated development environment (IDE). These sections may be continuously edited as the developers refine key features, for example. Users must move between files and scroll through lines of code to find the functions of interest or to review previous edits. For large projects with multiple code files and very many lines of code, it can be time consuming for users to move among a few frequently visited sections of code. 
         [0002]    When the user returns to a previously edited section of code, they must recall from memory or refer to notes to remember what changes were previously made in that code section. For a much revised section of code and for very large projects, it can be difficult for users to keep track of all the changes that were previously entered. 
         [0003]    Similar problems arise in word processing, project management, database, and other programs. Certain sections of large document collections, projects, or databases may be visited and edited more frequently than others, but these often-visited sections may be spread out among the relevant files. 
         [0004]    Previous solutions allow users to use a search tool to find selected sections of a file or document. However, the search must be run each time to create a list of possible destinations. Additionally, the searches do not include information regarding past edits to the code or text. Some applications provide a simple list of previous edit actions that indicate, for example, the occurrence of deletions, insertions, moves, font changes, and the like. However, these lists do not show a chronological list of the user&#39;s edits or the user&#39;s navigation within the document or file. 
       SUMMARY 
       [0005]    This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter. 
         [0006]    A user&#39;s repeated navigations within a code file or text document may be predicted based on the user&#39;s prior navigations. Users are more likely to return to functions or methods they have edited in the past or in which they have spent a significant amount of time but not editing (i.e., dwelling). In one embodiment, a code stream provides a historical view of the user&#39;s changes to program code and related actions. The user can display the code stream view on the screen concurrently with the code for reference, navigation, editing, sharing, and to aid in interruption recovery. 
         [0007]    The code stream automatically constructs a list of visited code segments based on user changes to the code or navigation within the code. The code stream is an activity history that is constructed based on analysis of user navigation behavior, such as specific edits to the code or dwelling in a section of the code. The user has the ability to undo changes in the code in a non-linear fashion by individually reversing changes from the history listed in the code stream. 
         [0008]    The code stream can be saved, persisted to a file and shared with other users. The code stream integrates with a suspend/resume mechanism to help resume tasks more efficiently because the code stream allows a user to see what happened with the task prior to its suspension. The code stream includes a deep provenance of the code by saving the location and differences in previous versions of the code. Changes to the same function are grouped into one history point in the code stream. 
         [0009]    Additionally, users can explicitly include or exclude individual items in the code stream view. External information, such as tasks, emails, instant messages, web pages, debug data, variable values, and the like, can be tagged into the code stream. 
         [0010]    In other embodiments, the code stream may represent content of documents, projects, databases or other files. 
     
    
     
       DRAWINGS 
         [0011]    To further clarify the above and other advantages and features of embodiments of the present invention, a more particular description of embodiments of the present invention will be rendered by reference to the appended drawings. It is appreciated that these drawings depict only typical embodiments of the invention and are therefore not to be considered limiting of its scope. The invention will be described and explained with additional specificity and detail through the use of the accompanying drawings in which: 
           [0012]      FIG. 1  is an example display for an integrated development environment that provides a code stream for the user. 
           [0013]      FIGS. 2-5  are example displays showing changes to the code stream as the user edits the code. 
           [0014]      FIG. 6  illustrates the effect of navigation in the code window by selecting an item in the code stream. 
           [0015]      FIG. 7  is a flowchart illustrating a method or process for tracking user activity within an application. 
           [0016]      FIG. 8  is a flowchart illustrating a method or process for tracking user activity within an integrated development environment. 
           [0017]      FIG. 9  illustrates an example of a suitable computing and networking environment. 
       
    
    
     DETAILED DESCRIPTION 
       [0018]    A code stream is automatically constructed based on user behavior while viewing, creating, or editing code in a file. User activity is monitored and a degree-of-interest model is created to determine the set of content that is most relevant to the user. For example, when a user creates new code, edits existing code, or spends time looking (i.e., dwells) at specific code, that code is identified as being of higher interest to the user. It is more likely that the user will return to this code for additional revisions or reference compared to other code. 
         [0019]    Users may further extend the code stream by manually tagging content into the code stream. These items may include code (e.g., functions, methods, etc.) that has not been automatically added to the code stream or external material, such as tasks, emails, instant messages, debug data, and the like. 
         [0020]    The user may also tag external information into the code stream through an extensible provenance framework. For example, in one embodiment, a textual representation cache is saved for each code stream item along with a cache timestamp, as well as a history tag type, a timestamp, and an XML blob comprising the location of the information. A plug-in architecture allows this information to be resolved and displayed on the screen. 
         [0021]    The code stream typically presents a historical view showing the most recently accessed code at the top of a list. The user can select specific items in the code stream to undo. The user is not required to undo later edits in order to undo the selected code. This allows the user to undo their changes in a non-linear manner. 
         [0022]    The code stream can be saved and persisted to a file. This allows the code stream to be shared with other users or to be recalled by the user at later time. The persistence file contains complete details of the code stream, such as the fully-qualified name of the methods/functions/classes, the start/end locations (offsets) in the file, the fully qualified path to the file, as well as the actual contents of the fragment. Additionally, a baseline version of the file and branch information may be stored. A fully qualified version control path may also be stored. This allows the code stream to reliably re-open on other computers. If the user does not have the content, then a static cache of the contents may be shown. If the user has the wrong version of the code files, a warning regarding version error may be shown and the cached content is shown. Otherwise, the actual live file content is shown if available. The redundant information comprises deep provenance. 
         [0023]    The code stream allows for suspend/resume integration, which allows the user to suspend their work and resume it later. The code stream allows users to resume the task more efficiently by reading the available history information. 
         [0024]    Code changes are displayed in the code stream in chronological order with relative timestamp information for each entry. The system groups multiple edits in the same function into a single entry, showing this entry at the timestamp of the most recent edit in that function. For non-functional edits, the system displays just the edited lines and provenance information. 
         [0025]      FIG. 1  illustrates an example display  100  for an IDE that provides a code stream for the user. Editor window  101  displays code for a selected project. Editor window  101  displays generic code that represents any function, method, object, class or other code structure that is appropriate for a selected programming language. Task history window  102  includes the activity items in the user&#39;s code stream. In this example, the user has activated a work item—Task 1 ( 103 )—which is added to the code stream in task history window  102 . A task description  104  or other information may be included with Task 1 as well as a timestamp  105 . The content of task description  104  may be user-entered content or may be a default value, such as the title of the task. Task description  104  may display a default amount of text, such as one or more lines, or any amount of text selected by the user. Timestamp  105  may represent a specific time (i.e., “1:15 PM”) when the task was opened or completed or an elapsed time (i.e., “1 hour ago”) since the action was open or completed. Alternatively, timestamp  105  may show both the start and completion times and/or a duration the user worked on that task. Task icon  106  may indicate that the task has been started, completed, or shared or may represent an author or owner of the task. 
         [0026]      FIG. 2  illustrates an example display  200  after the user has edited the code. Display  200  shows the updated code  201  and a new code stream  202 . As illustrated in editor window  201 , the user has added new code, such as new Function X  203 , to the project. The new code is also added to task history window  202  and is identified by the edited function—Function X ( 204 ). The new code  205  for this function is also shown in the task history  202 . The font or highlighting used for new code  205  may be selected to indicate how it was edited or added. For example, inserted code may be underlined, deleted code may be shown as strikeout text and moved or copied code may be highlighted in some other way. A timestamp  206  is also applied to this new task. The timestamp  207  for the previous code stream entry—Task 1 ( 103 )—has also been updated when the new task was added. 
         [0027]      FIG. 3  illustrates an example display  300  after the user has further edited the code. Editor window  301  and task history window  302  illustrate these edits and reflect other user actions. In particular, the user has edited Function C ( 303 ) and started a new task, Task 2. After editing Function X ( 204 ), the user accessed an email thread. Email Thread  304  may be manually added to the code stream in task history window  302  by the user or may be automatically added if, for example, the email is linked to this project. Email text  305  may include, for example, a subject line, sender name, or some or all of the email content. Timestamp  306  notes the time that the email was added, read, or created. Envelope icon  307  may indicate whether the user wrote, read, replied, forwarded or otherwise processed the email thread. 
         [0028]    The user has also opened another task  308 , which is added to the code stream timeline with the appropriate description and timestamp. 
         [0029]    The user&#39;s edits to Function C  309  have also been added to the code stream timeline. In particular, Function C originally had five lines of code and has now been edited to have six lines of code. The new code is shown in editor window  301 . Entry  309  in task history  302  also shows the changes  310  to the code. The edited code  310  for Function C may be assigned a font or highlighting that indicates how it was edited by the user. For example, inserted code may be underlined, deleted code may be shown as strikeout text and moved or copied code may be highlighted in some other way. A timestamp  311  is also applied to this new task and the timestamps for the previous entries have been updated. 
         [0030]      FIG. 4  illustrates another example display  400  after the user has further edited the code. Again, editor window  401  and task history window  402  illustrate these edits and reflect other user actions. Following the edits to Function C ( 309 ), the user began a debug session. Debug Session  403  was added to the task history along with debug details and a time stamp. The debug details may include any content added by the user or automatically generated by the IDE to document the debug session. 
         [0031]    An Instant Message  404  and Sharing Session  405  have also been added to the code stream along with relevant details and timestamps. These entries may have been added manually by the user or automatically added by the IDE. 
         [0032]    The task history  402  also shows that the user has dwelled in two functions—Function D ( 406 ) and Function E ( 407 ). Dwelling may include, for example, opening or selecting the function in the editor window  401 , copying the function or lines of code, making unsaved edits in the function, or otherwise indicating a user interest in the function. The icons  408 ,  409  indicate that other details are available for dwelling entries  406  and  407 , but the details are collapsed out of view to simplify the display. On the other hand, icon  410  for Function C ( 309 ) may indicate that this entry has been expanded to show the relevant details. The user has flagged ( 411 ) the entry for Function B ( 407 ), which may be used, for example, to indicate that the user should return to this function or to highlight the function to a co-worker. 
         [0033]      FIG. 5  illustrates another example display  500  after the user has edited another function—Function F ( 503 )—in editor window  501 . Corresponding entry  504  has been added to the task history window  502  along with the relevant edits  505  and timestamp  506 . The timestamps for the other entries in the task history have been updated, and the details for the edits to Function C ( 507 ) have been collapsed by the user—as indicated by icon  508 —to simplify the display. 
         [0034]      FIG. 6  illustrates the display  600  after the user has selected an existing item from the code stream in the task history window  602 . The user has selected Function C ( 603 ) from the task history window  602 , which moves this entry to the top of the code stream and makes it the current entry. Also, the editor window  601  moves to the selected Function C ( 604 ). The user has further edited the code in Function C. These edits  605  are shown in the task history. In the illustrated example, current edits are shown by single underlining and single strikeout text and previous edits (e.g., the earlier edits from  FIG. 4 ) are shown using double underlining and double strikeout text. In other embodiments, different types of fonts and/or highlighting may be used to indicate edits to the code. Alternatively, the task history  602  may only indicate current edits, and the user may have the capability to selectively display and/or step through displays of previous edits, if any. 
         [0035]    The previous entry for Function C was listed between the Debug Session and Task 2 entries in task history window  602 . This entry has been removed because Function C is now the current activity at the top of the list. In other embodiments, the previous entries for the same function or task may remain in their original position to display a task-by-task list of the user&#39;s previous activity in the project. 
         [0036]    Although the example shown in  FIGS. 1-6  illustrates an IDE that is used to work with code, it will be understood that the activity history stream may be used with other applications, such as word processing, document management, project management, database, and other applications. The user&#39;s activity in such applications can be tracked and displayed in a manner similar to the task history illustrated above. Additionally, the activity history may correspond to multiple files and/or applications where the user has several different programs open at the same time and is moving among the programs. 
         [0037]    The user&#39;s activity history, such as the code stream shown in the task history windows of  FIGS. 1-6 , may be saved either with or separately from the corresponding code, document, project, or other file to which it is associated. The activity history may be shared among users working on the same project. This would allow a new user to quickly identify what edits were made and which task were completed by the prior user. 
         [0038]      FIG. 7  is a flowchart illustrating a method or process for tracking user activity within an application. In step  701 , user actions within an application are monitored. The application may be an integrated development environment and the user actions comprise edits to software code. In step  702 , an activity history of the user actions is generated. The activity history may comprise a chronological list of the user actions. In step  703 , the activity history is displayed to the user. In step  704 , the activity history is automatically updated when a new user action is detected. 
         [0039]    In step  705 , user instructions are received indicating selected items to add to the activity history. These user-selected are added to the activity history and displayed to the user. The selected items may be associated with other applications running on the same or a different computer. The selected items may be tasks, email messages, instant messages, web pages, and debugger variable values. 
         [0040]    When a user selection of an item listed in the activity history is received, the content related to the user-selected item is displayed. The user-selected item may be, for example, a previous edit to the software code. The activity history may be saved in a format that can be accessed by another user. 
         [0041]      FIG. 8  is a flowchart illustrating a method or process for tracking user activity within an integrated development environment. In step  801 , a code editing window is provided to display code for a selected project. In step  802 , a task history window is provided to display an activity history that lists previous user actions associated with the code. In step  803 , the activity history is automatically update to include user edits to the code. In step  804 , the activity history is automatically updated to include code segments that have been accessed by the user but not edited. In step  805 , the activity history is updated to include user-selected items, such as tasks, email messages, instant messages, web pages, and debugger variable values. 
         [0042]    The activity history may also be updated to remove user-selected items. A user may identify a previous action in the activity history and designate that previous action to be reversed. The previous action may be an edit to the code that occurred at a designated time. The code is returned to a prior state that existed at the designated time without undoing other code edits that occurred at other times. 
         [0043]    The activity history may be saved in a sharable format that can be accessed by other users to determine what actions were performed on the code. 
         [0044]    It will be understood that steps  701 - 705  of the process illustrated in  FIG. 7  and steps  801 - 805  of the process illustrated in  FIG. 8  may be executed simultaneously and/or sequentially. It will be further understood that each step may be performed in any order and may be performed once or repetitiously. 
         [0045]      FIG. 9  illustrates an example of a suitable computing and networking environment  900  on which the examples of  FIGS. 1-8  may be implemented. The computing system environment  900  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. The invention is operational with numerous other general purpose or special purpose computing system environments or configurations. Examples of 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, server computers, hand-held or laptop devices, tablet devices, multiprocessor systems, microprocessor-based systems, set top boxes, programmable consumer electronics, network PCs, minicomputers, mainframe computers, distributed computing environments that include any of the above systems or devices, and the like. 
         [0046]    The invention may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, and so forth, which perform particular tasks or implement particular abstract data types. 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. In a distributed computing environment, program modules may be located in local and/or remote computer storage media including memory storage devices. 
         [0047]    With reference to  FIG. 9 , an exemplary system for implementing various aspects of the invention may include a general purpose computing device in the form of a computer  900 . Components may include, but are not limited to, various hardware components, such as processing unit  901 , data storage  902 , such as a system memory, and system bus  903  that couples various system components including the data storage  902  to the processing unit  901 . The system bus  903  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. 
         [0048]    The computer  900  typically includes a variety of computer-readable media  904 . Computer-readable media  904  may be any available media that can be accessed by the computer  900  and includes both volatile and nonvolatile media, and removable and non-removable media, but excludes propagated signals. By way of example, and not limitation, computer-readable media  904  may comprise computer storage media and communication media. Computer storage media includes 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, CD-ROM, 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 accessed by the computer  900 . 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 the any of the above may also be included within the scope of computer-readable media. Computer-readable media may be embodied as a computer program product, such as software stored on computer storage media. 
         [0049]    The data storage or system memory  902  includes computer storage media in the form of volatile and/or nonvolatile memory such as read only memory (ROM) and random access memory (RAM). A basic input/output system (BIOS), containing the basic routines that help to transfer information between elements within computer  900 , such as during start-up, is typically stored in ROM. RAM typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by processing unit  901 . By way of example, and not limitation, data storage  902  holds an operating system, application programs, and other program modules and program data. 
         [0050]    Data storage  902  may also include other removable/non-removable, volatile/nonvolatile computer storage media. By way of example only, data storage  902  may be a hard disk drive that reads from or writes to non-removable, nonvolatile magnetic media, a magnetic disk drive that reads from or writes to a removable, nonvolatile magnetic disk, and an optical disk drive that reads from or writes to a removable, nonvolatile optical disk 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 drives and their associated computer storage media, described above and illustrated in  FIG. 9 , provide storage of computer-readable instructions, data structures, program modules and other data for the computer  900 . 
         [0051]    A user may enter commands and information through a user interface  905  or other input devices such as a tablet, electronic digitizer, a microphone, keyboard, and/or pointing device, commonly referred to as mouse, trackball or touch pad. Other input devices may include a joystick, game pad, satellite dish, scanner, or the like. Additionally, voice inputs, gesture inputs using hands or fingers, or other natural user interface (NUI) may also be used with the appropriate input devices, such as a microphone, camera, tablet, touch pad, glove, or other sensor. These and other input devices are often connected to the processing unit  901  through a user input interface  905  that is coupled to the system bus  903 , 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  906  or other type of display device is also connected to the system bus  903  via an interface, such as a video interface. The monitor  906  may also be integrated with a touch-screen panel or the like. Note that the monitor and/or touch screen panel can be physically coupled to a housing in which the computing device  900  is incorporated, such as in a tablet-type personal computer. In addition, computers such as the computing device  900  may also include other peripheral output devices such as speakers and printer, which may be connected through an output peripheral interface or the like. 
         [0052]    The computer  900  may operate in a networked or cloud-computing environment using logical connections  907  to one or more remote devices, such as a remote computer. The remote computer 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  900 . The logical connections depicted in  FIG. 9  include one or more local area networks (LAN) and one or more wide area networks (WAN), but may also include other networks. Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets and the Internet. 
         [0053]    When used in a networked or cloud-computing environment, the computer  900  may be connected to a public or private network through a network interface or adapter  907 . In some embodiments, a modem or other means for establishing communications over the network. The modem, which may be internal or external, may be connected to the system bus  903  via the network interface  907  or other appropriate mechanism. A wireless networking component such as comprising an interface and antenna may be coupled through a suitable device such as an access point or peer computer to a network. In a networked environment, program modules depicted relative to the computer  900 , or portions thereof, may be stored in the remote memory storage device. It may be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers may be used. 
         [0054]    Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims.