DECLARATION OF GORDON MACPHERSON
`
`I, Gordon MacPherson, am over twenty-one (21) years of age. I have never been
`convicted of a felony, and I am fully competent to make this declaration. I declare the following
`to be true to the best of my knowledge, information and belief:
`
`1.
`
`2.
`
`3.
`
`I am Director Board Governance & IP Operations of The Institute of Electrical and
`Electronics Engineers, Incorporated (“IEEE”).
`
`IEEE is a neutral third party in this dispute.
`
`I am not being compensated for this declaration and IEEE is only being reimbursed
`for the cost of the article I am certifying.
`
`4. Among my responsibilities as Director Board Governance & IP Operations, I act as a
`custodian of certain records for IEEE.
`
`5.
`
`I make this declaration based on my personal knowledge and information contained
`in the business records of IEEE.
`
`6. As part of its ordinary course of business, IEEE publishes and makes available
`technical articles and standards. These publications are made available for public
`download through the IEEE digital library, IEEE Xplore.
`
`7.
`
`It is the regular practice of IEEE to publish articles and other writings including
`article abstracts and make them available to the public through IEEE Xplore. IEEE
`maintains copies of publications in the ordinary course of its regularly conducted
`activities.
`
`8. The article below has been attached as Exhibit A to this declaration:
`
`A. A. Fuggetta; G.P. Picco; G. Vigna, “Understanding code mobility”, IEEE
`Transactions on Software Engineering, Vol. 24, Issue 5, May 1998.
`
`9.
`
`I obtained a copy of Exhibit A through IEEE Xplore, where it is maintained in the
`ordinary course of IEEE’s business. Exhibit A is a true and correct copy of the
`Exhibit, as it existed on or about August 6, 2021.
`
`10. The article and abstract from IEEE Xplore show the date of publication. IEEE
`Xplore populates this information using the metadata associated with the publication.
`
`445 Hoes Lane Piscataway, NJ 08854
`
`DocuSign Envelope ID: E32A4F90-8775-46F6-9477-55752AEEBA63
`
`Netflix, Inc. - Ex. 1026, Page 000001
`IPR2022-00322 (Netflix, Inc. v. CA, Inc.)
`
`

`

`11. A. Fuggetta; G.P. Picco; G. Vigna, “Understanding code mobility” was published in
`IEEE Transactions on Software Engineering, Vol. 24, Issue 5. IEEE Transactions on
`Software Engineering, Vol. 24, Issue 5 was published in May 1998. Copies of this
`publication was made available no later than the last day of the publication month.
`The article is currently available for public download from the IEEE digital library,
`IEEE Xplore.
`
`12. I hereby declare that all statements made herein of my own knowledge are true and
`that all statements made on information and belief are believed to be true, and further
`that these statements were made with the knowledge that willful false statements and
`the like are punishable by fine or imprisonment, or both, under 18 U.S.C. § 1001.
`
`I declare under penalty of perjury that the foregoing statements are true and correct.
`
`
`
`
`Executed on:
`
`
`
`
`
`
`
`
`
`
`DocuSign Envelope ID: E32A4F90-8775-46F6-9477-55752AEEBA63
`
`8/12/2021
`
`Netflix, Inc. - Ex. 1026, Page 000002
`
`

`

`
`
`
`
`
`
`
`
`
`
`
`
`
`
`EXHIBIT A
`
`DocuSign Envelope ID: E32A4F90-8775-46F6-9477-55752AEEBA63
`
`Netflix, Inc. - Ex. 1026, Page 000003
`
`

`

`IEEE.org
`
`IEEE Xplore
`
`IEEE-SA
`
`IEEE Spectrum
`
`More Sites
`
`SUBSCRIBE
`
`SUBSCRIBECart Create Account
`
`Personal Sign In 
`
`
`
`Browse  My Settings  Help 
`
`Institutional Sign In
`
`Institutional Sign In
`
`All
`
`
`
`
`
`ADVANCED SEARCH
`
`Journals & Magazines > IEEE Transactions on Software... > Volume: 24 Issue: 5 
`
`Understanding code mobility
`Publisher: IEEE
`
`Cite This
`
` PDF
`
`  
`
`Alerts
`
`Manage Content Alerts
`
`Add to Citation Alerts
`
`A. Fuggetta ; G.P. Picco ; G. Vigna All Authors
`
`958
`Full
`Text Views
`
`4P
`
`atent
`Citations
`
`635
`Paper
`Citations
`
`Abstract
`
`Authors
`
`References
`
`Citations
`
`Keywords
`
`Metrics
`
`More Like This
`
`Abstract:The technologies, architectures, and methodologies traditionally used to
`develop distributed applications exhibit a variety of limitations and drawbacks when
`applied to l... View more
`
` Metadata
`Abstract:
`The technologies, architectures, and methodologies traditionally used to develop
`distributed applications exhibit a variety of limitations and drawbacks when applied to
`large scale distributed settings (e.g., the Internet). In particular, they fail in providing the
`desired degree of configurability, scalability, and customizability. To address these
`issues, researchers are investigating a variety of innovative approaches. The most
`promising and intriguing ones are those based on the ability of moving code across the
`nodes of a network, exploiting the notion of mobile code. As an emerging research field,
`code mobility is generating a growing body of scientific literature and industrial
`developments. Nevertheless, the field is still characterized by the lack of a sound and
`comprehensive body of concepts and terms. As a consequence, it is rather difficult to
`understand, assess, and compare the existing approaches. In turn, this limits our ability
`to fully exploit them in practice, and to further promote the research work on mobile
`code. Indeed, a significant symptom of this situation is the lack of a commonly accepted
`and sound definition of the term mobile code itself. This paper presents a conceptual
`framework for understanding code mobility. The framework is centered around a
`classification that introduces three dimensions: technologies, design paradigms, and
`applications. The contribution of the paper is two-fold. First, it provides a set of terms
`and concepts to understand and compare the approaches based on the notion of mobile
`code. Second, it introduces criteria and guidelines that support the developer in the
`identification of the classes of applications that can leverage off of mobile code, in the
`
` D
`
`ownl
`PDF
`
`Netflix, Inc. - Ex. 1026, Page 000004
`
`More
`Like
`This
`Applying object oriented
`programming to developing
`programs on CTRON interfaces
`Proceedings Eighth TRON Project
`Symposium
`Published: 1991
`Teaching Object-Oriented
`Programming Laboratory With
`Computer Game Programming
`IEEE Transactions on Education
`Published: 2007
`Show
`More
`

`

`design of these applications, and, finally, in the selection of the most appropriate
`implementation technologies. The presentation of the classification is intertwined with a
`review of state-of-the-art in the field. Finally, the use of the classification is exemplif...
`
`(Show More)
`
`Published in: IEEE Transactions on Software Engineering ( Volume: 24 , Issue: 5, May
`1998)
`
`Page(s): 342 - 361
`
`INSPEC Accession Number: 5955978
`
`Date of Publication: May 1998 
`
`DOI: 10.1109/32.685258
`
` ISSN Information:
`
`Publisher: IEEE
`
`Authors
`
`References
`
`Citations
`
`Keywords
`
`Metrics
`
`
`
`
`
`
`
`
`
`
`
`IEEE Personal Account
`
`Purchase Details
`
`Profile Information
`
`Need Help?
`
`CHANGE USERNAME/PASSWORD
`
`PAYMENT OPTIONS
`
`COMMUNICATIONS PREFERENCES
`
`US & CANADA: +1 800 678 4333
`
`VIEW PURCHASED DOCUMENTS
`
`PROFESSION AND EDUCATION
`
`WORLDWIDE: +1 732 981 0060
`
`TECHNICAL INTERESTS
`
`CONTACT & SUPPORT
`
`Follow
`
`  
`
`About IEEE Xplore | Contact Us | Help | Accessibility | Terms of Use | Nondiscrimination Policy | IEEE Ethics Reporting  | Sitemap | Privacy & Opting Out of Cookies
`A not-for-profit organization, IEEE is the world's largest technical professional organization dedicated to advancing technology for the benefit of humanity.
`
`© Copyright 2021 IEEE - All rights reserved. Use of this web site signifies your agreement to the terms and conditions.
`
`IEEE Account
`
`Purchase Details
`
`Profile Information
`
`Need Help?
`
`» Change Username/Password
`» Update Address
`
`» Payment Options
`» Order History
`» View Purchased Documents
`
`» Communications Preferences
`» Profession and Education
`» Technical Interests
`
`» US & Canada: +1 800 678 4333
`» Worldwide: +1 732 981 0060
`» Contact & Support
`
`About IEEE Xplore Contact Us
`
`
`|
`
`|
`
`Help
`
`
`|
`
`Accessibility
`
`
`|
`
`Terms of Use
`
`
`|
`
`Nondiscrimination Policy
`
`
`|
`
`Sitemap
`
`
`|
`
`Privacy & Opting Out of Cookies
`
`A not-for-profit organization, IEEE is the world's largest technical professional organization dedicated to advancing technology for the benefit of humanity.
`© Copyright 2021 IEEE - All rights reserved. Use of this web site signifies your agreement to the terms and conditions.
`
`Netflix, Inc. - Ex. 1026, Page 000005
`
`

`

`342
`
`IEEE TRANSACTIONS ON SOFTWARE ENGINEERING, VOL. 24, NO. 5, MAY 1998
`
`Understanding Code Mobility
`
`Alfonso Fuggetta, Member, IEEE, Gian Pietro Picco, Member, IEEE,
`and Giovanni Vigna, Member, IEEE
`
`Abstract—The technologies, architectures, and methodologies traditionally used to develop distributed applications exhibit a variety of
`limitations and drawbacks when applied to large scale distributed settings (e.g., the Internet). In particular, they fail in providing the
`desired degree of configurability, scalability, and customizability. To address these issues, researchers are investigating a variety of
`innovative approaches. The most promising and intriguing ones are those based on the ability of moving code across the nodes of a
`network, exploiting the notion of mobile code. As an emerging research field, code mobility is generating a growing body of scientific
`literature and industrial developments. Nevertheless, the field is still characterized by the lack of a sound and comprehensive body of
`concepts and terms. As a consequence, it is rather difficult to understand, assess, and compare the existing approaches. In turn, this
`limits our ability to fully exploit them in practice, and to further promote the research work on mobile code. Indeed, a significant symptom
`of this situation is the lack of a commonly accepted and sound definition of the term “mobile code” itself.
`This paper presents a conceptual framework for understanding code mobility. The framework is centered around a classification
`that introduces three dimensions: technologies, design paradigms, and applications. The contribution of the paper is two-fold. First, it
`provides a set of terms and concepts to understand and compare the approaches based on the notion of mobile code. Second, it
`introduces criteria and guidelines that support the developer in the identification of the classes of applications that can leverage off
`of mobile code, in the design of these applications, and, finally, in the selection of the most appropriate implementation technologies.
`The presentation of the classification is intertwined with a review of state-of-the-art in the field. Finally, the use of the classification is
`exemplified in a case study.
`
`Index Terms—Mobile code, mobile agent, distributed application, design paradigm.
`——————————(cid:3)(cid:3)(cid:3)F(cid:3)(cid:3)(cid:3)——————————
`
`C
`
`1 INTRODUCTION
`OMPUTER networks are evolving at a fast pace, and this
`evolution proceeds along several lines. The size of net-
`works is increasing rapidly, and this phenomenon is not
`confined just to the Internet, whose tremendous growth
`rate is well-known. Intra- and inter-organization networks
`experience an increasing diffusion and growth as well, fos-
`tered by the availability of cheap hardware and motivated
`by the need for uniform, open, and effective information
`channels inside and across the organizations. A side effect
`of this growth is the significant increase of the network traf-
`fic, which in turn triggers research and industrial efforts to
`enhance the performance of the communication infrastruc-
`ture. Network links are constantly improved, and techno-
`logical developments lead to increased computational
`power on both intermediate and end network nodes.
`The increase in size and performance of computer net-
`works is both the cause and the effect of an important
`phenomenon: networks are becoming pervasive and
`ubiquitous. By pervasive, we mean that network connec-
`tivity is no longer an expensive add-on. Rather it is a basic
`feature of any computing facility, and, in perspective, also
`of many products in the consumer electronics market (e.g.,
`
`††††††††††††††††
`•(cid:3) A. Fuggetta and G. Vigna are with the Dipartimento di Elettronica e Infor-
`mazione, Politecnico di Milano, P.za Leonardo da Vinci, 32, I-20133 Milano,
`Italy. E-mail: {fuggetta, vigna}@elet.polimi.it.
`•(cid:3) G.P. Picco is with the Dipartimento di Automatica e Informatica, Politec-
`nico di Torino, C.so Duca degli Abruzzi 24, I-10129 Torino, Italy.
`E-mail: picco@polito.it.
`Manuscript received 16 July 1997; revised 18 Dec. 1997.
`Recommended for acceptance by G.-C. Roman.
`
`For information on obtaining reprints of this article, please send e-mail to:
`tse@computer.org, and reference IEEECS Log Number 106411.
`
`televisions). By ubiquitous, we refer to the ability of exploit-
`ing network connectivity independently of the physical
`location of the user. Developments in wireless technology
`free network nodes from the constraint of being placed at a
`fixed physical location and enable the advent of so-called
`mobile computing. In this new scenario, mobile users can
`move together with their hosts across different physical
`locations and geographical regions, still being connected to
`the net through wireless links.
`Another important phenomenon is the increasing avail-
`ability of easy-to-use technologies accessible also to naive
`users (e.g., the World Wide Web). These technologies have
`triggered the creation of new application domains and even
`new markets. This is changing the nature and role of net-
`works, and particularly of the Internet. They cannot be con-
`sidered just plain communication technologies. Nowadays,
`modern computer networks constitute innovative media
`that support new forms of cooperation and communication
`among users. Terms like “electronic commerce,” or “Inter-
`net phone” are symptomatic of this change.
`However, this evolution path is not free of obstacles and
`several challenging problems must be addressed. The
`growing size of networks raises a problem of scalability.
`Most results that are significant for small networks are of-
`ten inapplicable when scaled to a world-wide network like
`the Internet. For instance, while it might be conceivable to
`apply a global snapshot algorithm to a LAN, its perform-
`ance is unacceptable in an Internet setting. Wireless con-
`nectivity poses even tougher problems [1], [2]. Network
`nodes may move and be connected discontinuously, hence
`the topology of the network is no longer defined statically.
`As a consequence, some of the basic tenets of research on
`
`0098-5589/98/$10.00 © 1998 IEEE
`Authorized licensed use limited to: IEEE Staff. Downloaded on August 06,2021 at 16:23:41 UTC from IEEE Xplore. Restrictions apply.
`
`Netflix, Inc. - Ex. 1026, Page 000006
`
`

`

`FUGGETTA ET AL.: UNDERSTANDING CODE MOBILITY
`
`343
`
`distributed systems are undermined, and we need to adapt
`and extend existing theoretical and technological results to
`this new scenario. Another relevant issue is the diffusion of
`network services and applications to very large segments of
`our society. This makes it necessary to increase the custom-
`izability of services, so that different classes of users are en-
`abled to tailor the functionality and interface of a service
`according to their specific needs and preferences. Finally,
`the dynamic nature of both the underlying communication
`infrastructure and the market requirements demand in-
`creased flexibility and extensibility.
`There have been many attempts to provide effective an-
`swers to this multifaceted problem. Most of the proposed
`approaches, however, try to adapt well-established models
`and technologies within the new setting, and usually take
`for granted the traditional client-server architecture. For
`example, CORBA [3] integrates remote procedure calls
`(RPCs) with the object-oriented paradigm. It attempts to
`combine the benefits of the latter in terms of modularity
`and reuse, with
`the well-established communication
`mechanism of the former. However, this approach does not
`ensure the degree of flexibility, customizability, and recon-
`figurability needed to cope with the challenging require-
`ments discussed so far.
`A different approach originates in the promising re-
`search area exploiting the notion of mobile code. Code mo-
`bility can be defined informally as the capability to dy-
`namically change the bindings between code fragments and
`the location where they are executed [4]. The ability to relo-
`cate code is a powerful concept that originated a very inter-
`esting range of developments. However, despite the wide-
`spread interest in mobile code technology and applications,
`the field is still quite immature. A sound terminological and
`methodological framework is still missing, and there is not
`even a commonly agreed term to qualify the subject of this
`research.1 In addition, the interest demonstrated by markets
`and media, due to the fact that mobile code research is
`tightly bound to the Internet, has added an extra level of
`noise, by introducing hypes and sometimes unjustified ex-
`pectations. In the next section we present the main differ-
`ences between mobile code and other related approaches,
`and the motivations and main contributions of this paper.
`
`2 MOTIVATIONS AND APPROACH
`Code mobility is not a new concept. In the recent past, sev-
`eral mechanisms and facilities have been designed and im-
`plemented to move code among the nodes of a network.
`Examples are remote batch job submission [5] and the use
`of PostScript [6] to control printers. The research work on
`distributed operating systems has followed a more struc-
`tured approach. In that research area, the main problem is
`to support the migration of active processes and objects
`(along with their state and associated code) at the operating
`system level [7]. In particular, process migration concerns the
`transfer of an operating system process from the machine
`where it is running to a different one. Migration mecha-
`
`1. Hereafter, we use interchangeably the terms code mobility and mobile
`code, although other authors prefer different terms such as mobile computa-
`tions, mobile object systems, or program mobility.
`
`nisms handle the bindings between the process and its exe-
`cution environment (e.g., open file descriptors and envi-
`ronment variables) to allow the process to seamlessly re-
`sume its execution in the remote environment. Process mi-
`gration facilities have been introduced at the operating
`system level to achieve load balancing across network
`nodes. Therefore, most of these facilities provide transpar-
`ent process migration: the programmer has neither control
`nor visibility of the migration process. Other systems pro-
`vide some form of control over the migration process. For
`example, in Locus [8] process migration can be triggered
`either by an external signal or by the explicit invocation of
`the migrate system call. Object migration makes it possible
`to move objects among address spaces, implementing a
`finer grained mobility with respect to process-level migra-
`tion. For example, Emerald [9] provides object migration at
`any level of granularity ranging from small, atomic data to
`complex objects. Emerald does not provide complete trans-
`parency since the programmer can determine objects loca-
`tions and may request explicitly the migration of an object
`to a particular node. An example of system providing
`transparent migration is COOL [10], an object-oriented ex-
`tension of the Chorus operating system [11]. COOL is able
`to move objects among address spaces without user inter-
`vention or knowledge.
`Process and object migration address the issues that arise
`when code and state are moved among the hosts of a
`loosely coupled, small scale distributed system. However,
`they are insufficient when applied in larger scale settings.
`Nevertheless, the migration techniques discussed so far
`have been taken as a starting point for the development of a
`new breed of systems providing enhanced forms of code
`mobility. These systems, often referred to as Mobile Code
`Systems (MCSs), exhibit several innovations with respect to
`existing approaches:
`Code mobility is exploited on an Internet-scale. Distributed
`systems providing process or object migration have been
`designed having in mind small-scale computer networks,
`thus assuming high bandwidth, small predictable latency,
`trust, and, often, homogeneity. Conversely, MCSs are con-
`ceived to operate in large scale settings where networks are
`composed of heterogeneous hosts, managed by different
`authorities with different levels of trust, and connected by
`links with different bandwidths (e.g., wireless slow con-
`nections and fast optical links).
`Programming is location aware. Location is a pervasive ab-
`straction that has a strong influence on both the design and
`the implementation of distributed applications. Mobile
`code systems do not paper over the location of application
`components, rather, applications are location-aware and
`may take actions based on such knowledge.
`Mobility is under programmer’s control. The programmer is
`provided with mechanisms and abstractions that enable the
`shipping and fetching of code fragments (or even entire
`components) to/from remote nodes. The underlying run-
`time support provides basic functionalities (e.g., data mar-
`shaling, code check-in, and security), but does not have any
`control over migration policies.
`
`Authorized licensed use limited to: IEEE Staff. Downloaded on August 06,2021 at 16:23:41 UTC from IEEE Xplore. Restrictions apply.
`
`Netflix, Inc. - Ex. 1026, Page 000007
`
`

`

`344
`
`IEEE TRANSACTIONS ON SOFTWARE ENGINEERING, VOL. 24, NO. 5, MAY 1998
`
`Mobility is not performed just for load balancing. Process
`and object migration aim at supporting load balancing and
`performance optimization. Mobile code systems address a
`much wider range of needs and requirements, such as
`service customization, dynamic extension of application
`functionality, autonomy, fault tolerance, and support for
`disconnected operations.
`To cope with this variety of requirements and needs, in-
`dustrial and academic researchers have proposed a number
`of MCSs. This lively and sometimes chaotic research activ-
`ity has generated some confusion about the semantics of
`mobile code concepts and technologies.
`A first problem is the unclear distinction between im-
`plementation technologies, specific applications, and para-
`digms used to design these applications. In an early and yet
`valuable assessment of code mobility [12], the authors
`analyze and compare issues and concepts that belong to
`different abstraction levels. Similarly, in a recent work
`about autonomous objects [13], mechanisms like REV [14]
`and RPC [15] are compared to the Echo distributed algo-
`rithms [16], to applications like “intelligent e-mail” and Web
`browsers, and to paradigms for structuring distributed ap-
`plications, like mobile agents. We argue that these different
`concepts and notions cannot be compared directly. It is as
`inappropriate and misleading as trying to compare the
`emacs editor, the fork Unix system call, and the client-
`server design paradigm.
`There is also confusion about terminology. For instance,
`several systems [17], [18] claim to be able to move the state
`of a component along with its code. This assertion is justi-
`fied by the availability of mechanisms that allow the pro-
`grammer to pack some portion of the data space of an exe-
`cuting component before the component’s code is sent to a
`remote destination. Indeed, this is quite different from the
`situation where the run-time image of the component is
`transferred as a whole, including its execution state (i.e.,
`program counter, call stack, etc.). In the former case, it is the
`programmer’s task to rebuild the execution state of a com-
`ponent after its migration, using the data transferred with
`the code. Conversely, in the latter case this task is carried
`out by the run-time support of the MCS. Another termino-
`logical confusion stems from the excessive overload of the
`term “mobile agent.” This term is used with different and
`somewhat overlapping semantics in both the distributed
`systems and artificial intelligence research communities. In
`the distributed system community the term “mobile agent”
`is used to denote a software component that is able to move
`between different execution environments. This definition
`has actually different interpretations. For example, while in
`Telescript [19] an agent is represented by a thread that can
`migrate among different nodes carrying its execution state,
`in TACOMA [17] agents are just code fragments associated
`with initialization data that can be shipped to a remote
`host. They do not have the ability to migrate once they have
`started their execution. On the other hand, in the artificial
`intelligence community the term “agent” denotes a soft-
`ware2 component that is able to achieve a goal by perform-
`ing actions and reacting to events in a dynamic environ-
`
`2. In this paper we ignore the implications of broader notions of agent
`which are not restricted to the software domain.
`
`ment [20]. The behavior of this component is determined by
`the knowledge of the relationships among events, actions,
`and goals. Moreover, knowledge can be exchanged with
`other agents, or increased by some inferential activity [21].
`Although mobility is not the most characterizing aspect of
`these entities [22], there is a tendency to blend this notion of
`intelligent agent with the one originating from distributed
`systems and thus assume implicitly that a mobile agent is
`also intelligent (and vice versa). This is actually generating
`confusion since there is a mix of concepts and notions that
`belong to two different layers, i.e., the layer providing code
`mobility and the one exploiting it. Finally, there is no defi-
`nition or agreement about the distinguishing characteristics
`of languages supporting code mobility. In [23], Knabe lists
`the essential characteristics of a mobile code language. They
`include support for manipulating, transmitting, receiving,
`and executing “code-containing objects.” However, there is
`no discussion about how to manage the state of mobile
`components. Other contributions [24], [12] consider only
`the support for mobility of both code and state, without
`mentioning weaker forms of code mobility involving code
`migration alone—as we discuss later on in the paper.
`Certainly, confusion and disagreement are typical of a
`new and still immature research field. Nevertheless, re-
`search developments are fostered not only by novel ideas,
`mechanisms, and systems, but also by a rationalization and
`conceptualization effort that re-elaborates on the raw ideas,
`seeking for a common and stable ground on which to base
`further endeavors. Research on code mobility is not an ex-
`ception. The technical concerns raised by performance and
`security of MCSs are not the only factors hampering full
`acceptance and exploitation of mobile code. A conceptual
`framework is needed to foster understanding of the multi-
`faceted mobile code scenario. It will enable researchers and
`practitioners to assess and compare different solutions with
`respect to a common set of reference concepts and abstrac-
`tions—and go beyond it. To be effective, this conceptual
`framework should also provide valuable information to
`application developers, actually guiding the evaluation of
`opportunities for exploitation of code mobility during the
`different phases of application development.
`These considerations provide the rationale for the classi-
`fication presented in this paper. The classification intro-
`duces abstractions, models, and terms to characterize the
`different approaches to code mobility proposed so far,
`highlighting commonalities, differences, and applicability.
`The classification is organized along three dimensions that
`are of paramount importance during the actual develop-
`ment process: technologies, design paradigms, and application
`domains. Mobile code technologies are the languages and
`systems that provide mechanisms enabling and supporting
`code mobility. Some of these technologies have been al-
`ready mentioned and are discussed in greater detail in the
`next section. Mobile code technologies are used by the ap-
`plication developer in the implementation stage. Design
`paradigms are the architectural styles that the application
`designer uses in defining the application architecture. An
`architectural style identifies a specific configuration for the
`components of the system and their mutual interactions.
`Client-server and peer-to-peer are well-known examples of
`
`Authorized licensed use limited to: IEEE Staff. Downloaded on August 06,2021 at 16:23:41 UTC from IEEE Xplore. Restrictions apply.
`
`Netflix, Inc. - Ex. 1026, Page 000008
`
`

`

`FUGGETTA ET AL.: UNDERSTANDING CODE MOBILITY
`
`345
`
`design paradigms. Application domains are classes of appli-
`cations that share the same general goal, e.g., distributed
`information retrieval or electronic commerce. They play a
`role in defining the application requirements. The expected
`benefits of code mobility in a number of application do-
`mains is the motivating force behind this research field.
`Our classification will break down in a vertical distinc-
`tion among these three layers, as well as in an horizontal
`distinction among the peculiarities of the various ap-
`proaches found in literature. Section 3 presents a general
`model and a classification of the mechanisms provided by
`mobile code technologies. The classification is then used to
`survey and characterize several MCSs. Section 4 presents
`mobile code design paradigms and discusses their relation-
`ships with mobile code technologies. Section 5 discusses the
`advantages of the mobile code approach and presents some
`application domains that are supposed to benefit from the
`use of some form of code mobility. Finally, in Section 6 we
`exemplify the use of the classification by applying it to a
`case study in the network management application domain.
`
`3(cid:3) MOBILE CODE TECHNOLOGIES
`Mobile code technologies include programming languages
`and their corresponding run-time supports. At a first
`glance, these technologies provide quite different concepts
`and primitives. For this reason, the first part of this section
`introduces some reference abstractions, and then seeks out
`and classifies the different mechanisms that allow an appli-
`cation to move code and state across the nodes of a net-
`work. We are concerned here only with the issues strictly
`related to mobility. Other aspects of mobile code technology
`are indeed relevant, such as security or strategies for trans-
`lation and execution. On-going work is defining a similar
`framework for these aspects as well. In the second part of
`the section (Section 3.3), the classification of mobility
`mechanisms is used to characterize the features provided
`by several existing MCSs. The classification accommodates
`several technologies found in literature. The set of tech-
`nologies considered is not exhaustive, and is constrained by
`space and by the focus of the paper. However, the reader
`may actually verify the soundness of the classification by
`applying it to other MCSs not considered here, like the ones
`described in [25], [26], [27]. Also, the reader interested in a
`more detailed analysis of the linguistic problems posed by
`the introduction of mobility in programming languages can
`refer to [28], [29].
`
`3.1 A Virtual Machine for Code Mobility
`Traditional distributed systems can be accommodated in
`the virtual machine shown on the left-hand side of Fig. 1.
`The lowest layer, just upon the hardware, is constituted by
`the Core Operating System (COS). The COS can be regarded
`as the layer providing the basic operating system function-
`alities, such as file system, memory management, and proc-
`ess support. No support for communication or distribution
`is provided by this layer. Nontransparent communication
`services are provided by the Network Operating System
`(NOS) layer. Applications using NOS services address ex-
`plicitly the host targeted by communication. For instance,
`
`socket services can be regarded as belonging to the NOS
`layer, since a socket must be opened by specifying explicitly
`a destination network node. The NOS, at least conceptually,
`uses the services provided by the COS, e.g., memory man-
`agement. Network transparency is provided by the True
`Distributed System (TDS) layer. A TDS implements a plat-
`form where components, located at different sites of a net-
`work, are perceived as local. Users of TDS services do not
`need to be aware of the underlying structure of the net-
`work. When a service is invoked, there is no clue about the
`node of the network that will actually provide the service,
`and even about the presence of a network at all. As an ex-
`ample, CORBA [3] services can be regarded as TDS services
`since a