Implementing changes made to the source code of a reloadable type at runtime

Abstract

Systems and methods are provided for implementing changes made to source code of a program at runtime. Specifically, a computing device may execute the source code in a runtime environment and detect changes made to the source code at runtime in the runtime environment. In response to detecting the changes, the computing device may determine whether changes have been made to a type in the source code identified as reloadable. In response to determining that changes have been made to a type in the source code identified as reloadable, the computing device may create a new version of the type and implement the changes to the source code at runtime using the new version of the type.

Description

[Background technology]

[0001] Various types of software development tools allow software developers to make changes to the source code of an application while the program is in break mode during a debugging session. If any defects or problems are found during a debugging session that prevent the correct operation of the source code, the software developer may make changes to the source code to resolve the defect or problem. In some cases, the changes may be made without a debugger attached. Yet, another scenario is when a debugger is attached but the program may not be suspended in break mode when the changes are made. In such cases, when changes to the source code are received, the changes may be applied in-place to the source code of the type. In other words, when the changes are being applied to the source code of the type, the source code is being overwritten. Once the changes have been made and the software developer resumes the application, the runtime representation of the type and its existing instances are updated to reflect the changes. This allows the software developer to make changes to the source code without having to stop the entire program, recompile, and restart the debugging session. However, due to the inherent complexities of updating the runtime representation of a type and its instances, the set of edits that are allowed is limited.

[0002] It is with respect to these and other general considerations that the aspects disclosed herein have been made. Moreover, although relatively specific problems may be discussed, it should be understood that the embodiments are not limited to solving the specific problems identified in the Background and elsewhere in this disclosure. Summary of the Invention

[0003] The present disclosure relates to hot reloading, which reduces the inner loop of a developer development cycle by allowing a developer to modify a program without stopping, reloading, and restarting the program. More specifically, the present disclosure teaches the ability to hot reload when a type (e.g., a class) changes. To implement this idea, both the UI framework and the .NET runtime can be updated.

[0004] In accordance with at least one embodiment of the present disclosure, a method is provided for implementing changes to source code of a program at runtime, which may include executing the source code in a runtime environment, detecting changes made to the source code at runtime in the runtime environment, determining whether changes have been made to a type in the source code identified as reloadable, and in response to determining that changes have been made to a type in the source code identified as reloadable, creating a new version of the type, and implementing the changes to the source code at runtime using the new version of the type.

[0005] In accordance with at least one embodiment of the present disclosure, a computing device for implementing changes made to source code of a program at runtime is provided. The computing device may include a processor and a memory having instructions stored thereon that, when executed by the processor, cause the computing device to execute the source code in a runtime environment, detect changes made to the source code at runtime in the runtime environment, determine whether changes have been made to types in the source code identified as reloadable, and, in response to determining that changes have been made to types in the source code identified as reloadable, create a new version of the type, and use the new version of the type to implement the changes to the source code at runtime.

[0006] In accordance with at least one embodiment of the present disclosure, a non-transitory computer-readable medium is provided that stores instructions for implementing changes made to source code of a program at runtime, which instructions, when executed by one or more processors of a computing device, cause the computing device to execute the source code in a runtime environment, detect changes made to the source code at runtime in the runtime environment, determine whether changes have been made to types in the source code identified as reloadable, and, in response to determining that changes have been made to types in the source code identified as reloadable, create a new version of the type, and implement the changes to the source code at runtime using the new version of the type.

[0007] Any of the one or more aspects above in combination with any other of the one or more aspects. Any of the one or more aspects described herein.

[0008] 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 limit the scope of the claimed subject matter. Additional aspects, features, and / or advantages of the embodiments will be set forth in part in the description that follows, and in part will be obvious from the description, or may be learned by practice of the disclosure.

[0009] Non-limiting and non-exhaustive examples are described with reference to the following figures. [Brief description of the drawings]

[0010] [Figure 1] FIG. 2 illustrates details directed to a software development system according to an embodiment of the present disclosure. [Diagram 2]FIG. 1 illustrates a method for implementing changes made to source code of a reloadable type at runtime, according to an embodiment of the present disclosure. [Diagram 3] FIG. 1 illustrates a method for implementing changes made to source code of a reloadable type at runtime, according to an embodiment of the present disclosure. [Figure 4] FIG. 1 is a block diagram illustrating the physical components (e.g., hardware) of a computing device in which aspects of the present disclosure may be implemented. [Figure 5A] FIG. 1 illustrates a first example of a computing device in which aspects of the present disclosure may be implemented. [Figure 5B] FIG. 2 illustrates a second example of a computing device in which aspects of the present disclosure may be implemented. [Figure 6] FIG. 1 illustrates at least one aspect of an architecture of a system for processing data, according to an embodiment of the present disclosure. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0011] In the following detailed description, reference is made to the accompanying drawings, which form a part of this specification, in which specific aspects or embodiments are shown by way of example. These aspects may be combined, other aspects may be utilized, and structural changes may be made without departing from the present disclosure. The aspects may be implemented as a method, system, or device. Thus, the aspects may take the form of a hardware implementation, an entirely software implementation, or an embodiment combining software and hardware aspects. Therefore, the following detailed description is not to be taken in a limiting sense, and the scope of the present disclosure is defined by the appended claims and their equivalents.

[0012] According to an embodiment of the present disclosure, a software development system allows a user (e.g., a developer, programmer, designer, and / or coder) to develop or modify a program using an application framework, the application framework including a software framework for implementing a standard structure of application software. The software development system of the present disclosure is configured to implement changes made to the source code of a program while the program is running. In particular, the software development system allows a user to modify certain types in the source code at run time without stopping, reloading, and restarting the entire program.

[0013] To do so, a particular type may be marked as reloadable in the source code or in a database library. In some aspects, the database library may be associated with an application framework. When changes are made to the source code of a reloadable type, instead of applying the changes in-place (e.g., updating the type in-place), the changes may result in creating a new version of the reloadable type, and the new version of the reloadable type may replace the previous version of the type. To do so, for example, the application framework may replace runtime representations and existing instances of the previous version of the reloadable type in the source code with the new version of the reloadable type. Creating a new version of the type that reflects changes made to the source code may allow users to make changes to the source code during runtime without being constrained by the limitations of in-place updates.

[0014] 1 illustrates a software development system 100 for implementing changes made to source code by a user 110 at runtime, according to an embodiment of the present disclosure. To do so, software development system 100 includes a computing device 120 associated with user 110 and one or more remote devices, such as a server 140, communicatively coupled to computing device 120 via a network 150. Network 150 may include any type of computing network, including, but not limited to, a wired or wireless local area network (LAN), a wired or wireless wide area network (WAN), and / or the Internet.

[0015] The computing device 120 includes an integrated development environment (IDE) 130 executing on the computing device 120 having a processor 122, a memory 124, and a communication interface 126. The IDE 130 may enable the user 110 to design, code, compile, test, run, edit, debug, or build software programs, sets of programs, websites, web applications, and web services on a computer system. The software programs may include source code written in one or more source code languages ​​(e.g., Visual Basic, Visual J#, C++, C#, J#, Java Script, APL, COBOL, Pascal, Eiffel, Haskell, ML, Oberon, Perl, Python, Scheme, Smalltalk, etc.). The IDE 130 may provide a native code development environment or may provide a managed code environment running on a virtual machine. For example, the IDE 130 may provide a managed code development environment using the .NET framework. In an exemplary embodiment, the IDE 130 may be configured to develop applications for use with, for example, the .NET framework and / or a UI framework. To implement changes made to the source code of a reloadable type at runtime, both the UI framework and the .NET runtime can be updated.

[0016] For example, the .NET framework is updated with attributes that designate certain types as reloadable and attributes that designate certain types as recipients of update notifications. The update notifications contain information about the types that have been updated. It should be understood that attributes are markers that can be placed on any type.

[0017] The UI framework defines certain types that represent UI elements. Certain types that the UI framework can reload are marked with the above attributes. The UI framework implements types that are designed to receive update notifications from the runtime. Upon retrieval of such notifications, the UI framework replaces all updated reloadable types in its data structures with the corresponding new versions that contain the updates. It should be understood that the usage pattern of reloadable types is such that it allows replacing a type with its new version. In other words, user code that references such types does not directly reference a particular version of a type, but rather indirectly (e.g., via a base type, an interface, or dynamic dispatch).

[0018] To do so, the IDE 130 further includes a source code analyzer 132, a reloadable type identifier 134, and a framework library updater 136. The source code analyzer 132 is configured to analyze source code of a program loaded with the IDE 130 to detect changes made by the user 110 at run-time. In an exemplary embodiment, the user 110 may use the IDE 130 to make changes to the source code while the program is running. The changes may be implemented at run-time without stopping, reloading / recompiling, and restarting the entire program, depending on metadata indicating the type of source code for which the changes were made. As described above and further below, certain types of source code may be reloaded and thus updated arbitrarily while the program is running. Such reloadable types of source code allow the user 110 to edit the program at run-time with fewer restrictions compared to types that are updated in-place. The reloadable type identifier 134 is configured to determine whether the changes made to the source code are made to one or more reloadable types of source code. For example, a user 110 may create one or more reloadable types during the development process by annotating a type as reloadable. Alternatively or additionally, the framework may include a reloadable type database of predefined types that can be reloaded. For example, a developer of an application framework may create one or more types, identify some types as reloadable, and store the identified reloadable types in the reloadable type database. Such a reloadable type database may be received from another computing device (e.g., server 140). Server 140 may be one or more cloud servers.

[0019] The framework library updater 136 is configured to send a notification to another device (e.g., server 140) that includes metadata indicating changes to the source code of the reloadable type. The changes made to the source code of the reloadable type generate a new version of the reloadable type, and the new version of the reloadable type is included in the metadata sent to the framework. In some aspects, the notification may be sent to the server 140 and the framework may be updated via the framework library updater 142 of the server 140. The new version of the reloadable type is stored in a framework library (e.g., reloadable type database 128 and / or framework library 144). In response, the framework creates a new type (e.g., a new version of the type) that has its own runtime representation. When the UI framework is notified of an update to a reloadable type, the UI framework replaces all references it has to the old version of the type with the new version. When the UI is refreshed, the UI framework identifies which type implements a particular UI element and fetches that type from the UI framework's data structure. This becomes the latest version of the type. The UI framework then executes the code in the type that renders the UI for the element, allowing changes to be implemented immediately while the program is running.

[0020] One example of a framework that may use reloadable types is Razor. Razor is a framework used to create web applications and / or web pages. Razor allows programmers to use an HTML construction workflow. In the example shown below, Microsoft.AspNetCore.Mvc.RazorPages.Page is the base type for user-defined types that represent web pages. This type is typically generated from a .razor file that describes a page in the Razor language. This is automatically converted to C# code that looks like the following:

[0021] public class MyPage:Microsoft.AspNetCore.Mvc.RazorPages.Page { public async override Task ExecuteAsync() { / / ... code that builds the HTML content for the page ... } } When a user 110 updates a .razor file (e.g., changing the title of a page), the sources of the above types are automatically updated accordingly. Razor comments are processed on the server 140 before the page is sent to the browser. To allow such updates to take effect immediately while a web application is running, the Razor framework marks the base type Microsoft.AspNetCore.Mvc.RazorPages.Page as reloadable, and as a result, all subtypes of Page are reloadable. This avoids the need to quit, recompile, and run the application again, and avoids any constraints on updates that may be made in-place.

[0022] Another example of a reloadable type is the Model-View-Update (MVU) pattern. The Comet UI framework is built using the MVU pattern. It provides a View class from which application UI views are derived as follows:

[0023] public class MyView:View { [Body] View body()=>new Text("Hello World"); } The Comet framework allows a View type to be marked as "reloadable" to allow the user 110 to update the view while the application is running.

[0024] 2 and 3, a method 200 of implementing changes made to a source code of a program while the program is running according to an embodiment of the present disclosure is provided. An overall sequence of steps of the method 200 is shown in FIGS. 2 and 3. Generally, the method 200 begins at 204 and ends at 254. The method 200 may include more or fewer steps and may configure the sequence of steps differently than shown in FIGS. 2 and 3. In an exemplary embodiment, the method 200 is performed by a computing device of the user 110 (e.g., the user device 120). Specifically, in some embodiments, the method 200 may be performed by an integrated development environment (IDE) (e.g., 130) running on the user device 120. For example, the computing device 120 may be, without limitation, a computer, notebook, laptop, mobile device, smartphone, tablet, wearable, or any other suitable computing device capable of communicating with the server 140. For example, the server 140 may be any suitable computing device capable of communicating with the computing device 120. Method 200 may be executed by a computer system and implemented as computer-executable instructions encoded or stored on a computer-readable medium. Additionally, method 200 may be performed by gates or circuits associated with a processor, an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a system on a chip (SOC), or other hardware device. Method 200 is described below with reference to the systems, components, modules, software, data structures, user interfaces, etc. described in conjunction with FIG.

[0025] Method 200 may begin at 202 and flow may proceed to 206. At 206, computing device 120 obtains or builds source code for a program in an integrated development environment (IDE) (e.g., 124). In some aspects, the source code may be built within a software framework (e.g., .NET framework). For example, the source code may be provided by user 110. Alternatively, the source code may be received or obtained from server 140. Once the source code is obtained, it is loaded into IDE 124. For example, IDE 124 may be Microsoft® Visual Studio®, Eclipse, Microsoft® Office, or any other IDE running on computing device 120.

[0026] Thereafter, at 210, the source code is executed in a runtime environment provided by the IDE 124. In some aspects, the computing device 120 may analyze the source code to identify one or more types that are identified as reloadable during runtime. For example, a user may create one or more types and annotate such types as reloadable during the development process. Alternatively or additionally, the software framework may include a reloadable type library or database of predefined types that can be reloaded at runtime. The reloadable type database may be received from another computing device (e.g., server 140). Alternatively or additionally, a developer of the software framework may create one or more types, identify a type as reloadable, and store the identified reloadable type in the reloadable type database. At 218, while the program is executing in the runtime environment, the computing device 120 detects one or more changes to the source code made by the user 110. When one or more changes are detected, the computing device 120 determines whether one or more changes have been made to the source code of the reloadable type, as described in operation 222. As previously mentioned, the reloadable type database 128 associated with the software framework may include predefined types that can be reloaded at runtime. In such an aspect, the computing device 120 determines whether one or more changes have been made to the source code of the reloadable type based in part on the reloadable type database 128. Additionally or alternatively, a particular type in the source code may be identified and annotated as a reloadable type source code by the user 110 before and / or during runtime. Additionally or alternatively, the user 110 may create a new type and annotate the new type as reloadable. The method 200 then proceeds to operation 226 of FIG. 3, as indicated by the alphanumeric character A in FIGS. 2 and 3.

[0027] At 226, if the computing device 120 determines that the changes are not in the source code of the reloadable type, the method 200 proceeds to operation 230, where the changes made to the source code of the non-reloadable type are applied in-place. In other words, the runtime representation of the non-reloadable type and all existing instances thereof are updated to reflect the changes. However, as mentioned above, due to the inherent complexities of updating the runtime representation of a type and its instances, the set of in-place edits that are allowed is limited. The method 200 then skips forward to operation 250, where it continues executing the program in the runtime environment with the updated source code.

[0028] Returning to operation 226, if the computing device 120 determines that changes are to be made in the source code of the reloadable type, the method 200 proceeds to operation 234. At 234, the computing device 120 creates a new type (e.g., a new version of the reloadable type) based on the changes.

[0029] Thereafter, at 238, the computing device 120 notifies the software framework of information (e.g., metadata) about the new version of the type that needs to be reloaded by the software framework. In response to receiving the notification, at 242, the software framework transfers significant state (e.g., member variables), if any, from the previous instance of the reloadable type to the new version of the reloadable type.

[0030] At 246, the computing device 120 replaces the runtime representation and existing instances of the previous version of the reloadable type in the source code with the new version of the reloadable type.

[0031] Thereafter, at 250, the computing device 120 continues executing the program in the runtime environment after implementing the changes while the program is running. This allows the user 110 to make changes to the source code at runtime without stopping, reloading, and restarting the entire program.

[0032] Figures 4-6 and the associated description provide a discussion of various operating environments in which aspects of the disclosure may be implemented. However, the devices and systems depicted and discussed in connection with Figures 4-6 are for purposes of example and illustration, and are not intended to be a limitation of the vast number of computing device configurations that may be utilized to implement aspects of the disclosure described herein.

[0033] 4 is a block diagram illustrating physical components (e.g., hardware) of a computing device 400 in which aspects of the disclosure may be implemented. The computing device components described below may be suitable for such computing devices. For example, computing device 400 may represent computing device 120 of FIG. 1. In a basic configuration, computing device 400 may include at least one processing unit 402 and a system memory 404. Depending on the configuration and type of computing device, system memory 404 may include, but is not limited to, volatile storage (e.g., random access memory), non-volatile storage (e.g., read-only memory), flash memory, or any combination of such memory.

[0034] The system memory 404 may include an operating system 405 and one or more program modules 406 suitable for performing various aspects as disclosed herein. The operating system 405 may be, for example, suitable for controlling the operation of the computing device 400. Additionally, aspects of the disclosure may be implemented with graphics libraries, other operating systems, or any other application programs and are not limited to any particular application or system. This basic configuration is illustrated in FIG. 4 by those components within dashed line 408. The computing device 400 may have additional features or functionality. For example, the computing device 400 may also include additional data storage devices (removable and / or non-removable), such as, for example, magnetic disks, optical disks, tape, and the like. Such additional storage is illustrated in FIG. 4 by removable storage device 409 and non-removable storage device 410.

[0035] As previously mentioned, a number of program modules and data files may be stored in the system memory 404. While executing on at least one processing unit 402, the program modules 406 may perform processes including, but not limited to, one or more aspects described herein. The applications 420 include a source code analyzer 423, a reloadable type identifier 424, a framework library updater 425, as described in more detail with respect to FIG. 1. Other program modules that may be used in accordance with aspects of the present disclosure may include email and contact applications, word processing applications, spreadsheet applications, database applications, slide presentation applications, drawing or computer-aided application programs, and / or one or more components supported by the system described herein.

[0036] Additionally, aspects of the disclosure may be implemented in electrical circuits with discrete electronic elements, packaged or integrated electronic chips including logic gates, circuits using microprocessors, or on a single chip including electronic elements or a microprocessor. For example, aspects of the disclosure may be implemented via a system-on-chip (SOC), where each or many of the components shown in FIG. 4 may be integrated on a single integrated circuit. Such an SOC device may include one or more processing units, graphics units, communication units, system virtualization units, and various application functions, all of which are integrated (or "burned") as a single integrated circuit on a chip substrate. When operating via a SOC, the functionality described herein regarding the client's ability to switch protocols may operate via application specific logic integrated with other components of the computing device 400 on a single integrated circuit (chip). Aspects of the disclosure may also be implemented using other technologies capable of performing logical operations, such as, for example, AND, OR, NOT, including but not limited to, mechanical, optical, fluidic, and quantum technologies.

[0037] Furthermore, aspects of the disclosure may be implemented in a general purpose computer or any other circuits or systems.

[0038] The computing device 400 may also have one or more input devices 412, such as a keyboard, mouse, pen, sound or voice input device, touch or swipe input device, etc. Output devices 414A, such as a display, speakers, printer, etc. may also be included. An output 414B corresponding to a virtual display may also be included. The aforementioned devices are examples and others may be used. The computing device 400 may include one or more communication connections 416 that enable communication with other computing devices 450. Examples of suitable communication connections 416 include, but are not limited to, radio frequency (RF) transmitter, receiver, and / or transceiver circuitry, universal serial bus (USB), parallel and / or serial ports.

[0039] As used herein, the term computer readable media may include computer storage media. Computer storage media may include volatile and non-volatile, removable and non-removable media implemented in any method or technology for storage of information, such as computer readable instructions, data structures, program modules, and the like. System memory 404, removable storage device 409, and non-removable storage device 410 are all examples of computer storage media (e.g., memory storage). Computer storage media may include RAM, ROM, Electrically Erasable Read Only Memory (EEPROM), Flash memory, or other memory technology, CD-ROM, Digital Versatile Disk (DVD), or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage, or other magnetic storage devices, or any other article of manufacture that may be used to store information and that may be accessed by computing device 400. Any such computer storage media may be part of computing device 400. Computer storage media does not include carrier waves or other propagated or modulated data signals.

[0040] Communication media may be embodied with 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" may describe a signal that has one or more characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media may include wired media, such as a wired network or direct-wired connection, and wireless media, such as acoustic, radio frequency (RF), infrared and other wireless media.

[0041] 5A and 5B illustrate a computing device or mobile computing device 500, such as a mobile phone, a smartphone, a wearable computer (such as a smart watch), a tablet computer, a laptop computer, and the like, on which aspects of the disclosure may be implemented. Referring to FIG. 5A, one embodiment of a mobile computing device 500 for implementing aspects is shown. In a basic configuration, the mobile computing device 500 is a handheld computer that includes both input and output elements. The mobile computing device 500 typically includes a display 505 and one or more input buttons 509 / 510 that allow a user to input information into the mobile computing device 500. The display 505 of the mobile computing device 500 may also function as an input device (e.g., a touch screen display). If included, an optional side input element 515 allows for another user input. The side input element 515 may be a rotary switch, a button, or any other type of manual input element. In alternative embodiments, the mobile computing device 500 may incorporate more or fewer elements. For example, in some aspects, the display 505 may not be a touchscreen. In yet another alternative aspect, the mobile computing device 500 is a portable phone system, such as a cellular phone. The mobile computing device 500 may also include an optional keypad 535. The optional keypad 535 may be a physical keypad or a "soft" keypad generated on a touchscreen display. In various aspects, the output elements include the display 505 for showing a graphical user interface (GUI), a visual indicator 531 (e.g., a light emitting diode), and / or an audio transducer 525 (e.g., a speaker). In some aspects, the mobile computing device 500 incorporates a vibration transducer for providing tactile feedback to the user.In yet another aspect, the mobile computing device 500 incorporates input and / or output ports 530, such as an audio input (e.g., a microphone jack), an audio output (e.g., a headphone jack), a video output (e.g., an HDMI port), etc., for sending signals to or receiving signals from an external source.

[0042] FIG. 5B is a block diagram illustrating an architecture of one aspect of a computing device, server, or mobile computing device. That is, the mobile computing device 500 may incorporate a system (902) (e.g., architecture) for implementing some aspects. The system 502 may be implemented as a "smartphone" capable of running one or more applications (e.g., browser, email, calendar, contact manager, messaging client, games, media client / player). In some aspects, the system 502 is integrated as a computing device such as an all-in-one personal digital assistant (PDA) and a wireless phone.

[0043] One or more application programs 566 may be loaded into memory 562 and executed on or in association with operating system 564. Examples of application programs include a phone dialer program, an email program, a personal information manager (PIM) program, a word processing program, a spreadsheet program, an Internet browser program, a messaging program, and / or one or more components supported by the system described herein. System 502 also includes a non-volatile storage area 568 in memory 562. Non-volatile storage area 568 may be used to store persistent information that should not be lost if system 502 is powered down. Application programs 566 may use and store information in non-volatile storage area 568, such as emails and other messages used by an email application. A synchronization application (not shown) also resides on system 502 and is programmed to interact with a corresponding synchronization application resident on a host computer to keep information stored in non-volatile storage area 568 synchronized with corresponding information stored on the host computer. It should be understood that other applications may be loaded into memory 562 and executed on the mobile computing device 500 described herein (e.g., source code analyzer 423, reloadable type identifier 424, framework library updater 425, etc.). The system 502 has a power source 570, which may be embodied as one or more batteries. The power source 570 may further include an external power source, such as an AC adapter or a powered docking cradle that supplements or recharges the battery.

[0044] The system 502 may also include a wireless interface layer 572 that functions to transmit and receive radio frequency communications. The wireless interface layer 572 facilitates wireless connectivity between the system 502 and the "outside world" via a communications carrier or service provider. Transmissions to and from the wireless interface layer 572 are performed under the control of the operating system 564. In other words, communications received by the wireless interface layer 572 may be disseminated to the application programs 566 via the operating system 564, and vice versa.

[0045] The visual indicator 520 may be used to provide visual notifications and / or the audio interface 574 may be used to generate audible notifications via the audio transducer 525. In the illustrated configuration, the visual indicator 520 is a light emitting diode (LED) and the audio transducer 525 is a speaker. These devices may be directly coupled to the power source 570 such that, when activated, these devices remain on for a duration dictated by the notification mechanism, even though the processor 560 / 961 and other components may be shut down to conserve battery power. The LED may be programmed to remain on indefinitely until the user takes action to indicate the power on status of the device. The audio interface 574 is used to provide audible signals to and receive audible signals from the user. For example, in addition to being coupled to the audio transducer 525, the audio interface 574 may also be coupled to a microphone to receive audible input, such as to facilitate a phone conversation. According to aspects of the present disclosure, the microphone may also serve as an audio sensor to facilitate control of notifications, as described below. The system 502 may further include a video interface 576 that enables operation of an on-board camera to record still images, video streams, and the like.

[0046] A mobile computing device 500 implementing system 502 may have additional features or functionality. For example, mobile computing device 500 may also include additional data storage devices (removable and / or non-removable), such as magnetic disks, optical disks, tape, etc. Such additional storage is illustrated in FIG. 5B by non-volatile storage area 568.

[0047] The data / information generated or captured by the mobile computing device 500 and stored via the system 502 may be stored locally on the mobile computing device 500 as previously described, or the data may be stored on any number of storage media that may be accessed by the device via the wireless interface layer 572 or via a wired connection between the mobile computing device 500 and a separate computing device associated with the mobile computing device 500, e.g., a server computer in a distributed computing network such as the Internet. As should be understood, such data / information may be accessed via the mobile computing device 500, via the wireless interface layer 572, or via a distributed computing network. Similarly, such data / information may be readily transferred between computing devices for storage and use in accordance with well-known data / information transfer and storage means, including electronic mail and collaborative data / information sharing systems.

[0048] 6 illustrates one aspect of an architecture of a system for processing data received at a computing system from a remote source, such as a personal computer 604, a tablet computing device 606, or a mobile computing device 608, as described above. Content displayed at the server device 602 may be stored in a variety of communication channels or other storage types. For example, the computing devices 604, 606, 608 may represent the computing devices 120 of FIG. 1, and the server device 602 may represent the server 140 of FIG. 1.

[0049] In some aspects, one or more of the source code analyzer 623, the trusted type identifier 624, and the framework library updater 625 may be utilized by the server device 602. The server device 602 may provide data to and from client computing devices, such as a personal computer 604, a tablet computing device 606, and / or a mobile computing device 608 (e.g., a smartphone) over the network 612. As an example, the aforementioned computer system may be embodied in a personal computer 604, a tablet computing device 606, and / or a mobile computing device 608 (e.g., a smartphone). Any of these aspects of the computing device may retrieve content from the store 616 in addition to receiving graphical data available for pre-processing at the graphics originating system or post-processing at the receiving computing system. The content store may include reloadable type data 618.

[0050] FIG. 6 illustrates an exemplary mobile computing device 608 that may perform one or more aspects disclosed herein. Additionally, aspects and functions described herein may operate via a distributed system (e.g., a cloud-based computing system) in which application functions, memory, data storage and retrieval, and various processing functions may be operated remotely from one another via a distributed computing network, such as the Internet or an intranet. User interfaces and various types of information may be displayed via on-board computing device displays or via remote display units associated with one or more computing devices. For example, user interfaces and various types of information may be displayed on and interacted with a wall surface onto which the user interfaces and various types of information are projected. Interactions with multiple computing systems in which aspects of the present invention may be implemented include keystroke input, touch screen input, voice or other audio input, gesture input, and the like, in which the associated computing device is equipped with detection (e.g., camera) capabilities to capture and interpret user gestures to control functions of the computing device.

[0051] "At least one," "one or more," "or," and "and / or" are open-ended expressions that are both conjunctive and disjunctive in operation. For example, the expressions "at least one of A, B, and C," "at least one of A, B, or C," "one or more of A, B, and C," "one or more of A, B, or C," "A, B, and / or C," and "A, B, or C" each mean A only, B only, C only, A and B, A and C, B and C, or A, B, and C, respectively.

[0052] The term "a" or "an" entity refers to one or more of that entity. Thus, "a" (or "an"), "one or more," and "at least one" may be used interchangeably herein. "Comprising," "including," and "having" may be used interchangeably.

[0053] The term "automatic" and variations thereof, as used herein, refers to any process or operation that is typically continuous or semi-continuous when the process or operation is performed and that is performed without substantial human input. However, a process or operation may be automatic if performing the process or operation uses essential or non-essential human input, but the input is received prior to performing the process or operation. If human input affects how the process or operation is performed, such input is considered essential. Human input consenting to performing the process or operation is not considered "essential."

[0054] Any of the steps, functions, and operations discussed herein may be performed continuously and automatically.

[0055] The exemplary systems and methods of the present disclosure have been described in relation to computing devices. However, to avoid unnecessarily obscuring the present disclosure, the foregoing description has omitted some well-known structures and devices. This omission should not be construed as limiting. Specific details are described to provide an understanding of the present disclosure. However, it should be understood that the present disclosure may be implemented in various ways other than the specific details described herein.

[0056] Additionally, although the exemplary embodiments illustrated herein depict various components of the system as co-located, some components of the system may be located remotely, in separate portions of a distributed network, such as a LAN and / or the Internet, or in a dedicated system. Thus, it should be understood that the components of the system may be combined as one or more devices, such as a server, a communication device, or co-located on a particular node of a distributed network, such as an analog and / or digital telecommunications network, a packet-switched network, a circuit-switched network, etc. From the foregoing description, it will be appreciated that for computational efficiency, the components of the system may be located anywhere within the distributed network of components without affecting the operation of the system.

[0057] It should further be understood that the various links connecting the elements may be wired or wireless links, or any combination thereof, or any other known or later developed elements capable of providing and / or communicating data between the connected elements. Such wired or wireless links may also be secure links and may be capable of communicating encrypted information. For example, the transmission medium used as the link may be any suitable carrier for electrical signals, including coaxial cables, copper wire, and optical fibers, and may take the form of acoustic or light waves, such as those generated during radio wave and infrared data communications.

[0058] Although the flowcharts have been discussed and illustrated with reference to a particular sequence of events, it will be understood that modifications, additions, and omissions may be made to this sequence without substantially affecting the operation of the disclosed configurations and aspects.

[0059] Several variations and modifications of the present disclosure may be used: it is possible to provide some features of the present disclosure without providing other features.

[0060] In yet another configuration, the systems and methods of the present disclosure may be implemented with special purpose computers, programmed microprocessors or microcontrollers and peripheral integrated circuit elements, hardwired electronic or logic circuits such as ASICs or other integrated circuits, digital signal processors, discrete element circuits, programmable logic devices or gate arrays such as PLDs, PLAs, FPGAs, PALs, special purpose computers, any equivalent means, and the like. In general, any device or means capable of implementing the methods shown herein may be used to implement various aspects of the present disclosure. Exemplary hardware that may be used for the present disclosure includes computers, handheld devices, phones (e.g., cellular, Internet-enabled, digital, analog, hybrid, and others), and other hardware known in the art. Some of these devices include processors (e.g., single or multiple microprocessors), memory, non-volatile storage, input devices, and output devices. Additionally, alternative software implementations, including but not limited to distributed processing or component / object distributed processing, parallel processing, or virtual machine processing, may also be constructed to implement the methods described herein.

[0061] In yet another configuration, the disclosed methods may be readily implemented with software using object or object-oriented software development environments that provide portable source code that can be used on a variety of computer or workstation platforms. Alternatively, the disclosed systems may be implemented partially or fully in hardware using standard logic circuits or VLSI designs. Whether software or hardware is used to implement a system according to the present disclosure depends on the speed and / or efficiency requirements of the system, the particular functionality, and the particular software or hardware system or microprocessor or microcomputer system being used.

[0062] In yet another configuration, the disclosed methods may be implemented in part in software that may be stored on a storage medium and executed on a programmed general purpose computer, special purpose computer, microprocessor, etc. in cooperation with a controller and memory. In such examples, the disclosed systems and methods may be implemented as programs embedded on a personal computer, such as applets, JAVA, CGI scripts, etc., as resources resident on a server or computer workstation, as dedicated measurement systems, routines embedded within system components, etc. The system may also be implemented by physically incorporating the system and / or method within a software and / or hardware system.

[0063] This disclosure is not limited to the standards and protocols when they are described. Other similar standards and protocols not described herein exist and are included in this disclosure. Furthermore, the standards and protocols described herein, as well as other similar standards and protocols not described herein, are periodically replaced by faster or more efficient equivalents having essentially the same functions. Such replacement standards and protocols having the same functions are considered equivalents included within this disclosure.

[0064] In accordance with at least one example of the present disclosure, a method is provided for implementing changes made to source code of a program at runtime, the method may include executing the source code in a runtime environment, detecting changes made to the source code at runtime in the runtime environment, determining whether changes were made to a type in the source code identified as reloadable, and in response to determining that changes were made to a type in the source code identified as reloadable, creating a new version of the type, and implementing the changes to the source code at runtime using the new version of the type.

[0065] According to at least one aspect of the above method, the method may include executing the source code in a runtime environment including obtaining the source code, loading the source code into an integrated development environment (IDE), and executing the source code in the runtime environment deployed by the IDE.

[0066] According to at least one aspect of the above method, the method may further include, in response to determining that no changes were made to the types in the source code identified as reloadable, updating the types in-place.

[0067] According to at least one aspect of the above method, the method may include performing the implementation of changes to the source code at runtime using the new version of the type further includes replacing a runtime representation of a previous version of the type and one or more existing instances in the source code with the new version of the type.

[0068] According to at least one aspect of the above method, the method may include that implementing changes to the source code at runtime using the new version of the type further includes notifying a framework used to build the source code that a new version of the type has been created, and transferring state from one or more existing instances of a previous version of the type in the source code to the new version.

[0069] In accordance with at least one aspect of the above method, the method may further include continuing execution of the updated source code with the changes in the runtime environment.

[0070] According to at least one aspect of the above method, the method may include where determining whether changes have been made to types in the source code identified as reloadable further includes determining whether changes have been made to types in the source code identified as reloadable based on a framework library associated with a framework used to build the source code, the framework library including a list of predefined types that are marked as reloadable.

[0071] In accordance with at least one example of the present disclosure, a computing device for implementing changes made to source code of a program at runtime is provided. The computing device may include a processor and a memory having instructions stored thereon that, when executed by the processor, cause the computing device to execute the source code in a runtime environment, cause the runtime to detect changes made to the source code in the runtime environment, determine whether changes have been made to types in the source code identified as reloadable, and, in response to determining that changes have been made to types in the source code identified as reloadable, create a new version of the type, and cause the runtime to implement the changes to the source code using the new version of the type.

[0072] In accordance with at least one aspect of the computing device described above, the computing device may include, where executing the source code in a runtime environment includes obtaining the source code, loading the source code into an integrated development environment (IDE), and executing the source code in the runtime environment deployed by the IDE.

[0073] In accordance with at least one aspect of the computing device described above, the computing device may be further configured to update the type in-place in response to a determination that no changes were made to the type within the source code identified as reloadable.

[0074] According to at least one aspect of the computing device described above, the computing device may include: implementing changes to the source code at runtime using the new version of the type includes replacing a runtime representation of a previous version of the type and one or more existing instances in the source code with the new version of the type.

[0075] According to at least one aspect of the computing device described above, the computing device may include: implementing changes to source code at runtime using the new version of the type includes notifying a framework used to build the source code that a new version of the type has been created; and transferring state from one or more existing instances of a previous version of the type in the source code to the new version.

[0076] In accordance with at least one aspect of the computing device described above, the computing device may be further configured to continue executing the updated source code with the changes in the runtime environment.

[0077] According to at least one aspect of the computing device described above, the computing device may include determining whether changes have been made to types in the source code identified as reloadable based on a framework library associated with a framework used to build the source code, and the framework library may include including a list of predefined types that are marked as reloadable.

[0078] In accordance with at least one example of the present disclosure, a non-transitory computer-readable medium is provided that stores instructions for implementing changes made to source code of a program at runtime, which instructions, when executed by one or more processors of a computing device, cause the computing device to execute the source code in a runtime environment, cause the runtime to detect changes made to the source code in the runtime environment, determine whether changes have been made to types in the source code identified as reloadable, and, in response to determining that changes have been made to types in the source code identified as reloadable, create a new version of the type, and cause the runtime to implement the changes to the source code using the new version of the type.

[0079] In accordance with at least one aspect of the non-transitory computer-readable medium described above, the instructions, when executed by one or more processors of a computing device, may include executing the source code in a runtime environment including obtaining the source code, loading the source code into an integrated development environment (IDE), and executing the source code in the runtime environment deployed by the IDE.

[0080] According to at least one aspect of the non-transitory computer-readable medium described above, the instructions, when executed by one or more processors, may cause the computing device to update a type in-place in response to a determination that no changes have been made to a type within source code identified as reloadable.

[0081] According to at least one aspect of the non-transitory computer-readable medium described above, the instructions, when executed by one or more processors of the computing device, may include performing implementation of changes to source code at runtime using the new version of the type including replacing a runtime representation of a previous version of the type and one or more existing instances in the source code with the new version of the type.

[0082] According to at least one aspect of the non-transitory computer-readable medium described above, the instructions, when executed by one or more processors of the computing device, may include performing implementation of changes to source code at runtime using the new version of the type, including notifying a framework used to build the source code that a new version of the type has been created, and transitioning state from one or more existing instances of a previous version of the type in the source code to the new version.

[0083] In accordance with at least one aspect of the non-transitory computer-readable medium described above, the instructions, when executed by the one or more processors, may further cause the computing device to continue executing the updated source code with changes in the runtime environment.

[0084] The present disclosure includes, in various configurations and embodiments, components, methods, processes, systems, and / or apparatus substantially as illustrated and described herein, including various combinations, subcombinations, and subsets thereof. After understanding the present disclosure, a person skilled in the art will understand how to make and use the systems and methods disclosed herein. The present disclosure includes, in various configurations and embodiments, providing devices and processes without items not illustrated and / or described herein, or without items that may have been used in a previous device or process, for example to improve performance, achieve ease of implementation, and / or reduce cost.

Claims

1. A computing device for implementing changes made to the source code of a program at runtime, comprising: a processor; a memory storing a plurality of instructions; wherein when the plurality of instructions are executed by the processor, the computing device is caused to: execute the source code in a runtime environment, the source code including reloadable types and non-reloadable in-place types; detect changes made to the source code at runtime in the runtime environment; determine whether the changes were made to types in the source code identified as reloadable types based on a framework used to construct the source code, the framework including a framework library indicating whether the types in the source code are reloadable types or non-reloadable in-place types; create a new version of the reloadable types in response to a determination that the changes were made to the types in the source code identified as reloadable types; implement the changes to the source code at runtime using the new version of the reloadable types; and a computing device.

2. The computing device according to claim 1, wherein executing the source code in the runtime environment comprises: acquiring the source code; loading the source code into an integrated development environment (IDE); and executing the source code in the runtime environment arranged by the IDE. A computing device.

3. The computing device according to claim 1, further configured to update types in place in response to a determination that the changes were not made to the types in the source code identified as reloadable types.

4. The computing device according to claim 1, wherein A computing device that, when implementing the changes to the source code at runtime using the new version of the reloadable type, includes replacing the runtime representation of the previous version of the type in the source code and one or more existing instances with the new version of the reloadable type.

5. The computing device according to claim 1, wherein implementing the changes to the source code at runtime using the new version of the reloadable type includes notifying the framework used to build the source code that the new version of the reloadable type has been created; and transferring the state from one or more existing instances of the previous version of the type in the source code to the new version. A computing device.

6. A computing device according to claim 1, further configured to continue execution of the updated source code with the changes within the runtime environment.

7. A computing device according to claim 1, wherein determining whether the changes have been made to a type in the source code identified as reloadable further includes determining whether the changes have been made to a type in the source code identified as reloadable based on a framework library associated with the framework used to build the source code, and the framework library includes a list of predefined types marked as reloadable.

8. A non-transitory computer-readable medium storing instructions for implementing changes made to a program's source code at runtime, which, when executed by one or more processors of a computing device, cause the computing device to execute the source code in a runtime environment, where the source code includes reloadable types and non-reloadable in-place types. Detecting changes made to the source code at runtime in the runtime environment; Determining whether the changes were made to types within the source code identified as reloadable types based on a framework used to build the source code, the framework including a framework library indicating whether the types within the source code are reloadable types or non-reloadable types in-place; Creating a new version of the reloadable type in response to determining that the changes were made to the types within the source code identified as reloadable types; Using the new version of the reloadable type to effect the changes to the source code at runtime A non-transitory computer-readable medium that causes the above. **Claim 9** The non-transitory computer-readable medium according to claim 8, wherein executing the source code in the runtime environment comprises: Obtaining the source code; Loading the source code into an integrated development environment (IDE); Executing the source code in the runtime environment disposed by the IDE A non-transitory computer-readable medium that includes the above. **Claim 10** The non-transitory computer-readable medium according to claim 8, wherein when the instructions are executed by the one or more processors, the computing device is further caused to update the non-reloadable type in-place in response to determining that the changes were not made to the types within the source code identified as reloadable types. **Claim 11** The non-transitory computer-readable medium according to claim 8, wherein using the new version of the reloadable type to effect the changes to the source code at runtime includes replacing a runtime representation of a previous version of the type within the source code and one or more existing instances with the new version of the reloadable type. **Claim 12** A non-transitory computer-readable medium according to claim 8, wherein performing the change to the source code at runtime using the new version of the reloadable type comprises notifying a framework used to build the source code that the new version of the reloadable type has been created; transferring state from one or more existing instances of the previous version of the type in the source code to the new version; A non-transitory computer-readable medium comprising. **Claim 13** A non-transitory computer-readable medium according to claim 8, wherein when the instructions are executed by the one or more processors, the computing device is further caused to continue execution of the updated source code with the change in the runtime environment. **Claim 14** A method for implementing a change made to a program's source code at runtime, comprising executing the source code in a runtime environment, the source code including reloadable types and non-reloadable in-place types; detecting a change made to the source code at runtime in the runtime environment; determining, based on a framework used to build the source code, whether the change has been made to a type in the source code identified as a reloadable type, the framework including a framework library indicating whether the type in the source code is a reloadable type or a non-reloadable in-place type; creating a new version of the reloadable type in response to determining that the change has been made to the type in the source code identified as the reloadable type; performing the change to the source code at runtime using the new version of the reloadable type; A method comprising. **Claim 15** The method according to claim 14, wherein the step of executing the source code in the runtime environment comprises obtaining the source code; loading the source code into an integrated development environment (IDE); executing the source code in the runtime environment arranged by the IDE; A method comprising this. **Claim 16** The method according to claim 14, further comprising, in response to determining that the change was not made to the type in the source code identified as reloadable, updating the non-reloadable type in place. **Claim 17** The method according to claim 14, The step of implementing the change to the source code at runtime using the new version of the reloadable type further comprises replacing the runtime representation of the previous version of the type in the source code and one or more existing instances with the new version of the reloadable type. **Claim 18** The method according to claim 14, wherein the step of implementing the change to the source code at runtime using the new version of the reloadable type comprises notifying the framework used to build the source code that the new version of the reloadable type has been created; and migrating the state from one or more existing instances of the previous version of the type in the source code to the new version. A method further comprising this. **Claim 19** The method according to claim 14, wherein the step of determining whether the change was made to a type in the source code identified as reloadable further comprises determining whether the change was made to a type in the source code identified as reloadable based on a framework library associated with the framework used to build the source code, and the framework library includes a list of predefined types marked as reloadable. **Claim 20** The method according to claim 14, further comprising continuing to execute the updated source code with the change in the runtime environment.

Images