Viewing Objects

Total Page:16

File Type:pdf, Size:1020Kb

Viewing Objects Viewing Ob jects Peter J Barclay and Jessie B Kennedy Computer Studies Dept., Napier University 219 Colinton Road, Edinburgh EH14 1DJ Abstract. This pap er examines the incorp oration of database views into an ob ject oriented conceptual mo del. An approach is presented where views are themselves ob jects, instances of view classes. These view ob jects provide new ways of interacting with preexisting data; no new ob jects are required to p opulate the view. Although this approach requires no new concepts to b e added to the ob ject oriented data mo del, a large category of views may b e realised. These views allow (parameterisable) sp eci cation of their p op- ulations, and may b e arranged in hierarchies; the ob jects they contain may b e decomp osed or combined, and mayhave prop erties added or hidden. The views presented maintain the integrity of the underlying ob ject mo del, and allow up dating where appropriate. A prototyp e implementation of a data management system supp orting such views is describ ed brie y. 1 Intro duction This pap er presents an approach to database views consistent with a generic ob ject oriented data mo del. Section 2 reviews database views, and their incorp oration in ob ject oriented approaches. Section 3 overviews the ob ject oriented data mo del used. Section 4 shows how a wide category of views can b e realised without need of new mo delling constructs. Section 5 addresses the use and maintenance of views, describ- ing brie y one implementation. Section 6 concludes with a discussion, a comparison with related work, and some directions for future research. 2 Background 2.1 Database Views ANSI/SPARChave de ned a three-level architecture of database description [Jar76] 1 where the topmost `external' level represents a collection of subschemata appropri- ate for particular database users. The central `conceptual' level provides a compre- hensiveoverall description of the enterprise mo delled. Since some users maywork at this conceptual level directly,itmight b e considered a sp ecial case of a view of the data | the most complete view. The views at the external level are abstractions over this base. Views help manage the intellectual complexityofinteracting with the data, by hiding unnecessary detail and presenting information in the most appropriate format; 1 More accurately, these are alternativeschemata whichmay b e derived from the concep- tual schema or some subset of it. further, they mayprovide a level of security where only the information allowable to certain users will b e present in the views which they use. A view is sometimes de ned as a query, but is p erhaps b etter thought of simply as a database schema and its extension. Since for the user of a view, the view schema provides the most comprehensiveoverall description of the data as she knows it, the term `notional (conceptual) schema' will b e used here to mean a schema describing the data as if the view it represents were the central conceptual level. The term `implementing schema' will be used for the schema which shows how the notional view schema is abstracted from the base conceptual schema. This implementing schema corresp onds to the queries in the `view as query' p ersp ective. 2.2 Views in an Ob ject Oriented Context Views have b een well investigated in the relational context (eg [Dat87,chapter 8]). However, developments such as ob ject oriented database systems [Dit88], [Oxb88], + [ABD 89], [GJ89], [Kho90], [ZM90b], [ZM90a] and database programming languages + + [Atk78], [Bun84] (including p ersistent programming languages [ABC 83], [ABC 84], [Co c82], [Co o90]) require development of the concept of a view b eyond that found in the relational mo del. Programming languages have incorp orated various notions of data abstraction [Gut77], [MP88]whichhave b een realised in constructs suchasthepackages of Ada [Bar82], [alr83]. Data abstraction is central in the class concept of ob ject oriented programming languages [SB85], [Sau89]suchasSimula [BDMN79], Smalltalk [GR83] and C++ [Str87], [BG93]. Although some ob ject oriented database systems suchas Postgres have b een based on extensions of the relational mo del [p os90], [Sto87], + others such as Gemstone [BMO 89] and ONTOS [ont90]have b een based closely on such ob ject oriented programming languages. However, the programming language notions of data abstraction are often insucient for database views since the latter requires the notions of p opulation | a subset of preexisting ob jects are to participate in the view. Further, databases frequently require multiple co existing abstractions over the same data. So far, views have b een little supp orted in ob ject oriented database systems (some exceptions are reviewed in section 6.2). Whereas relational views may hide or create attributes in tables, ob jected oriented views must hide or create b ehaviour as well as structure. Further, they should not violate encapsulation, and should interact felicitously with the inheritance graph and the comp osition graph of the underlying mo del. Some approaches to ob ject oriented views (eg [HZ90]) have involved the creation of new ob jects to p opulate the view; this gives rise to various problems in assigning identity[KC86] to these `imaginary' ob jects. 3 NOM | The Napier Ob ject Mo del This section reviews brie y the ob ject oriented mo delling context within which views will b e explored. 3.1 A Conceptual Ob ject Oriented Mo del NOM (the Napier Ob ject Mo del) is an ob ject oriented data mo del based on the mo delling approach describ ed by the authors in [BK91]. The basic aim of NOM is to provide a simple, `vanilla' ob ject data mo del for the investigation of issues in ob ject oriented mo delling. The mo del is more biased towards expressivity for semantics capture than towards ecient implementation. NOM has b een used for the analysis of novel database application areas [BK92a], and for the investigation of sp eci c mo delling issues such as declarative integrity constraints and activeness in ob ject oriented data mo dels [BK92b]. 3.2 NOODL | the Napier Ob ject Oriented Data De nition Language NOODL (Napier Ob ject Oriented Data De nition Language) is a data de nition and manipulation language based on the textual notation used in [BK91]. A brief summary only is given here; further detail will b e intro duced later through examples. A complete description of NOODL may b e found in [Bar93]. A NOODL schema consists of a collection of class de nitions; each de nition p ertains to one particular class of ob ject app earing in the domain mo delled. Each class is named, and its ancestors (sup erclasses) cited. The prop erties of the class are named and de ned, and their sorts given. NOM blurs any distinction b etween `attributes' and `metho ds'; the term `prop erty' is intended to cover b oth. Prop erties declared without de nition represent stored values, those declared with de nition represent computed values. The de nition of a prop ertymay b e an arbitrary query. The names of prop erties may serve as messages to get and set the corresp ond- ing values; such messages are called gettors and settors resp ectively, and are dis- tinguished simply by the absence or presence of the new value. For example, the expression x.name returns the name of the ob ject x,andx.name("Inyan Hoksi") sets the value of the name prop ertyofx to b e \Inyan Hoksi". 2 Op erations whichmay b e su ered by instances of the class, and integrity con- straints to which they are sub ject, are also sp eci ed in each class de nition. A simple example of a NOODL schema is shown in gure 1. 4 Ob ject Oriented Views 4.1 An Approach to Ob ject Oriented Views The basic technique used here to create any desired view is to create a class of ob jects, instances of which represent the view itself. The op erations of this class provide a site for the various queries de ning how the view is derived from the base. No new ob jects are created to p opulate the view; the same p opulations are simply viewed di erently, through the new op erations. This approach circumvents the problems of assigning identity to imaginary view ob jects, and facilitates up datability. 2 Prop erties are simple characteristics of an ob ject, representing a (notionally) stored value; op erations represent the more complex b ehaviour of an ob ject, are parameterisable and represented by arbitrarily long sequences of query expressions. In the following sections, three classes of views are treated separately: selection- 3 views, pro jection-views, and join-views .Any general view may b e a combination of these three categories, which are treated separately for clarity of exp osition. A selection-view do es not change the `shap e' of the data, but hides the existence of those instances which do not meet the selection criterion ; the selection criterion thus sp eci es the population of the view. A pro jection-view reshap es instances of individual classes; ob jects may lose some prop erties they p ossess in the base, and (despite the name `pro jection') may also gain new prop erties not sp eci ed in the base. A join-view may aggregate together ob jects which are separate in the base, or disaggregate single base ob jects into fragments in the view. Such views can b e sp eci ed (and implemented) entirely at the conceptual level, using NOODL.
Recommended publications
  • Lecture Notes in Computer Science
    Orthogonal Persistence Revisited Alan Dearle, Graham N.C. Kirby and Ron Morrison School of Computer Science, University of St Andrews, North Haugh, St Andrews, Fife KY16 9SX, Scotland {al, graham, ron}@cs.st-andrews.ac.uk Abstract. The social and economic importance of large bodies of programs and data that are potentially long-lived has attracted much attention in the commercial and research communities. Here we concentrate on a set of methodologies and technologies called persistent programming. In particular we review programming language support for the concept of orthogonal persistence, a technique for the uniform treatment of objects irrespective of their types or longevity. While research in persistent programming has become unfashionable, we show how the concept is beginning to appear as a major component of modern systems. We relate these attempts to the original principles of orthogonal persistence and give a few hints about how the concept may be utilised in the future. 1 Introduction The aim of persistent programming is to support the design, construction, maintenance and operation of long-lived, concurrently accessed and potentially large bodies of data and programs. When research into persistent programming began, persistent application systems were supported by disparate mechanisms, each based upon different philosophical assumptions and implementation technologies [1]. The mix of technologies typically included naming, type and binding schemes combined with different database systems, storage architectures and query languages. The incoherence in these technologies increased the cost both intellectually and mechanically of building persistent application systems. The complexity distracted the application builder from the task in hand to concentrate on mastering the multiplicity of programming systems, and the mappings amongst them, rather than the application being developed.
    [Show full text]
  • Persistent Programming and Object Oriented Databases
    l.l Persistent Programming and Object Oriented Databases Malcolm Atkinson and Ronald Morrison University of Glasgow University of St. Andrews Abstract Persistent Programming Languages are defined as those languages which allow any of their values to have lives of any duration. The first ten years of research into those languages are reviewed. The motivation for such languages has increased. There are significant technological developments pertinent to their implementation. To obtain the ir benefits requires a radical revision of the architecture of computer systems, and a major comm itment to the parad igm . Their potential as a foundation for im plementing operating systems and database systems is described, as well as their obvious use for writing long-lived and large scale applications. The paper concludes by examining some aspects of object orientation, to consider the solutions offered by the persistent paradigm. 1 Introduction It is now ten years since a group in Scotland began the implementation of a persistent programming language. This paper reviews the progress in those ten years, and then suggests the next major step in persistent programming research. The review concludes that persistent programming languages have the capability of supporting applications programs and many components currently thought of as system components. The next step will demonstrate the value of persistent languages as a foundation for system software. It will also realise the target of 'seamless' computing which that research began to explore ten years ago, and provide efficient implementation of this class of languages. Such a seamless system is expected to yield very large productivity improvements for the implementers of large app lication systems.
    [Show full text]
  • Napier88 Reference Manual Release 2.2.1
    Napier88 Reference Manual Release 2.2.1 July 1996 Ron Morrison Fred Brown* Richard Connor Quintin Cutts† Alan Dearle‡ Graham Kirby Dave Munro University of St Andrews, North Haugh, St Andrews, Fife KY16 9SS, Scotland. *Department of Computer Science, University of Adelaide, South Australia 5005, Australia. †University of Glasgow, Lilybank Gardens, Glasgow G12 8QQ, Scotland. ‡University of Stirling, Stirling FK9 4LA, Scotland. This document should be referenced as: “Napier88 Reference Manual (Release 2.2.1)”. University of St Andrews (1996). Contents 1 INTRODUCTION ............................................................................. 5 2 CONTEXT FREE SYNTAX SPECIFICATION.......................................... 8 3 TYPES AND TYPE RULES ................................................................ 9 3.1 UNIVERSE OF DISCOURSE...............................................................................................9 3.2 THE TYPE ALGEBRA..................................................................................................... 10 3.2.1 Aliasing............................................................................................................... 10 3.2.2 Recursive Definitions............................................................................................. 10 3.2.3 Type Operators...................................................................................................... 11 3.2.4 Recursive Operators ..............................................................................................
    [Show full text]
  • Chapter 3. the Persistent Programming Language, PS-Algol
    https://theses.gla.ac.uk/ Theses Digitisation: https://www.gla.ac.uk/myglasgow/research/enlighten/theses/digitisation/ This is a digitised version of the original print thesis. Copyright and moral rights for this work are retained by the author A copy can be downloaded for personal non-commercial research or study, without prior permission or charge This work cannot be reproduced or quoted extensively from without first obtaining permission in writing from the author The content must not be changed in any way or sold commercially in any format or medium without the formal permission of the author When referring to this work, full bibliographic details including the author, title, awarding institution and date of the thesis must be given Enlighten: Theses https://theses.gla.ac.uk/ [email protected] On The Utilisation of Persistent Programming Environments Richard Cooper A thesis submitted to the Faculty of Science, University of Glasgow For the degree of Doctor of Philosophy September, 1989 © R. L. Cooper, 1989 ProQuest Number: 10999281 All rights reserved INFORMATION TO ALL USERS The quality of this reproduction is dependent upon the quality of the copy submitted. In the unlikely event that the author did not send a com plete manuscript and there are missing pages, these will be noted. Also, if material had to be removed, a note will indicate the deletion. uest ProQuest 10999281 Published by ProQuest LLC(2018). Copyright of the Dissertation is held by the Author. All rights reserved. This work is protected against unauthorized copying under Title 17, United States C ode Microform Edition © ProQuest LLC.
    [Show full text]
  • Writing Cybersecurity Job Descriptions for the Greatest Impact
    Writing Cybersecurity Job Descriptions for the Greatest Impact Keith T. Hall U.S. Department of Homeland Security Welcome Writing Cybersecurity Job Descriptions for the Greatest Impact Disclaimers and Caveats • Content Not Officially Adopted. The content of this briefing is mine personally and does not reflect any position or policy of the United States Government (USG) or of the Department of Homeland Security. • Note on Terminology. Will use USG terminology in this brief (but generally translatable towards Private Sector equivalents) • Job Description Usage. For the purposes of this presentation only, the Job Description for the Position Description (PD) is used synonymously with the Job Opportunity Announcement (JOA). Although there are potential differences, it is not material to the concepts presented today. 3 Key Definitions and Concepts (1 of 2) • What do you want the person to do? • Major Duties and Responsibilities. “A statement of the important, regular, and recurring duties and responsibilities assigned to the position” SOURCE: https://www.opm.gov/policy-data- oversight/classification-qualifications/classifying-general-schedule-positions/classifierhandbook.pdf • Major vs. Minor Duties. “Major duties are those that represent the primary reason for the position's existence, and which govern the qualification requirements. Typically, they occupy most of the employee's time. Minor duties generally occupy a small portion of time, are not the primary purpose for which the position was established, and do not determine qualification requirements” SOURCE: https://www.opm.gov/policy-data- oversight/classification-qualifications/classifying-general-schedule-positions/positionclassificationintro.pdf • Tasks. “Activities an employee performs on a regular basis in order to carry out the functions of the job.” SOURCE: https://www.opm.gov/policy-data-oversight/assessment-and-selection/job-analysis/job_analysis_presentation.pdf 4 Key Definitions and Concepts (2 of 2) • What do you want to see on resumes that qualifies them to do this work? • Competency.
    [Show full text]
  • Comparative Programming Languages CM20253
    We have briefly covered many aspects of language design And there are many more factors we could talk about in making choices of language The End There are many languages out there, both general purpose and specialist And there are many more factors we could talk about in making choices of language The End There are many languages out there, both general purpose and specialist We have briefly covered many aspects of language design The End There are many languages out there, both general purpose and specialist We have briefly covered many aspects of language design And there are many more factors we could talk about in making choices of language Often a single project can use several languages, each suited to its part of the project And then the interopability of languages becomes important For example, can you easily join together code written in Java and C? The End Or languages And then the interopability of languages becomes important For example, can you easily join together code written in Java and C? The End Or languages Often a single project can use several languages, each suited to its part of the project For example, can you easily join together code written in Java and C? The End Or languages Often a single project can use several languages, each suited to its part of the project And then the interopability of languages becomes important The End Or languages Often a single project can use several languages, each suited to its part of the project And then the interopability of languages becomes important For example, can you easily
    [Show full text]
  • Persistent Programming: a Programming Language and Database Integration Technology
    v PERSISTENT PROGRAMMING: A PROGRAMMING LANGUAGE AND DATABASE INTEGRATION TECHNOLOGY R Morrison Rapporteur: Robert Allen and Dr Robert Stroud V.2 V. 3 PERSISTENT PROGRAMMING: A PROGRAMMING LANGUAGE AND DATABASE INTEGRATION TECHNOLOGY R Morrison, R C H Connor, Q I Cutts, G N C Kirby & D Munro School of Mathematical and Computational Sciences, University of St Andrews, North Haugh, St Andrews KY16 9SS, Scotland [email protected] M P Atkinson Department of Computer Science, University of Glasgow, Glasgow G 12 8QQ, Scotland [email protected] ABSTRACT Persistent programming is concerned with creating and manipulating data in a manner that is independent of its lifetime. The persistence abstraction yields a number of advantages in terms of orthogonal design and programmer productivity. One major advantage is that the abstraction integrates the database view of information with the programming language view. For this reason persistent programming languages are sometimes called database programming languages. A number of design principles have been devised for persistent systems. Following these rules, languages may provide persistence as a basic abstraction. In this paper the motivation for persistence is reviewed along with the above mentioned design rules for orthogonal persistence. Three examples of the integration of programming languages and databases through the persistence abstraction are given along with a discussion of their benefits. The examples are linguistic reflection, concurrency control and a new technology only available in persistent systems, called hyper-programming. 1 Introduction The aim of persistent programming is to support the activity of applications construction. Currently the technology underlying applications building relies on a number of disparate mechanisms and philosophical assumptions for support and efficient implementation.
    [Show full text]
  • Orthogonally Persistent Object Systems
    VLDBJournal,4~ 319-401 (1995), Malcolm Atkinson, Editor 319 QVLDB Orthogonally Persistent Object Systems Malcolm Atkinson and Ronald Morrison Received June, 1993; revised version received, March, 1995; accepted April, 1995. Abstract. Persistent Application Systems (PASs) are of increasing social and eco- nomic importance. They have the potential to be long-lived, concurrently ac- cessed, and consist of large bodies of data and programs. Typical examples of PASs are CAD/CAM systems, office automation, CASE tools, software engineer- ing environments, and patient-care support systems in hospitals. Orthogonally persistent object systems are intended to provide improved support for the de- sign, construction, maintenance, and operation of PASs. Persistence abstraction allows the creation and manipulation of data in a manner that is independent of its lifetime, thereby integrating the database view of information with the program- ming language view. This yields a number of advantages in terms of orthogonal design and programmer productivity which are beneficial for PASs. Design prin- ciples have been proposed for persistent systems. By following these principles, languages that provide persistence as a basic abstraction have been developed. In this paper, the motivation for orthogonal persistence is reviewed along with the above mentioned design principles. The concepts for integrating programming languages and databases through the persistence abstraction, and their benefits, are given. The technology to support persistence, the achievements, and future directions of persistence research are then discussed. Key Words. Orthogonal persistence, persistent programming languages, database programming languages, persistent application systems. 1. Introduction This paper presents a broad review of current research and achievements in or- thogonally persistent object systems.
    [Show full text]
  • Napier88 – a Database Programming Language?
    This paper should be referenced as: Dearle, A., Connor, R.C.H., Brown, A.L. & Morrison, R. “Napier88 - A Database Programming Language?”. In Proc. 2nd International Workshop on Database Programming Languages, Salishan, Oregon (1989) pp 179-195. Napier88 – A Database Programming Language? Alan Dearle, Richard Connor, Fred Brown & Ron Morrison al%uk.ac.st-and.cs@ukc richard%uk.ac.st-and.cs@ukc ab%uk.ac.st-and.cs@ukc ron%uk.ac.st-and.cs@ukc Department of Computational Science University of St Andrews North Haugh St Andrews Scotland KY16 9SS. Abstract This is a description of the Napier88 type system based on "A Framework for Comparing Type Systems for Database Programming Languages" by Albano et al. 1 Introduction This is a description of the Napier88 type system based on "A Framework for Comparing Type Systems for Database Programming Languages" [ADG89]. Napier88 is designed to be a general purpose persistent programming language. The authors envisage the language to be used to construct large, integrated computer systems such as CAD, CASE, hypermedia, database and Office Integration systems. Such systems have the following requirements in common which are met by the Napier88 programming language: 1. the need to support large amounts of dynamically changing, structured data, and, 2. the need for sophisticated MMI. In order to meet these demands an integrated environment is needed which will support all of the application builders' requirements. For comparison, it is useful to distinguish between Database Programming languages and Persistent Programming Languages. Database programming languages are not necessarily computationally complete. They often require the use of other ‘conventional’ programming languages [CL88].
    [Show full text]
  • Method of Paradigmatic Analysis of Programming Languages and Systems
    Method of Paradigmatic Analysis of Programming Languages and Systems Lidia Gorodnyaya1,2[0000-0002-4639-9032] 1 A.P. Ershov Institute of Informatics Systems (IIS), 6, Acad. Lavrentjev pr., Novosibirsk 630090, Russia 2 Novosibirsk State University, Pirogov str., 2, Novosibirsk 630090, Russia [email protected] Abstract. The purpose of the article is to describe the method of comparison of programming languages, convenient for assessing the expressive power of languages and the complexity of the programming systems. The method is adapted to substantiate practical, objective criteria of program decomposition, which can be considered as an approach to solving the problem of factorization of very complicated definitions of programming languages and their support systems. In addition, the article presents the results of the analysis of the most well-known programming paradigms and outlines an approach to navigation in the modern expanding space of programming languages, based on the classification of paradigms on the peculiarities of problem statements and semantic characteristics of programming languages and systems with an emphasis on the criteria for the quality of programs and priorities in decision- making in their implementation. The proposed method can be used to assess the complexity of programming, especially if supplemented by dividing the requirements of setting tasks in the fields of application into academic and industrial, and by the level of knowledge into clear, developed and complicated difficult to certify requirements. Keywords: Definition of Programming Languages, Programming Paradigms, Definition Decomposition Criteria, Semantic Systems 1 Introduction Descriptions of modern programming languages (PL) usually contain a list of 5-10 predecessors and a number of programming paradigms (PP) supported by the language [1,2].
    [Show full text]
  • Fibonacci: a Programming Language for Object Databases 1
    An Introduction to Fibonacci: A Programming Language for Object Databases 1 A. Albano, G. Ghelli, R. Orsini2 Dipartimento di Informatica Università di Pisa Corso Italia 40 56125 Pisa – Italy e-mail: albano, ghelli, [email protected] ABSTRACT Fibonacci is an object-oriented database programming language characterized by static and strong typing and by new mechanisms for modelling databases in terms of objects with roles, classes and associations. A brief introduction to the language is provided to present those features which are particularly suited to modelling complex databases. Examples of the use of Fibonacci are given with reference to the prototype implementation of the language. Categories and Subject Descriptors: D.3.2 [Programming Languages]: Languages Classifications — Object-Oriented Languages; D.3.3 [Programming Languages]: Language Constructs and Features — Data Types and Structures; H.2.3 [Database Management]: Languages — Database (Persistent) Programming Languages. General Terms: Databases, Languages. Additional Key Words and Phrases: Object-Oriented Databases, Database Programming Languages, Objects with Roles, Data Models. 1 This work has been supported in part by grants from the C.E.C. under ESPRIT BRA No.6309 (FIDE2: Fully Integrated Data Environment), the Progetto finalizzato “Sistemi informatici e calcolo parallelo” of C.N.R. under grant No. 93.1502.PF69, and by Ministero dell’Università e della Ricerca Scientifica e Tecnologica. 2 Present address: Corso di Laurea in Scienze dell’Informazione, Università di Venezia, Via Torino 153, 30170, Mestre ([email protected]). 1 1 INTRODUCTION Fibonacci is an object-oriented database programming language characterized by static and strong typing and by new mechanisms for modelling databases in terms of objects with roles, classes and associations.
    [Show full text]
  • Selective Transparency in Distributed Transaction Processing
    Selective Transparency in Distributed Transaction Processing Daniel L. McCue Ph.D. Thesis The University of Newcastle upon Tyne Computing Laboratory April1992 ---- I I I f---- t- Abstract Abstract Object-oriented programming languages provide a powerful interface for programmers to access the mechanisms necessary for reliable distributed computing. Using inheritance and polymorphism provided by the object model, it is possible to develop a hierarchy of classes to capture the semantics and inter-relationships of various levels of functionality required for distributed transaction processing. Using multiple inheritance, application developers can selectively apply transaction properties to suit the requirements of the application objects. In addition to the specific problems of (distributed) transaction processing in an environment of persistent objects, there is a need for a unified framework, or architecture in which to place this system. To be truly effective, not only the transaction manager, but the entire transaction support environment must be described, designed and implemented in terms of objects. This thesis presents an architecture for reliable distributed processing in which the management of persistence, provision of transaction properties (e.g., concurrency control), and organisation of support services (e.g., RPC) are all gathered into a unified design based on the object model. Acknowledgments Acknowledgements "Induced, by a conviction of the great utility of such engines, to withdraw for some time my attention from a subject on which it has been engaged during several years, and which possesses charms of a higher order, I have now arrived at a point where success is no longer doubtful." [Charles Babbage 1822J I sincerely thank my supervisor, Professor Santosh Shrivastava, who has taught me so much about reliability and distributed systems.
    [Show full text]