WO2009139964A1 - Dynamic declarative application description - Google Patents
Dynamic declarative application description Download PDFInfo
- Publication number
- WO2009139964A1 WO2009139964A1 PCT/US2009/038646 US2009038646W WO2009139964A1 WO 2009139964 A1 WO2009139964 A1 WO 2009139964A1 US 2009038646 W US2009038646 W US 2009038646W WO 2009139964 A1 WO2009139964 A1 WO 2009139964A1
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- application
- act
- code
- changes
- portions
- Prior art date
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/65—Updates
- G06F8/656—Updates while running
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
Definitions
- Procedural languages may include ASP, PERL, Python and C, among others. Such languages generally require a high level detail regarding event handling and state changes. This is more pronounced in cases where the user interface changes as a result of various user inputs. [0003] Declarative languages have alleviated some of this burden by allowing developers to generally specify how to handle certain events or state changes without having to write code for each specific situation. However, many times declarative languages lack the dynamism to allow the declarative specification of rich data driven applications. Moreover, declarative languages often limit the types of modifications that can be performed during operation of the application, without having to terminate, recompile, and restart the application.
- Embodiments described herein are directed to dynamically reconfiguring at least a portion of an operating software application.
- a computer system receives an edit indicating that at least one portion of an operating software application is to be edited, where the edit includes changes that are to be dynamically applied to the application.
- the computer system instantiates dynamic configuration builders designed to implement application changes as indicated by the received edit and determines which portions of the application are to be suspended while the changes to the application are implemented.
- the computer system suspends the determined application portions until the application changes are implemented and implements the changes indicated by the edit on the suspended portion of the application, while the remainder of the application continues operating.
- the computer system also dynamically reconfigures the application with the implemented changes, where the reconfiguring includes reinitializing the suspended application portions.
- a computer system receives an indication that one or more portions of an application are to be reconfigured while the application is operating.
- the computer system instantiates dynamic configuration builders configured to implement application reconfigurations as indicated by the received indication and determines which static code pieces are to be used to perform the reconfigurations.
- the configuration builders access static code to provide those static code pieces that are to be used to perform the reconfigurations.
- the computer system receives a call from at least one of the static code pieces for a portion of dynamic code to perform the reconfigurations based on the indication and reconfigures the indicated portion of the application using the dynamic code portion to modify the static code pieces.
- Figure 1 illustrates a computer architecture in which embodiments of the present invention may operate including dynamically reconfiguring at least a portion of an operating software application.
- Figure 2 illustrates a computer architecture in which embodiments of the present invention may operate including allowing a user to reconfigure an application by editing data, where static software code is configured to call dynamic software code to perform dynamic reconfigurations received from a user.
- Figure 3 illustrates a flowchart of an example method for dynamically reconfiguring at least a portion of an operating software application.
- Figure 4 illustrates a flowchart of an example method for allowing a user to reconfigure an application by editing data, where static software code is configured to call dynamic software code to perform dynamic reconfigurations received from a user.
- Embodiments described herein are directed to dynamically reconfiguring at least a portion of an operating software application.
- a computer system receives an edit indicating that at least one portion of an operating software application is to be edited, where the edit includes changes that are to be dynamically applied to the application.
- the computer system instantiates dynamic configuration builders designed to implement application changes as indicated by the received edit and determines which portions of the application are to be suspended while the changes to the application are implemented.
- the computer system suspends the determined application portions until the application changes are implemented and implements the changes indicated by the edit on the suspended portion of the application, while the remainder of the application continues operating.
- the computer system also dynamically reconfigures the application with the implemented changes, where the reconfiguring includes reinitializing the suspended application portions.
- a computer system receives an indication that one or more portions of an application are to be reconfigured while the application is operating.
- the computer system instantiates dynamic configuration builders configured to implement application reconfigurations as indicated by the received indication and determines which static code pieces are to be used to perform the reconfigurations.
- the configuration builders access static code to provide those static code pieces that are to be used to perform the reconfigurations.
- the computer system receives a call from at least one of the static code pieces for a portion of dynamic code to perform the reconfigurations based on the indication and reconfigures the indicated portion of the application using the dynamic code portion to modify the static code pieces.
- Embodiments of the present invention may comprise or utilize a special purpose or general-purpose computer including computer hardware, as discussed in greater detail below.
- Embodiments within the scope of the present invention also include physical and other computer-readable media for carrying or storing computer-executable instructions and/or data structures.
- Such computer-readable media can be any available media that can be accessed by a general purpose or special purpose computer system.
- Computer-readable media that store computer- executable instructions are physical storage media.
- Computer-readable media that carry computer-executable instructions are transmission media.
- embodiments of the invention can comprise at least two distinctly different kinds of computer-readable media: physical storage media and transmission media.
- Physical storage media includes RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store desired program code means in the form of computer-executable instructions or data structures and which can be accessed by a general purpose or special purpose computer.
- a "network" is defined as one or more data links that enable the transport of electronic data between computer systems and/or modules and/or other electronic devices. When information is transferred or provided over a network or another communications connection (either hardwired, wireless, or a combination of hardwired or wireless) to a computer, the computer properly views the connection as a transmission medium.
- Transmission media can include a network and/or data links which can be used to carry or transport desired program code means in the form of computer-executable instructions or data structures and which can be accessed by a general purpose or special purpose computer. Combinations of the above should also be included within the scope of computer-readable media. [0017] However, it should be understood, that upon reaching various computer system components, program code means in the form of computer-executable instructions or data structures can be transferred automatically from transmission media to physical storage media. For example, computer-executable instructions or data structures received over a network or data link can be buffered in RAM within a network interface card, and then eventually transferred to computer system RAM and/or to less volatile physical storage media at a computer system.
- Computer-executable instructions comprise, for example, instructions and data which cause a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions.
- the computer executable instructions may be, for example, binaries, intermediate format instructions such as assembly language, or even source code.
- the invention may be practiced in network computing environments with many types of computer system configurations, including, personal computers, desktop computers, laptop computers, message processors, hand-held devices, multi-processor systems, microprocessor-based or programmable consumer electronics, network PCs, minicomputers, mainframe computers, mobile telephones, PDAs, pagers, routers, switches, and the like.
- the invention may also be practiced in distributed system environments where local and remote computer systems, which are linked (either by hardwired data links, wireless data links, or by a combination of hardwired and wireless data links) through a network, both perform tasks.
- program modules may be located in both local and remote memory storage devices.
- Figure 1 illustrates a computer architecture 100 in which the principles of the present invention may be employed.
- the elements of Figure 1 may be implemented in or otherwise be a part of a computer system.
- User interface 125 may be any type of textual, graphical or other type of user interface.
- User interface (UI) 125 may be configured to display portions of software application 101. Additionally or alternatively, UI 125 may display user objects 126.
- User objects may include buttons, windows, links, graphics, icons or other graphical objects. In some cases, user objects may act as labels or indicators of underlying functionality provided by software application 101.
- Application 101 may be any type of software application, designed for any purpose. The application may include multiple components or only a single component.
- application 101 may be generated, compiled or stitched together at runtime.
- Engine 110 may be configured to perform all or a portion of the generation, compilation or stitching together at runtime. These functions may also be performed by engine 110 at some other time before runtime.
- Engine 110 may be configured to receive application description portions 115.
- application description portions 115 may include various software objects which may be used to create a working software application. The software objects may be tagged with one or more tags which declaratively indicate how the software objects are to be used, individually and in conjunction with other software objects. Such software objects may form the basis for various portions of software application functionality and may be declaratively stitched together by engine 110, as indicated above. [0022]
- Engine 110 may also be configured to receive framework objects 118.
- Framework objects may include any of user objects 126 as well as other application-oriented framework portions used in generating a software application. This may include libraries, bindings or other objects.
- Engine 110 may include parameter binding manager 109.
- Parameter binding manager 109 may be configured to access application description portions 115 including software objects and tags. Manager 109 may map portions of the application description identified by the tags to various software objects using reflection. Reflection, as used herein, includes accessing properties associated with the software objects, which in some cases, involves viewing metadata associated with the software objects.
- Parameter binding manager 109 may also be configured to bind the software objects' properties to various portions of the application description (e.g., 115) based on different declarative rules included in the software object properties associated with the software object. In some cases, software object properties may be bound to data items.
- Application description 115 may include such data items to which properties may be bound. Additionally or alternatively, software object properties may be bound to data items that are not included in the application description.
- Engine 110 may be further configured to access data 105 and generate combined objects 111.
- Data 105 may be any type of information usable by engine 110 to generate software application 101.
- data 105 may be accessible by application 101 on an ongoing basis. Thus, as a user interacts with application 101, data may be streamed or otherwise sent to either or both of application 101 and engine 110.
- Combined objects 111 indicates one or more software objects stitched together or otherwise combined by engine 110. In some cases, combined objects 111 may form the basis of software application 101 or may themselves comprise application 101.
- Software application 101 may be continually updated and altered as a result of a passage of time or due to interaction from a user or other application. For example, some action may occur (e.g., action 106) that indicates that software application 101 is to be modified. In some cases, this action may be a change in data. Such a change in data may indicate to engine 110 that the change in data is to be translated into changes to the software application. Data connectors 107 may be used to identify which data is to be modified and may be configured to communicate with data 105 to retrieve the updated information. Transforms 108 may be used to transform, reformat, or otherwise modify the retrieved data before transferring it to parameter binding manager 109.
- Parameter binding manager 109 may also play an integral role as part of application 101 including remapping various tags and binding software object properties to portions of application description 115. Parameter binding manager 109 may also be configured to interact directly with user interface 125, providing UI 125 with updated information that is to be displayed to a computer user.
- engine 110 may be a XAD engine.
- XAD which is short for extensible markup language (XML) Application Framework (XAF) Application Definition (XAD) language, is a declarative or descriptive language. In some cases, XAD may be used to author XAF applications (e.g., application 101) based on the XAF platform.
- XAD may indicate how to create a runtime object graph based on user-configurable construction information and/or application description portions 115.
- a XAD engine e.g., engine 110
- parameter binding manager 109 may process or execute the application description to create objects which view and/or process data.
- XAD may be used within the application framework to provide a standard and simple means of stating actions or other occurrences within the framework.
- a developer may be able to avoid writing the actual code for the objects that do the data processing. For example, the developer may only need to write the files for the declarative application that are ultimately compiled and executed.
- XAD offers progressive levels of abstraction to assist in design, strong typing, a high degree of static checking, and a high degree of extensibility. XAD also allows manipulation of heterogeneous data.
- XAF and XAD are mentioned herein and may be incorporated in one or more embodiments, it will be understood by one skilled in the art that functionality provided by either or both of XAD and XAF may additionally or alternatively be provided by other software applications, computer systems, or functionality providing entities.
- XAF is a software application framework for generating a runtime structure for a given software application and for managing execution of the software application.
- Application 101 may be generated by an application framework that includes a collection or graph of connected application components.
- Functionalities of an application configured according to the application framework are enabled by dynamically configuring groups of application components into component domains where each domain is configured to enable a given functionality of the application, for example, displaying a picture in a word processing document.
- an application may pass an application description for each piece of application functionality to an application description engine.
- the application description provides declarative rules for structuring and composing the component domains, and the application description engine is operative to interpret the declarative rules for creating and reconfiguring the component domains as required based on data events received by the application.
- Data events may be any type of software message, user input, or other indication that something has occurred that may affect the software application. Data events may occur, for example, when a user clicks a mouse to interact with the application, or when an error message is presented during processing of the application.
- XAF may be configured to track dependencies such that data evaluations and object graph constructions may be incrementally updated when data changes.
- XAF may track dependencies in data 105 such that software application 101 may be incrementally updated when data 105 is updated. In some embodiments, this incremental updating is carried out automatically by XAF.
- engine 110 may invoke a configuration builder 112 associated with at least one of application 101's entry points. This results in one or more objects being created, and possibly some objects being registered for initialization. These initializations may be performed, which may result in more configuration builders being invoked, which may result in more objects being created, and perhaps more objects being registered for initialization.
- engine 110 may be configured to receive edits 114. Edits 114 may include an indication that at least one portion of an operating software application is to be edited. For example, while software application 101 is running on a computer system, a computer user may desire to edit one or more parts of the application. These parts may include user objects 126 or any other part of application 101. In some cases, one or more configuration builders 112 may be instantiated by engine 1 10 to implement application changes as indicated by edits 114. [0032] In some cases, it may be advantageous to temporarily suspend or shut down portions of application 101 while edits are made.
- Engine 110 may be configured to determine which portions of application 101 are to be suspended while the changes to the application are implemented.
- Suspending module 113 may be configured to suspend those portions of the application for which it was determined that suspension was beneficial or necessary.
- Engine 110 may implement the changed indicated in edits 114 on the suspended portions of the application. In some embodiments, the entire application may be suspended while the changes are implemented. Alternatively, in some embodiments, only a portion of the application may be suspended while the changes are implemented. In such cases, the remainder of the application may continue running while the edits are being performed. Edits to the application (e.g., edits 120) may be passed on to any of application description portions 115, user interface 125 and software application 101.
- Figure 2 illustrates a computer architecture 200 in which the principles of the present invention may be employed.
- Figure 3 illustrates a flowchart of a method 300 for dynamically reconfiguring at least a portion of an operating software application. The method 300 will now be described with frequent reference to the components and data of environments 100 and 200 of Figures 1 and 2.
- Method 300 includes an act of receiving an edit indicating that at least one portion of an operating software application is to be edited, the edit including changes that are to be dynamically applied to the application (act 310).
- engine 110 may receive edit 114 indicating that at least one portion of operating software application 101 is to be edited, where the edit includes changes that are to be dynamically applied to application 101.
- the edits to the application include edits to model data within the application.
- application 101 may be configured to edit (or may currently be editing) data that corresponds to a model. In such cases, both the application and the model data are editable data, and may be edited as indicated in edit 114.
- application 101 may include one or more extension points through which code portions can be added or removed. These code portions may include static code objects 116, dynamic code objects 117 and/or framework objects 118. As used herein, static code objects may include any software code portions that are unchangeable (or are unchangeable without shutting the corresponding software application down and recompiling the application). Dynamic code objects, as used herein, refer to software code portions that are changeable and may be modified while the corresponding software application is running.
- code portions may be added through one or more of the application's extension points and dynamically recompiled while the application is running. Similarly, code portions may be removed through the extension points and the application (or a portion thereof) may be dynamically recompiled. In some cases, application 101 may be capable of editing portions of its own code using the application's extension points.
- Method 300 includes an act of instantiating one or more dynamic configuration builders designed to implement application changes as indicated by the received edit (act 320).
- engine 110 may instantiate dynamic configuration builders 112 designed to implement application changes indicated in edits 114.
- configuration builders 112 may be configured to monitor and identify changes in application state for application 101. These state changes and related state information may be stored in a local or remote data store. Preserving the state changes allows for application reconfiguration while maintaining state. This concept will be explained in greater detail below.
- Method 300 includes an act of determining which portions of the application are to be suspended while the changes to the application are implemented (act 330).
- engine 110 may determine which portions of application 101 are to be suspended while the changes to the application indicated in edits 114 are implemented.
- application 220A may include static portions 22 IA, 22 IB and 221C, along with dynamic portions 222 A.
- Engine 210 may determine that edits 114 indicate that changes are to be made to static portion 22 IB. Based on this determination, engine 110 may determine that portion 22 IB is to be suspended while the changes to application 220A are being implemented. In determining which code portions to suspend, care should be taken to ensure that the minimal set of application portions that allows the indicated changes to be performed be suspended. In other words, each received edit may be implemented by suspending certain portions of application 220A.
- Method 300 includes an act of suspending the determined application portions until the application changes are implemented (act 340).
- suspending module 213 may suspend static portion 22 IB until the changes to application 220A are implemented.
- static portion 22 IB may be sent to configuration builders 212 for modification.
- Method 300 includes an act of implementing the changes indicated by the edit on the suspended portion of the application, wherein the remainder of the application continues operating (act 350).
- configuration builders 212 may implement the changes to code portion 22 IB indicated in edit 114, while the remainder of application 220A continues running (e.g., application 220B).
- the edits may be minor or extensive, and may thus increase or decrease the time spent in modification.
- Engine 210 may include state monitoring module 214 which may monitor and assess current state configurations in static code portion 22 IB as it is accessed in application 220A. State monitoring module 214 may be configured to store current state settings in static portion 22 IB and/or application 220A as a whole.
- Method 300 includes an act of dynamically reconfiguring the application with the implemented changes, where the reconfiguring includes reinitializing the suspended application portions (act 360).
- engine 210 may dynamically reconfigure application 220B with the changes implemented by configuration builders 212.
- the reconfiguring includes reinitializing suspended static portion 22 IB (now modified portion 22 IBM) in application 220C.
- reconfigured application 220C includes original static portions 22 IA and 221C, as well as modified static portion 221BM and dynamic portions 222C.
- FIG. 4 illustrates a flowchart of a method 400 for allowing a user to reconfigure an application by editing data, where static software code is configured to call dynamic software code to perform dynamic reconfigurations received from a user.
- the method 400 will now be described with frequent reference to the components and data of environment 200 of Figure 2.
- Method 400 includes an act of receiving an indication that one or more portions of an application are to be reconfigured while the application is operating (act 410).
- engine 110 may receive edits 114 indicating that one or more portions of application 101 are to be reconfigured while application 101 continues to operate.
- Edits 114 may be received from a computer user, from a software application, or from another computer system.
- the edits may include any type of modification to application 101 including settings changes, code changes, or any other type of changes.
- Method 400 includes an act of instantiating one or more dynamic configuration builders configured to implement application reconfigurations as indicated by the received indication (act 420).
- engine 110 may instantiate dynamic configuration builders 112 to implement application reconfigurations as indicated by edits 114.
- Builders 112 may be used by engine 110 to determine, based on the received edits, what changes are to be made to application 101. The changes may affect one or more code portions, as illustrated in application 220A including static code portions 221A, 221B and 221C, as well as dynamic code portions 222A.
- Method 400 includes an act of determining which static code pieces are to be used to perform the reconfigurations (act 430).
- engine 110 may determine that static code portion 22 IB is to be used in performing the reconfiguration.
- an application declaration e.g., application description 115
- Such application declarations may be stored in a repository, either locally or remotely.
- application 220A may include any number of static and/or dynamic code portions.
- any number of code portions may be suspended and/or modified by engine 210.
- Method 400 includes an act of at least one of the instantiated dynamic configuration builders accessing static code to provide those static code pieces that are to be used to perform the reconfigurations (act 440).
- dynamic configuration builders 212 may access static code portions 22 IA, 22 IB and/or 221C to provide those static pieces (i.e., 221B) that are to be used to perform the reconfiguration.
- static code portion 212B contains the code corresponding to the indicated change(s).
- a software mechanism referred to herein as a dynamic invoker may expose portions of application 220A back to dynamic code portions 222A, such that the dynamic code can use the exposed static pieces to perform the reconfigurations.
- a dynamic invoker may point at various runtime pieces which reads in code (e.g., objects 116 and/or 117) from a repository and compile the code.
- the application is responsible for defining the extension points through which the dynamic invoker can add or remove code.
- the application may be static, compiled code, but can declare extension points that allow editing of the application itself.
- the dynamic invoker may build at least a portion of the application based on inputs supplied by the application.
- dynamic code portions 222 A may use static code portions 22 IA, 22 IB and/or 221C in performing the reconfigurations.
- dynamic configuration builders 212 may include editable data. In such cases, the builders 212 may conform to a schema understandable by various static configuration builders.
- Method 400 includes an act of receiving a call from at least one of the static code pieces for at least a portion of dynamic code to perform the reconfigurations based on the indication (act 450).
- engine 210 may receive a call from static portion 22 IB for dynamic code portion 222 A to perform the reconfigurations based on the indication.
- static code portions can call dynamic portions to perform reconfigurations
- dynamic code may also call into static application code to perform the edits. Further code calling iterations and compilations are also possible.
- engine 210 may allow various code portions to call into each other to accomplish various goals, including performing application reconfigurations.
- Method 400 includes an act of the at least one instantiated dynamic configuration builder reconfiguring the indicated portion of the application using the dynamic code portion to modify the static code pieces (act 460).
- configuration builders 212 may reconfigure static code portion 22 IB using dynamic code portion 222A to modify static code portion 22 IB.
- application state may be monitored and stored by state monitoring module 214.
- state monitoring module 214 may monitor and stored by state monitoring module 214.
- any state settings or other state information is maintained and updated in the reconfiguration.
- engine 110 may receive an edit (e.g., 114) indicating that at least one portion of an operating software application (e.g., 101) is to be edited.
- the edit may include changes that are to be dynamically applied to application 101.
- Engine 110 may instantiate dynamic configuration builders (e.g., 112) designed to implement application changes as indicated by the received edit (e.g., 1 14).
- Engine 110 may determine a minimal set of application portions (e.g., I l l) that are to be suspended to allow the indicated changes to be implemented.
- Suspending module 113/213 may suspend the determined application portions until the application changes are implemented.
- At least one of the instantiated dynamic configuration builders may access static code (e.g., 116) to provide those static code pieces that are to be used to perform the edits.
- Engine 110 may receive a call from at least one of the static code pieces for at least a portion of dynamic code (e.g., 117) to perform the edits based on the indication, while the remainder of the application (e.g., 101) continues operating.
- Engine 110 may dynamically reconfigure the application with the implemented changes using the dynamic code portion to modify the static code pieces.
- the reconfiguring also includes reinitializing those portions of the application that were suspended. In this manner, an application may be updated and reconfigured on-the-fly, with only a minimal portion of the application being temporarily suspended to enact the requested changes.
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
Description
Claims
Priority Applications (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
JP2011509507A JP2011521352A (en) | 2008-05-15 | 2009-03-27 | Dynamic declarative application description |
EP09747050A EP2300924A4 (en) | 2008-05-15 | 2009-03-27 | Dynamic declarative application description |
CN200980117836.7A CN102027460B (en) | 2008-05-15 | 2009-03-27 | Dynamic declarative application description |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US12/121,497 US20090288069A1 (en) | 2008-05-15 | 2008-05-15 | Dynamic Declarative Application Description |
US12/121,497 | 2008-05-15 |
Publications (1)
Publication Number | Publication Date |
---|---|
WO2009139964A1 true WO2009139964A1 (en) | 2009-11-19 |
Family
ID=41317363
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/US2009/038646 WO2009139964A1 (en) | 2008-05-15 | 2009-03-27 | Dynamic declarative application description |
Country Status (6)
Country | Link |
---|---|
US (1) | US20090288069A1 (en) |
EP (1) | EP2300924A4 (en) |
JP (1) | JP2011521352A (en) |
KR (1) | KR20110014146A (en) |
CN (1) | CN102027460B (en) |
WO (1) | WO2009139964A1 (en) |
Cited By (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
GB2523074A (en) * | 2013-12-16 | 2015-08-19 | Make Apps Better Ltd | A method and system for modifying deployed applications |
US10255044B2 (en) | 2013-12-16 | 2019-04-09 | Make Apps Better Ltd | Method and system for modifying deployed applications |
Families Citing this family (11)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8132148B2 (en) | 2005-04-29 | 2012-03-06 | Microsoft Corporation | XML application framework |
US8799857B2 (en) * | 2005-04-29 | 2014-08-05 | Microsoft Corporation | XML application framework |
US8201147B2 (en) * | 2008-02-08 | 2012-06-12 | Microsoft Corporation | Generic XAD processing model |
US8984482B2 (en) * | 2008-12-09 | 2015-03-17 | Microsoft Technology Licensing, Llc | Abstracting request from a development environment to object model |
US8336027B2 (en) | 2009-05-27 | 2012-12-18 | Microsoft Corporation | Hierarchical view state storage |
US8756515B2 (en) * | 2009-11-16 | 2014-06-17 | Microsoft Corporation | Dynamic editors for functionally composed UI |
US8768902B2 (en) | 2010-06-11 | 2014-07-01 | Microsoft Corporation | Unified concurrent changes to data, schema, and application |
US20120117497A1 (en) * | 2010-11-08 | 2012-05-10 | Nokia Corporation | Method and apparatus for applying changes to a user interface |
JP6138482B2 (en) * | 2012-12-25 | 2017-05-31 | Necエンジニアリング株式会社 | Embedded system |
US9021428B2 (en) | 2013-05-29 | 2015-04-28 | Microsoft Technology Licensing, Llc | Troubleshooting visuals and transient expressions in executing applications |
KR101712609B1 (en) * | 2014-12-30 | 2017-03-08 | 엔에이치엔엔터테인먼트 주식회사 | Cloud service system and method for providing initial information |
Citations (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6502176B1 (en) * | 1999-02-24 | 2002-12-31 | Hitachi, Ltd. | Computer system and methods for loading and modifying a control program without stopping the computer system using reserve areas |
US6836884B1 (en) * | 2001-06-04 | 2004-12-28 | Microsoft Corporation | Method and system for editing software programs |
US20050071839A1 (en) * | 2003-09-25 | 2005-03-31 | Curitel Communications, Inc. | Communication terminal and communication network for partially updating software, software update method, and software creation device and method therefor |
US20060053419A1 (en) * | 2004-09-09 | 2006-03-09 | International Business Machines Corporation | Method and system for modifying installation software |
Family Cites Families (32)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5226160A (en) * | 1989-07-18 | 1993-07-06 | Visage | Method of and system for interactive video-audio-computer open architecture operation |
US5680619A (en) * | 1995-04-03 | 1997-10-21 | Mfactory, Inc. | Hierarchical encapsulation of instantiated objects in a multimedia authoring system |
US5758032A (en) * | 1995-04-13 | 1998-05-26 | Sterling Software, Inc. | Method and system for automated transformation of declarative language process specification |
US5960194A (en) * | 1995-09-11 | 1999-09-28 | International Business Machines Corporation | Method for generating a multi-tiered index for partitioned data |
EP1071991A4 (en) * | 1997-12-11 | 2002-03-13 | Digits Corp | Object code analysis and remediation system and method |
US6351843B1 (en) * | 1998-08-31 | 2002-02-26 | International Business Machines Corporation | Dynamically inserting a function into an application executable at runtime |
US6378128B1 (en) * | 1998-10-08 | 2002-04-23 | Microsoft Corporation | System and method for dynamically modifying an install-set |
US6725333B1 (en) * | 1999-04-22 | 2004-04-20 | International Business Machines Corporation | System and method for managing cachable entities |
US7089530B1 (en) * | 1999-05-17 | 2006-08-08 | Invensys Systems, Inc. | Process control configuration system with connection validation and configuration |
US7249328B1 (en) * | 1999-05-21 | 2007-07-24 | E-Numerate Solutions, Inc. | Tree view for reusable data markup language |
US6470344B1 (en) * | 1999-05-29 | 2002-10-22 | Oracle Corporation | Buffering a hierarchical index of multi-dimensional data |
US6496976B1 (en) * | 1999-08-05 | 2002-12-17 | Unisys Corporation | Method and system for dynamic recompilation of statements of a first language embedded in a program having statements of a second language |
US6438562B1 (en) * | 1999-08-24 | 2002-08-20 | Oracle Corporation | Parallel index maintenance |
US7404175B2 (en) * | 2000-10-10 | 2008-07-22 | Bea Systems, Inc. | Smart generator |
WO2001090887A1 (en) * | 2000-05-25 | 2001-11-29 | Fujitsu Limited | Method fir processing program for high-speed processing by using dynamically reconfigurable hardware and program for executing the processing method |
US7386832B2 (en) * | 2001-08-31 | 2008-06-10 | Siebel Systems, Inc. | Configurator using structure to provide a user interface |
US6915513B2 (en) * | 2001-11-29 | 2005-07-05 | Hewlett-Packard Development Company, L.P. | System and method for dynamically replacing code |
US20030135825A1 (en) * | 2001-12-05 | 2003-07-17 | Matthew Gertner | Dynamically generated mark-up based graphical user interfaced with an extensible application framework with links to enterprise resources |
US7159221B1 (en) * | 2002-08-30 | 2007-01-02 | Unisys Corporation | Computer OS dispatcher operation with user controllable dedication |
US20040162843A1 (en) * | 2003-02-19 | 2004-08-19 | Sun Microsystems, Inc. | Method, system, and article of manufacture for evaluating an object |
US20050172282A1 (en) * | 2004-01-30 | 2005-08-04 | Michael Shenfield | System and method for publishing and accessing application APIs on a generic terminal |
US20060130038A1 (en) * | 2004-12-15 | 2006-06-15 | Claussen Christopher S | Apparatus, system, and method for facilitating dynamic modification of existing software objects defined in a strongly-typed programming language |
US7478218B2 (en) * | 2005-02-18 | 2009-01-13 | Vmware, Inc. | Adaptive cache sizing based on monitoring of regenerated and replaced cache entries |
US8799857B2 (en) * | 2005-04-29 | 2014-08-05 | Microsoft Corporation | XML application framework |
US8418132B2 (en) * | 2005-04-29 | 2013-04-09 | Microsoft Corporation | Application description language |
US20070261041A1 (en) * | 2005-08-23 | 2007-11-08 | Lisa Amini | Method and system for dynamic application composition in streaming systems |
US7818736B2 (en) * | 2005-09-14 | 2010-10-19 | International Business Machines Corporation | Dynamic update mechanisms in operating systems |
US7882499B2 (en) * | 2005-10-24 | 2011-02-01 | Microsoft Corporation | Caching dynamically compiled code to storage |
EP1857930A3 (en) * | 2006-05-17 | 2008-07-23 | Ipreo Holdings LLC | System, method, and apparatus to allow for a design, administration, and presentation of computer software applications |
US8429613B2 (en) * | 2006-10-31 | 2013-04-23 | Microsoft Corporation | Stepping and application state viewing between points |
US8291374B2 (en) * | 2007-11-05 | 2012-10-16 | Cullum Owen H G | System and method for generating modified source code based on change-models |
US8336027B2 (en) * | 2009-05-27 | 2012-12-18 | Microsoft Corporation | Hierarchical view state storage |
-
2008
- 2008-05-15 US US12/121,497 patent/US20090288069A1/en not_active Abandoned
-
2009
- 2009-03-27 EP EP09747050A patent/EP2300924A4/en not_active Withdrawn
- 2009-03-27 WO PCT/US2009/038646 patent/WO2009139964A1/en active Application Filing
- 2009-03-27 CN CN200980117836.7A patent/CN102027460B/en not_active Expired - Fee Related
- 2009-03-27 JP JP2011509507A patent/JP2011521352A/en active Pending
- 2009-03-27 KR KR1020107025075A patent/KR20110014146A/en not_active Application Discontinuation
Patent Citations (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6502176B1 (en) * | 1999-02-24 | 2002-12-31 | Hitachi, Ltd. | Computer system and methods for loading and modifying a control program without stopping the computer system using reserve areas |
US6836884B1 (en) * | 2001-06-04 | 2004-12-28 | Microsoft Corporation | Method and system for editing software programs |
US20050071839A1 (en) * | 2003-09-25 | 2005-03-31 | Curitel Communications, Inc. | Communication terminal and communication network for partially updating software, software update method, and software creation device and method therefor |
US20060053419A1 (en) * | 2004-09-09 | 2006-03-09 | International Business Machines Corporation | Method and system for modifying installation software |
Non-Patent Citations (1)
Title |
---|
See also references of EP2300924A4 * |
Cited By (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
GB2523074A (en) * | 2013-12-16 | 2015-08-19 | Make Apps Better Ltd | A method and system for modifying deployed applications |
US10255044B2 (en) | 2013-12-16 | 2019-04-09 | Make Apps Better Ltd | Method and system for modifying deployed applications |
Also Published As
Publication number | Publication date |
---|---|
EP2300924A1 (en) | 2011-03-30 |
EP2300924A4 (en) | 2011-08-10 |
US20090288069A1 (en) | 2009-11-19 |
CN102027460B (en) | 2014-06-18 |
KR20110014146A (en) | 2011-02-10 |
CN102027460A (en) | 2011-04-20 |
JP2011521352A (en) | 2011-07-21 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US20090288069A1 (en) | Dynamic Declarative Application Description | |
Sharp | Microsoft Visual C# 2013 Step by Step | |
JP5710852B2 (en) | A framework for seamless authoring and editing of workflows at design and runtime | |
Komatineni et al. | Pro Android 4 | |
JP5173128B2 (en) | A unified model for authoring and executing flow-based and constraint-based workflows | |
US8799857B2 (en) | XML application framework | |
US8793649B2 (en) | XML application framework | |
US6230318B1 (en) | Application programs constructed entirely from autonomous component objects | |
US7469402B2 (en) | Pluggable model framework | |
Moskala et al. | Android Development with Kotlin | |
US8201147B2 (en) | Generic XAD processing model | |
Mackey | Introducing. NET 4.0: With Visual Studio 2010 | |
US7096475B2 (en) | Runlets as application execution units | |
US7707593B2 (en) | Object models enabling hosting content in a plurality of environments | |
Hall | Pro WPF and Silverlight MVVM: effective application development with Model-View-ViewModel | |
US20090112570A1 (en) | Declarative model interpretation | |
Himschoot | Blazor Revealed | |
Smyth | Android Studio 4.1 Development Essentials-Kotlin Edition | |
Taher | Hands-On Object-Oriented Programming with C#: Build maintainable software with reusable code using C | |
Troelsen | Pro C# With. Net 3.0 | |
Wexbridge et al. | NetBeans Platform for Beginners | |
Allen | Programming Windows Workflow Foundation: Practical WF Techniques and Examples using XAML and C | |
Smyth | Android Studio 3.4 Development Essentials-Kotlin Edition | |
Dovey et al. | Beginning Objective-C | |
Álvarez-Acebal | From JavaScript to React. js: Best Practices for Migration |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
WWE | Wipo information: entry into national phase |
Ref document number: 200980117836.7 Country of ref document: CN |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application |
Ref document number: 09747050 Country of ref document: EP Kind code of ref document: A1 |
|
WWE | Wipo information: entry into national phase |
Ref document number: 7033/CHENP/2010 Country of ref document: IN |
|
ENP | Entry into the national phase |
Ref document number: 20107025075 Country of ref document: KR Kind code of ref document: A |
|
WWE | Wipo information: entry into national phase |
Ref document number: 2011509507 Country of ref document: JP |
|
NENP | Non-entry into the national phase |
Ref country code: DE |
|
WWE | Wipo information: entry into national phase |
Ref document number: 2009747050 Country of ref document: EP |