|Publication number||US8209674 B2|
|Application number||US 11/674,041|
|Publication date||Jun 26, 2012|
|Filing date||Feb 12, 2007|
|Priority date||Feb 12, 2007|
|Also published as||US20080196025|
|Publication number||11674041, 674041, US 8209674 B2, US 8209674B2, US-B2-8209674, US8209674 B2, US8209674B2|
|Inventors||Henricus Johannes Maria Meijer, Brian C. Beckman, Christopher W. Brumme, Mark B. Shields, Wei Zhu|
|Original Assignee||Microsoft Corporation|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (26), Non-Patent Citations (8), Referenced by (8), Classifications (14), Legal Events (3)|
|External Links: USPTO, USPTO Assignment, Espacenet|
Traditionally, web-applications are written with a server-side bias. A browser submits requests for HTML pages that are dynamically generated on the server-side and pushed back as a whole to the browser. Thus, most of the computation is done by the server. Furthermore, since the HTTP protocol that is used to communicate between a browser and a web-server is stateless, the server-side program simply handles single requests and then terminates. It has no intrinsic memory of previous interactions with the browser, nor does it maintain any state until servicing the next request. As a result, the burden is on the programmer to maintain cross-request state using one many features that server-side frameworks provide.
As mentioned above, both client and server centric programming models require programmers to understand many different technologies and force programmers to decide upfront how to split computation between client and server. This causes programmers to turn their code inside out to deal with asynchronous callbacks, among other distributed programming issues. Matters are further complicated by the fact that they cannot user standard libraries that they may have used to develop conventional applications (e.g., forms, base class . . . ).
The following presents a simplified summary in order to provide a basic understanding of some aspects of the claimed subject matter. This summary is not an extensive overview. It is not intended to identify key/critical elements or to delineate the scope of the claimed subject matter. Its sole purpose is to present some concepts in a simplified form as a prelude to the more detailed description that is presented later.
Briefly described, the claimed subject matter pertains broadly to distributed programs and generation thereof. A rich and broad reaching tool-set, application model and supporting infrastructure are provided to facilitate generation of rich distributed applications. These mechanisms enable programmers to develop distributed programs in a single tier or tier agnostic manner. Subsequently or concurrently, programs can be split or sliced into multiple tiers supporting distributed execution across the tiers.
In accordance with one aspect of the disclosure, a tier-splitting component is provided to facilitate transforming single tier applications into multi-tier applications. The tier-splitting component enables automatic or semi-automatic program splitting, for example based on program analysis and execution environment characteristics such as processing capabilities of tier components and network communication speed. The tier-splitting component can also generate dynamic applications that are able to adjust splitting as a function of runtime context information.
According to another aspect, pre-split libraries are provided for use by the tier-splitting component and/or directly by programmers. Such libraries include distributed code associated with program language base classes and graphical interfaces, among other things.
In accordance with yet another aspect, a testing component is provided to enable distributed applications to be tested and debugged. More specifically, such applications can be executed and tested in a protected and/or distributed environment prior deployment in a real distributed system.
To the accomplishment of the foregoing and related ends, certain illustrative aspects of the claimed subject matter are described herein in connection with the following description and the annexed drawings. These aspects are indicative of various ways in which the subject matter may be practiced, all of which are intended to be within the scope of the claimed subject matter. Other advantages and novel features may become apparent from the following detailed description when considered in conjunction with the drawings.
Systems and methods are provided that facilitate generation of distributed applications such as those associated with Internet and/or Web (a.k.a. World Wide Web) programming. A support infrastructure is provided that allows programmers to write rich and broad reaching distributed applications. Initially, applications need only be developed as single tier or tier independent applications, wherein logic is expressed in a tier agnostic manner. These applications can then be split or sliced into multiple tiers in a variety ways, for instance as a function of execution and/or runtime context. As a result, programmers are not forced to make premature decisions about how computation should be split, and they are relieved of many difficulties related to distributed-programming.
Various aspects of the subject disclosure are now described with reference to the annexed drawings, wherein like numerals refer to like or corresponding elements throughout. It should be understood, however, that the drawings and detailed description relating thereto are not intended to limit the claimed subject matter to the particular form disclosed. Rather, the intention is to cover all modifications, equivalents and alternatives falling within the spirit and scope of the claimed subject matter.
Referring initially to
The acquisition component 110 facilitates receipt and/or retrieval of a programming application desired to be tier split. In one embodiment, the application can be specified in a tier agnostic or independent manner, thereby enabling the programmer to focus on application logic rather than intricate distributed processing issues. For example, consider a method that validates information such as an address with a zip code. Rather than focusing on whether validation will take place on a client or server and the mechanisms needed to support such interaction, a programmer can simply concentrate on specifying validation specifics. The acquisition component 110 can provide or otherwise make an acquired application available to the tier-splitting component 120.
The tier-splitting component 120 can aid splitting, slicing or otherwise partitioning an application in a variety of ways. In essence, the tier-splitting component 120 can transform a single tier application into a multiple tier application suitable for distributed processing. In one instance, this can be done automatically; however, as will be discussed infra, component 120 can additionally or alternatively support manual or semi-automatic operation. Moreover, it is to be appreciated that tier-splitting component 120 splits an application in a manner that preserves program semantics. Accordingly, split application execution is semantically equivalent to sequential execution of the application on a single tier.
The context component 130 obtains and supplies execution context to the tier-splitting component 120. Among other things, the execution context can include information about an execution environment such as the number of tiers, computational capacity and/or load for each tier and network communication speed. Based on analysis of an application and the execution context afforded by context component 130, the tier-splitting component 120 can determine or infer an optimal application division. For example, if an application is to be executed on a two-tier client-server architecture and the client is computationally constrained (e.g., thin client), then the application can be split such that the server processes most of the application and simply feeds display data to the client.
Turning attention to
Once split, executable portions 220 and 230 of the application 210 need not be completely isolated from one another. While in some instance this may be the case, in other instances the split portions 220 and 230 can cooperate and communicate to facilitate optimal execution. Accordingly, the split process can involve code transformation to facilitate such cooperation via a particular protocol.
In one instance, the split portions can execute asynchronous method and/or function calls. This allows a caller to do other work while the callee does its work. Further, such calls are significant in generating responsive programs, for instance, where there is a long computation of high latency.
Additionally or alternatively, co-routines or other continuation constructs can be employed across tiers. Co-routines are a generalization of subroutines in that they allow multiple entry points and can be suspended and resumed at particular code locations. One or more co-routines including nested sub-routines, co-routines or a combination thereof can be injected by the tier-splitting component 120.
Beyond aiding programmers via a mechanism that supports generation of distributed programs, the subject system can also relieve programmers of the burden of managing state across multiple tiers. More particularly, the tier-splitting component 120 can perform code transformations relating to state preservation and/or communication.
By way of example and not limitation, an application 210 can be a client-server shopping cart application where items are added to and/or removed from a shopping cart until the user finally checks out. Here, state pertains to items in a shopping cart. The tier-splitting component 120 can facilitate state management on the client and the server as well as provide communication between the two such that they are both aware of the items in the shopping cart.
There are many ways in which state can be maintained and as such many eligible manners of code transformation that can be performed by the tier-splitting component 120. In a two-tier system, for example, state can be stored on a client and delivered by the client on every call to an associated server. Alternatively, the server can persist the state to a local database and use some smaller piece of state, such as cookie, to map back to where the state is stored in the database. The client can then query the server for the state where needed. Of course, the technique employed can be dependent upon execution state or context. Returning to the shopping cart example, if the client is somewhat limited it may be desired that state be stored on the server so that the number of items that can be added to the shopping cart is not limited by a small client capacity.
Still further yet, it is to be appreciated that a protocol can be implemented between tiers to ensure proper state is maintained. In the client-server shopping cart example as well as other applications, actions by clients or other computers cannot be completely controlled. This could lead to applications vulnerabilities. For instance, in the shopping cart example a user could initially utilize a client browser to place things in a shopping cart and employ the server to check out. However, a user could clone their browser or open another browser instance and thus another application instance, which could also communicate with the server. In this instance, it could be possible for a user to check out utilizing the first instance of the application and pay for the items added to the cart thereby. However, after check out a user could employ the second instance to continue to add items to the cart and potentially receive them for free if the application is not properly designed. Accordingly, communication protocol can be secured against such as situation by ensuring proper instance communication utilizing some form of encryption, time ordered restrictions on requests and responses or the like.
In accordance with one aspect of the claimed subject matter, code transformations can be affected utilizing one or more pre-split libraries 310, as shown in distributed system 300 of
The compiler component 410 compiles or translates a high-level source program to lower level target code. In accordance with one embodiment, the compiler 410 can transform application code into an intermediate language to facilitate execution by a virtual machine or common language infrastructure (CLI) implementation (e.g., Common Language Runtime (CLR), Java Virtual Machine JVM). In this manner, applications can be written in numerous programming languages and compiled to a common intermediate language executable across multiple computer platforms. Accordingly, an initial tier independent or agnostic application programmed in one of many languages (e.g., C, C#, Java . . . ) can be modified to support multiple tier architectures and subsequently compiled into a common intermediate language. It should be appreciated that the compiler 410 can perform tasks previously described with respect to the tier-splitting component. For example, prior to or during compilation, the compiler 410 can insert identified/linked code residing in at least one of the pre-split libraries 310. Further yet, in one embodiment, the tier-splitting component 130 can form part of the compiler 410.
The execution component(s) 420 are operable to execute compiled program code on designated architectures. For example, common intermediate language code can be compiled or interpreted to run on a particular server or client device. In one instance, such code can be executed by a virtual machine resident on a tier computer. Further yet, the code can be run within a browser or other like application.
The execution component 420 can also be employed to affect dynamic splitting or computational distribution as a function of execution context information provided by the context component 130. Previously, it was noted that tier independent applications could be split early on based on context information provided about its execution environment such as the number of tiers and the capabilities of resources provided thereby. However, resource availability, computation load, network speed, inter alia can change during execution. Additionally, computational capabilities can differ from those at the time of compilation. Accordingly, splitting/slicing or other changes can be made at runtime based on execution context provided by communicatively coupled context component 130.
Such functionality can be implemented via incorporation of context sensitive/aware code. This code can be found in one or more of the pre-split libraries 310 and injected into an application by the tier splitting component 120 and/or compiler 410. Turing briefly to
For the most part, programmers need not be aware of how libraries and code is sliced. The application programming interfaces (APIs) exposed to the programmer and the manner of calling them need not be different. For example, a programmer can simply create an instance of a Button and a TextBox and assign an event handler to the button to greet a user as follows:
Dim WithEvents B As New Button( ) Dim T As New TextBox( ) Sub Clicked( ) Handles B.Click T.Text = “Hello World” End Sub
Depending on the actual slicing, this code call can run completely on a client or a server, or a hybrid of both.
Similarly and as previously mentioned, it is also significant to provide programmers with stateful services. Any given class that satisfies certain conditions can be split such that the actual implementation performs computations on different tiers while maintaining state. For example, a programmer can write a normal stateful class declaration such as the following simple counter:
Class Counter Private N As Integer Public Function Up( ) As Integer N += 1 Return N End Function Public Function Down( ) As Integer N −= 1 Return N End Function End Class
This class can then be realized in a plurality of ways, with respect to where the code runs, where and how instance state is stored, etc. However, no matter how the class is actually implemented, the programmer interacts with it using the same interface.
Furthermore, it is to be noted that the system 100, by way of development component 610 and pre-split libraries 310, can also provide refactoring support to supply an asynchronous interface to a given class or API via a variety of possible matters. For example, the libraries 310 can expose a synchronous interface for validation that returns a Boolean, but internally the validation performs asynchronous calls. Hence, it appears as synchronous but internally it can perform two calls and wait for a result. Splitting can thus be hidden inside a component that is invisible to a programmer. However, splitting can also be outside a component and visible to a programmer. Programmers can also manually program at least portions of the code for distributed execution it they so desire.
Still further, the development component 610 can be coupled to the tier-splitting component 120 to facilitate further distributed transformations. In other words, while programmers can manually program distributed execution and/or call interfaces that perform hidden distributed functionality, the tier-splitting component 120 can be employed additionally or alternatively to partition an application automatically for example by inferring optimal splits and/or code transformations base on static and/or dynamic analysis of a program and execution environment characteristics.
Also included in the distributed programming development system 600 is test component 620, communicatively coupled to the development component 610. The test component 620 provides a mechanism to test distributed programming applications generated via system 600, among other ways. The test component 620 can provide a protected and/or simulated environment for execution of distributed programs. In this environment, tests can be performed to ensure that the program responds properly. In particular, fault injection component 622 can be utilized to test code that contains asynchronous calls by injecting faults or latency. If needed, the development component 610 can be employed to correct any problems. In this manner, manually, semi-automatically and/or automatically generated distributed programs can be tested and subsequent debugged, if needed, prior to real deployment.
The aforementioned systems, architectures and the like have been described with respect to interaction between several components. It should be appreciated that such systems and components can include those components or sub-components specified therein, some of the specified components or sub-components, and/or additional components. Sub-components could also be implemented as components communicatively coupled to other components rather than included within parent components. Further yet, one or more components and/or sub-components may be combined into a single component to provide aggregate functionality. Communication between systems, components and/or sub-components can be accomplished in accordance with either a push and/or pull model. The components may also interact with one or more other components not specifically described herein for the sake of brevity, but known by those of skill in the art.
Furthermore, as will be appreciated, various portions of the disclosed systems and methods may include or consist of artificial intelligence, machine learning, or knowledge or rule based components, sub-components, processes, means, methodologies, or mechanisms (e.g., support vector machines, neural networks, expert systems, Bayesian belief networks, fuzzy logic, data fusion engines, classifiers . . . ). Such components, inter alia, can automate certain mechanisms or processes performed thereby to make portions of the systems and methods more adaptive as well as efficient and intelligent. By way of example and not limitation, tier-splitting component 120 can employ such mechanisms to infer optimal cut points for distributed applications based on context information and the applications themselves.
In view of the exemplary systems described supra, methodologies that may be implemented in accordance with the disclosed subject matter will be better appreciated with reference to the flow charts of
As used herein, the terms “component,” “system” and the like are intended to refer to a computer-related entity, either hardware, a combination of hardware and software, software, or software in execution. For example, a component may be, but is not limited to being, a process running on a processor, a processor, an object, an instance, an executable, a thread of execution, a program, and/or a computer. By way of illustration, both an application running on a computer and the computer can be a component. One or more components may reside within a process and/or thread of execution and a component may be localized on one computer and/or distributed between two or more computers.
The word “exemplary” is used herein to mean serving as an example, instance or illustration. Any aspect or design described herein as “exemplary” is not necessarily to be construed as preferred or advantageous over other aspects or designs. Furthermore, examples are provided solely for purposes of clarity and understanding and are not meant to limit the subject innovation or relevant portion thereof in any manner. It is to be appreciated that a myriad of additional or alternate examples could have been presented, but have been omitted for purposes of brevity.
As used herein, the term “inference” or “infer” refers generally to the process of reasoning about or inferring states of the system, environment, and/or user from a set of observations as captured via events and/or data. Inference can be employed to identify a specific context or action, or can generate a probability distribution over states, for example. The inference can be probabilistic—that is, the computation of a probability distribution over states of interest based on a consideration of data and events. Inference can also refer to techniques employed for composing higher-level events from a set of events and/or data. Such inference results in the construction of new events or actions from a set of observed events and/or stored event data, whether or not the events are correlated in close temporal proximity, and whether the events and data come from one or several event and data sources. Various classification schemes and/or systems (e.g., support vector machines, neural networks, expert systems, Bayesian belief networks, fuzzy logic, data fusion engines . . . ) can be employed in connection with performing automatic and/or inferred action in connection with the subject innovation.
Furthermore, all or portions of the subject innovation may be implemented as a method, apparatus or article of manufacture using standard programming and/or engineering techniques to produce software, firmware, hardware, or any combination thereof to control a computer to implement the disclosed innovation. The term “article of manufacture” as used herein is intended to encompass a computer program accessible from any computer-readable device or media. For example, computer readable media can include but are not limited to magnetic storage devices (e.g., hard disk, floppy disk, magnetic strips . . . ), optical disks (e.g., compact disk (CD), digital versatile disk (DVD) . . . ), smart cards, and flash memory devices (e.g., card, stick, key drive . . . ). Additionally it should be appreciated that a carrier wave can be employed to carry computer-readable electronic data such as those used in transmitting and receiving electronic mail or in accessing a network such as the Internet or a local area network (LAN). Of course, those skilled in the art will recognize many modifications may be made to this configuration without departing from the scope or spirit of the claimed subject matter.
In order to provide a context for the various aspects of the disclosed subject matter,
With reference to
The system memory 1116 includes volatile and nonvolatile memory. The basic input/output system (BIOS), containing the basic routines to transfer information between elements within the computer 1112, such as during start-up, is stored in nonvolatile memory. By way of illustration, and not limitation, nonvolatile memory can include read only memory (ROM). Volatile memory includes random access memory (RAM), which can act as external cache memory to facilitate processing.
Computer 1112 also includes removable/non-removable, volatile/non-volatile computer storage media.
The computer 1112 also includes one or more interface components 1126 that are communicatively coupled to the bus 1118 and facilitate interaction with the computer 1112. By way of example, the interface component 1126 can be a port (e.g., serial, parallel, PCMCIA, USB, FireWire . . . ) or an interface card (e.g., sound, video, network . . . ) or the like. The interface component 1126 can receive input and provide output (wired or wirelessly). For instance, input can be received from devices including but not limited to, a pointing device such as a mouse, trackball, stylus, touch pad, keyboard, microphone, joystick, game pad, satellite dish, scanner, camera, other computer and the like. Output can also be supplied by the computer 1112 to output device(s) via interface component 1126. Output devices can include displays (e.g., CRT, LCD, plasma . . . ), speakers, printers and other computers, among other things.
The system 1200 includes a communication framework 1250 that can be employed to facilitate communications between the client(s) 1210 and the server(s) 1230. The client(s) 1210 are operatively connected to one or more client data store(s) 1260 that can be employed to store information local to the client(s) 1210. Similarly, the server(s) 1230 are operatively connected to one or more server data store(s) 1240 that can be employed to store information local to the servers 1230.
By way of example, this is one potential multi-tier architecture on which applications can be executed. Based on the characteristics and/or capabilities of both the client(s) 1210 and the server(s) 1230 as well as runtime contextual information, initially specified tier agnostic applications can be transformed to run optimally on the client(s) 1210, the server(s) 1230 or both the client(s) 1210 and the server(s) 1230. In accordance with one embodiment, applications can be run on a browser or other target application on the client(s) 1210.
What has been described above includes examples of aspects of the claimed subject matter. It is, of course, not possible to describe every conceivable combination of components or methodologies for purposes of describing the claimed subject matter, but one of ordinary skill in the art may recognize that many further combinations and permutations of the disclosed subject matter are possible. Accordingly, the disclosed subject matter is intended to embrace all such alterations, modifications and variations that fall within the spirit and scope of the appended claims. Furthermore, to the extent that the terms “includes,” “has” or “having” or variations in form thereof are used in either the detailed description or the claims, such terms are intended to be inclusive in a manner similar to the term “comprising” as “comprising” is interpreted when employed as a transitional word in a claim.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US6362836||Mar 31, 1999||Mar 26, 2002||The Santa Cruz Operation, Inc.||Universal application server for providing applications on a variety of client devices in a client/server network|
|US6499137 *||Nov 20, 1998||Dec 24, 2002||Microsoft Corporation||Reversible load-time dynamic linking|
|US6714962||Mar 16, 2000||Mar 30, 2004||Microsoft Corporation||Multi-user server application architecture with single-user object tier|
|US6950850 *||Oct 31, 2000||Sep 27, 2005||International Business Machines Corporation||System and method for dynamic runtime partitioning of model-view-controller applications|
|US6968535||Apr 30, 2002||Nov 22, 2005||Sun Microsystems, Inc.||Service mapping method of enterprise application modeling and development for multi-tier service environments|
|US6983463||Nov 20, 1998||Jan 3, 2006||Microsoft Corporation||Network independent profiling of applications for automatic partitioning and distribution in a distributed computing environment|
|US7017162||Jul 10, 2001||Mar 21, 2006||Microsoft Corporation||Application program interface for network software platform|
|US7076762||Mar 29, 2002||Jul 11, 2006||Sun Microsystems, Inc.||Design and redesign of enterprise applications|
|US7194664 *||Sep 8, 2003||Mar 20, 2007||Poon Fung||Method for tracing application execution path in a distributed data processing system|
|US7412497 *||Jul 25, 2002||Aug 12, 2008||Sun Microsystems, Inc.||Generation of Administration framework for server systems|
|US7490331 *||Mar 4, 2003||Feb 10, 2009||International Business Machines Corporation||Mapping to and from native type formats|
|US7779429 *||Aug 18, 2006||Aug 17, 2010||Research In Motion Limited||Method and machine-readable medium for building distributed software|
|US20010049685 *||Jun 27, 2001||Dec 6, 2001||International Business Machines Corp.||Query optimization with deferred updates and autonomous sources|
|US20030050932||Sep 4, 2001||Mar 13, 2003||Pace Charles P.||System and method for transactional deployment of J2EE web components, enterprise java bean components, and application data over multi-tiered computer networks|
|US20030101291 *||Jan 28, 2002||May 29, 2003||Mussack Christopher Joseph||Application programming interface for provision of DICOM services|
|US20030154266 *||Sep 4, 2001||Aug 14, 2003||Mark Bobick||Server system and method for discovering digital assets in enterprise information systems|
|US20030172135 *||Sep 4, 2001||Sep 11, 2003||Mark Bobick||System, method, and data structure for packaging assets for processing and distribution on multi-tiered networks|
|US20030236900 *||May 14, 2002||Dec 25, 2003||Hsiao-Keng Chu||Method and apparatus for facilitating the implementation of an IP link over an InfiniBand network|
|US20040015898 *||Jun 8, 2001||Jan 22, 2004||Tewksbary David E.||Interface definition language compiler|
|US20040064804 *||Sep 26, 2002||Apr 1, 2004||Daniels Bruce K.||Generation of partitioned enterprise application using a high-level specification|
|US20040225678||May 8, 2003||Nov 11, 2004||Eugene Buzzeo||Distributed, multi-user, multi-threaded application development system and method|
|US20040236860 *||Jan 26, 2004||Nov 25, 2004||Gary Logston||Method and apparatus for balancing distributed applications|
|US20050039173 *||Jul 8, 2004||Feb 17, 2005||Tondreau David L.||Method and apparatus for transforming legacy software applications into modern object-oriented distributed systems|
|US20060020695||Sep 15, 2005||Jan 26, 2006||Microsoft Corporation||Scaling and delivering distributed applications|
|US20060184926 *||Mar 4, 2003||Aug 17, 2006||Yan Or||Deployment of applications in a multitier compute infrastructure|
|US20070156375 *||May 11, 2006||Jul 5, 2007||Microsoft Corporation||Performance engineering and the application life cycle|
|1||Ed Roman, et al. The Technical Benefits of EJB and J2EE Technologies over COM+ and Windows DNA. Middleware Company, Dec. 1999. Prepared for Sun Microsystems, Inc. http://citeseer.ist.psu.edu/cache/papers/cs/16505/http:zSzzSzjava.sun.comzSzproductszSzejbzSzpdfzSzj2ee-dnatwp.pdf/roman99technical.pdf. Last accessed Sep. 15, 2006.|
|2||Ed Roman, et al. The Technical Benefits of EJB and J2EE Technologies over COM+ and Windows DNA. Middleware Company, Dec. 1999. Prepared for Sun Microsystems, Inc. http://citeseer.ist.psu.edu/cache/papers/cs/16505/http:zSzzSzjava.sun.comzSzproductszSzejbzSzpdfzSzj2ee—dnatwp.pdf/roman99technical.pdf. Last accessed Sep. 15, 2006.|
|3||Gary R. Voth, et al. Distributed Application Development for Three-Tier Architectures: Microsoft on Windows DNA. IEEE Internet Computing. Mar.-Apr. 1998. http://ieeexplore.ieee.org/iel4/4236/14762/00670682.pdf?isNumber=. Last accessed Sep. 15, 2006.|
|4||Jeff Magee, et al. A Constructive Development Environment for Parallel and Distributed Programs. http://citeseer.ist.psu.edu/cache/papers/cs/7132/http:zSzzSzscorch.doc.ic.ac.ukzSz~regiszSzpaperszSziwcds94a.pdf/magee94constructive.pdf. Last accessed Sep. 15, 2006.|
|5||Jeff Magee, et al. A Constructive Development Environment for Parallel and Distributed Programs. http://citeseer.ist.psu.edu/cache/papers/cs/7132/http:zSzzSzscorch.doc.ic.ac.ukzSz˜regiszSzpaperszSziwcds94a.pdf/magee94constructive.pdf. Last accessed Sep. 15, 2006.|
|6||Po-Hao Chang, et al. An Adaptive Programming Framework for Web Applications. http://citeseer.ist.psu.edu/cache/papers/cs2/306/http:zSzzSzwww-osl.cs.uiuc.eduzSzdocszSzchang-kim-agha-04zSzchangp-framework.pdf/an-adaptive-programming-framework.pdf. Last accessed Sep. 15, 2006.|
|7||Po-Hao Chang, et al. An Adaptive Programming Framework for Web Applications. http://citeseer.ist.psu.edu/cache/papers/cs2/306/http:zSzzSzwww-osl.cs.uiuc.eduzSzdocszSzchang-kim-agha-04zSzchangp—framework.pdf/an-adaptive-programming-framework.pdf. Last accessed Sep. 15, 2006.|
|8||Po-Hao Chang. An Adaptive Distributed Object Framework for the Web. http://osl.cs.uiuc.edu/docs/ecoop-phd04/main.pdf. Last accessed Sep. 15, 2006.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US8745596 *||Feb 5, 2009||Jun 3, 2014||Microsoft Corporation||Program debugging with dynamically inserted instrumentation|
|US8813028 *||Jul 19, 2013||Aug 19, 2014||Arshad Farooqi||Mobile application creation system|
|US8918499 *||Aug 9, 2010||Dec 23, 2014||International Business Machines Corporation||Method and system for end-to-end quality of service in virtualized desktop systems|
|US9015667 *||Oct 6, 2010||Apr 21, 2015||Microsoft Technology Licensing, Llc||Fuzz testing of asynchronous program code|
|US20100199265 *||Feb 5, 2009||Aug 5, 2010||Microsoft Corporation||Program debugging with dynamically inserted instrumentation|
|US20120036251 *||Aug 9, 2010||Feb 9, 2012||International Business Machines Corporation||Method and system for end-to-end quality of service in virtualized desktop systems|
|US20120089868 *||Oct 6, 2010||Apr 12, 2012||Microsoft Corporation||Fuzz testing of asynchronous program code|
|US20150012908 *||Jul 14, 2014||Jan 8, 2015||Arshad Farooqi||Mobile Application Creation System|
|U.S. Classification||717/151, 717/106, 719/330, 717/121, 709/203, 709/201, 719/318, 717/149|
|International Classification||G06F9/45, G06F9/44, G06F15/16, G06F3/00|
|Feb 28, 2007||AS||Assignment|
Owner name: MICROSOFT CORPORATION, WASHINGTON
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:MEIJER, HENRICUS JOHANNES MARIA;BECKMAN, BRIAN C.;BRUMME, CHRISTOPHER W.;AND OTHERS;SIGNING DATES FROM 20070203 TO 20070205;REEL/FRAME:018940/0869
|Dec 9, 2014||AS||Assignment|
Owner name: MICROSOFT TECHNOLOGY LICENSING, LLC, WASHINGTON
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MICROSOFT CORPORATION;REEL/FRAME:034542/0001
Effective date: 20141014
|Dec 9, 2015||FPAY||Fee payment|
Year of fee payment: 4