Design and Validation of Computer Protocols

Total Page:16

File Type:pdf, Size:1020Kb

Design and Validation of Computer Protocols DESIGN AND VALIDATION OF COMPUTER PROTOCOLS Gerard J. Holzmann Bell Laboratories Murray Hill, New Jersey 07974 PRENTICE-HALL Englewood Cliffs, New Jersey 07632 Prentice Hall Software Series Brian W. Kernighan, Advisor Copyright 1991 by Lucent Technologies, Bell Laboratories, Incorporated. This book is typeset in Times Roman by the author, using an Linotronic 200P phototypesetter and a DEC VAX 8550 running the 10th Edition of the UNIX operating system. DEC and VAX are trademarks of Digital Equipment Corporation. UNIX is a registered trademark of AT&T. All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior written permission of the publisher. Printed in the United States of America 10 9 8 7 6 5 4 3 2 1 Prentice-Hall International (UK) Limited, London Prentice-Hall of Australia Pty. Limited, Sydney Prentice-Hall Canada Inc., Toronto Prentice-Hall Hispanoamericana, S.A., Mexico Prentice-Hall of India Private Limited, New Delhi Prentice-Hall of Japan, Inc., Tokyo Simon & Schuster Asia Pte. Ltd., Singapore Editora Prentice-Hall do Brasil, Ltda., Rio de Janeiro CONTENTS Foreword ix Preface xi Part I Ð Basics 1. Introduction 1.1 Early Beginnings 1 1.2 The First Networks 9 1.3 Protocols as Languages 12 1.4 Protocol Standardization 13 1.5 Summary 15 Exercises 16 Bibliographic Notes 16 2. Protocol Structure 2.1 Introduction 19 2.2 The Five Elements of a Protocol 21 2.3 An Example 22 2.4 Service and Environment 26 2.5 Vocabulary and Format 32 2.6 Procedure Rules 35 2.7 Structured Protocol Design 35 2.8 Ten Rules of Design 38 2.9 Summary 39 Exercises 39 Bibliographic Notes 40 3. Error Control 3.1 Introduction 43 3.2 Error Model 44 3.3 Types of Transmission Errors 46 3.4 Redundancy 46 3.5 Types of Codes 47 3.6 Parity Check 48 3.7 Error Correction 48 3.8 A Linear Block Code 52 3.9 Cyclic Redundancy Checks 56 3.10 Arithmetic Checksum 63 3.11 Summary 64 Exercises 64 Bibliographic Notes 65 4. Flow Control 4.1 Introduction 66 4.2 Window Protocols 70 4.3 Sequence Numbers 74 4.4 Negative Acknowledgments 80 4.5 Congestion Avoidance 83 4.6 Summary 86 Exercises 87 Bibliographic Notes 88 Part II Ð Specification and Modeling 5. Validation Models 5.1 Introduction 90 5.2 Processes, Channels, Variables 91 5.3 Executability of Statements 91 5.4 Variables and Data Types 92 5.5 Process Types 93 5.6 Message Channels 96 5.7 Control Flow 100 5.8 Examples 102 5.9 Modeling Procedures and Recursion 104 5.10 Message Type Definitions 104 5.11 Modeling Timeouts 105 5.12 Lynch's Protocol Revisited 106 5.13 Summary 107 Exercises 108 Bibliographic Notes 109 6. Correctness Requirements 6.1 Introduction 111 6.2 Reasoning about Behavior 112 6.3 Assertions 114 6.4 System Invariants 115 6.5 Deadlocks 117 6.6 Bad Cycles 118 6.7 Temporal Claims 119 6.8 Summary 125 Exercises 126 Bibliographic Notes 127 7. Protocol Design 7.1 Introduction 128 7.2 Service Specification 129 7.3 Assumptions about the Channel 130 7.4 Protocol Vocabulary 131 7.5 Messsage Format 133 7.6 Procedure Rules 140 7.7 Summary 160 Exercises 160 Bibliographic Notes 161 8. Finite State Machines 8.1 Introduction 162 8.2 Informal Description 162 8.3 Formal Description 169 8.4 Execution of Machines 170 8.5 Minimization of Machines 171 8.6 The Conformance Testing Problem 174 8.7 Combining Machines 175 8.8 Extended Finite State Machines 176 8.9 Generalization of Machines 178 8.10 Restricted Models 181 8.11 Summary 184 Exercises 185 Bibliographic Notes 185 Part III Ð Conformance Testing, Synthesis and Validation 9. Conformance Testing 9.1 Introduction 187 9.2 Functional Testing 188 9.3 Structural Testing 189 9.4 Deriving UIO Sequences 195 9.5 Modified Transition Tours 196 9.6 An Alternative Method 197 9.7 Summary 199 Exercises 200 Bibliographic Notes 200 10. Protocol Synthesis 10.1 Introduction 203 10.2 Protocol Derivation 203 10.3 Derivation Algorithm 208 10.4 Incremental Design 210 10.5 Place Synchronization 210 10.6 Summary 211 Exercises 212 Bibliographic Notes 212 11. Protocol Validation 11.1 Introduction 214 11.2 Manual Proof Method 214 11.3 Automated Validation Methods 218 11.4 The Supertrace Algorithm 226 11.5 Detecting Non-Progress Cycles 231 11.6 Detecting Acceptance Cycles 234 11.7 Checking Temporal Claims 235 11.8 Complexity Management 235 11.9 Boundedness of PROMELA Models 237 11.10 Summary 238 Exercises 239 Bibliographic Notes 240 Part IV Ð Design Tools 12. A Protocol Simulator 12.1 Introduction 243 12.2 SPIN Ð Overview 244 12.3 Expressions 245 12.4 Variables 255 12.5 Statements 265 12.6 Control Flow 275 12.7 Process and Message Types 282 12.8 Macro Expansion 292 12.9 SPIN Options 293 12.10 Summary 294 Exercises 295 Bibliographic Notes 296 13. A Protocol Validator 13.1 Introduction 297 13.2 Structure of the Validator 298 13.3 The Validation Kernel 299 13.4 The Transition Matrix 302 13.5 The Validator-Generator Code 303 13.6 Overview of the Code 306 13.7 Guided Simulation 308 13.8 Some Applications 310 13.9 Coverage in Supertrace Mode 315 13.10 Summary 316 Exercises 316 Bibliographic Notes 317 14. Using the Validator 14.1 Introduction 318 14.2 An Optical Telegraph Protocol 318 14.3 Dekker's Algorithm 320 14.4 A Larger Validation 322 14.5 Flow Control Validation 325 14.6 Session Layer Validation 336 14.7 Summary 349 Exercises 349 Bibliographic Notes 349 Conclusion 351 References 352 Appendices A. Data Transmission 367 B. Flow Chart Language 380 C. PROMELA Language Report 383 D. SPIN Simulator Source 393 E. SPIN Validator Source 436 F. PROMELA File Transfer Protocol 528 Name Index 537 Subject Index 539 PREFACE Protocols are sets of rules that govern the interaction of concurrent processes in distri- buted systems. Protocol design is therefore closely related to a number of established fields, such as operating systems, computer networks, data transmission, and data communications. It is rarely singled out and studied as a discipline in its own right. Designing a logically consistent protocol that can be proven correct, however, is a challenging and often frustrating task. It can already be hard to convince ourselves of the validity of a sequentially executed program. In distributed systems we must rea- son about concurrently executed, interacting programs. Books about distributed systems, computer networks, or data communications often do no better than describe a set of standard solutions that have been accepted as correct by, for instance, large international organizations. They do not tell us why the solutions work, what problems they solve, or what pitfalls they avoid. This text is intended as a guide to protocol design and analysis, rather than as a guide to standards and formats. It discusses design issues instead of applications. Two issues, therefore, are beyond the scope of this text: network control (including routing, addressing, and congestion control) and implementation. There is, however, no shor- tage of texts on both topics. The design problem is addressed here as a fundamental and challenging issue, rather than as an irritating practical obstacle to the development of reliable communication systems. The aim of the book is to make you familiar with all the issues of protocol validation and protocol design. The first part of the book covers the basics. Chapter 1 gives a flavor of the types of problems that are discussed. Chapter 2 deals with protocol structure and general design issues. Chapters 3 and 4 discuss the basics of error control and flow control. The next four chapters cover formal protocol modeling and specification techniques, beginning in Chapters 5 and 6 with the introduction of the concept of a protocol vali- dation model, that serves as an abstraction of a design and a prototype of its imple- mentation. In Chapter 5 a terse new language called PROMELA is introduced for the i PREFACE xi description of protocol validation models, and in Chapter 6 it is extended for the specification of protocol correctness requirements. In Chapter 7 we use PROMELA to discuss a number of standard design problems in the development of a sample file transfer protocol. Part II closes with a discussion, in Chapter 8, of the extended finite state machine, a basic notion in many formal modeling techniques. The third part of the book focuses on protocol synthesis, testing, and validation tech- niques that can be used to battle a protocol's complexity. Both the capabilities and the limitations of the formal design techniques are covered. The fourth and last part of the book gives a detailed description of the design of two protocol design tools based on PROMELA: an interpreter and an automated validator. Based on these tools, an implementation generator is simple to add. Source code for the tools is provided in Appendices D and E. The source is also available in elec- tronic form. Ordering information can be found in Appendix E. LECTURE PLAN The core of this book is contained in Chapters 2, 5, 6, 7, and 11. These chapters explore a design discipline that is supported by the tools discussed in Chapters 12 to 14. The remaining text is meant to make the book relatively self-contained. Chapter 3 on error control, Chapter 4 on flow control, and Chapter 8 on finite state machines give background information that should be part of the working knowledge of every protocol designer.
Recommended publications
  • Introduction to Concurrent Programming
    Introduction to Concurrent Programming Rob Pike Computing Sciences Research Center Bell Labs Lucent Technologies [email protected] February 2, 2000 1 Overview The world runs in parallel, but our usual model of software does not. Programming languages are sequential. This mismatch makes it hard to write systems software that provides the interface between a computer (or user) and the world. Solutions: processes, threads, concurrency, semaphores, spin locks, message-passing. But how do we use these things? Real problem: need an approach to writing concurrent software that guides our design and implementation. We will present our model for designing concurrent software. It’s been used in several languages for over a decade, producing everything from symbolic algebra packages to window systems. This course is not about parallel algorithms or using multiprocessors to run programs faster. It is about using the power of processes and communication to design elegant, responsive, reliable systems. 2 History (Biased towards Systems) Dijkstra: guarded commands, 1976. Hoare: Communicating Sequential Processes (CSP), (paper) 1978. Run multiple communicating guarded command sets in parallel. Hoare: CSP Book, 1985. Addition of channels to the model, rather than directly talking to processes. Cardelli and Pike: Squeak, 1983. Application of CSP model to user interfaces. Pike: Concurrent Window System, (paper) 1988. Application of Squeak approach to systems software. Pike: Newsqueak, 1989. Interpreted language; used to write toy window system. Winterbottom: Alef, 1994. True compiled concurrent language, used to write production systems software. Mullender: Thread library, 1999. Retrofit to C for general usability. 3 Other models exist Our approach is not the only way.
    [Show full text]
  • Knowledge Management Enviroments for High Throughput Biology
    Knowledge Management Enviroments for High Throughput Biology Abhey Shah A Thesis submitted for the degree of MPhil Biology Department University of York September 2007 Abstract With the growing complexity and scale of data sets in computational biology and chemoin- formatics, there is a need for novel knowledge processing tools and platforms. This thesis describes a newly developed knowledge processing platform that is different in its emphasis on architecture, flexibility, builtin facilities for datamining and easy cross platform usage. There exist thousands of bioinformatics and chemoinformatics databases, that are stored in many different forms with different access methods, this is a reflection of the range of data structures that make up complex biological and chemical data. Starting from a theoretical ba- sis, FCA (Formal Concept Analysis) an applied branch of lattice theory, is used in this thesis to develop a file system that automatically structures itself by it’s contents. The procedure of extracting concepts from data sets is examined. The system also finds appropriate labels for the discovered concepts by extracting data from ontological databases. A novel method for scaling non-binary data for use with the system is developed. Finally the future of integrative systems biology is discussed in the context of efficiently closed causal systems. Contents 1 Motivations and goals of the thesis 11 1.1 Conceptual frameworks . 11 1.2 Biological foundations . 12 1.2.1 Gene expression data . 13 1.2.2 Ontology . 14 1.3 Knowledge based computational environments . 15 1.3.1 Interfaces . 16 1.3.2 Databases and the character of biological data .
    [Show full text]
  • Squinting at Power Series
    Squinting at Power Series M. Douglas McIlroy AT&T Bell Laboratories Murray Hill, New Jersey 07974 ABSTRACT Data streams are an ideal vehicle for handling power series. Stream implementations can be read off directly from simple recursive equations that de®ne operations such as multiplication, substitution, exponentiation, and reversion of series. The bookkeeping that bedevils these algorithms when they are expressed in traditional languages is completely hidden when they are expressed in stream terms. Communicating processes are the key to the simplicity of the algorithms. Working versions are presented in newsqueak, the language of Pike's ``squint'' system; their effectiveness depends critically on the stream protocol. Series and streams Power series are natural objects for stream processing. Pertinent computations are neatly describable by recursive equations. CSP (communicating sequential process) languages1, 2 are good vehicles for implementation. This paper develops the algorithmic ideas and reduces them to practice in a working CSP language,3 not coincidentally illustrating the utility of concurrent programming notions in untangling the logic of some intricate computations on sequences. This elegant approach to power series computation, ®rst demonstrated but never published by Kahn and MacQueen as an application of their data stream system, is still little known.4 Power series are represented as streams of coef®cients, the exponents being given implicitly by ordinal position. (This is an in®nite analogue of the familiar representation of a polynomial as an array of coef®cients.) Thus the power series for the exponential function ∞ 1 1 1 e x = Σ x n / n! = 1 + x + __ x 2 + __ x 3 + ___ x 4 + .
    [Show full text]
  • Go Web App Example
    Go Web App Example Titaniferous and nonacademic Marcio smoodges his thetas attuned directs decreasingly. Fustiest Lennie seethe, his Pan-Americanism ballasts flitted gramophonically. Flavourless Elwyn dematerializing her reprobates so forbiddingly that Fonsie witness very sartorially. Ide support for web applications possible through gvm is go app and psych and unlock new subcommand go library in one configuration with embedded interface, take in a similar Basic Role-Based HTTP Authorization in fare with Casbin. Tools and web framework for everything there is big goals. Fully managed environment is go app, i is a serverless: verifying user when i personally use the example, decentralized file called marshalling which are both of. Simple Web Application with light Medium. Go apps into go library for example of examples. Go-bootstrap Generates a gait and allowance Go web project. In go apps have a value of. As of December 1st 2019 Buffalo with all related packages require Go Modules and. Authentication in Golang In building web and mobile. Go web examples or go is made against threats to run the example applying the data from the set the search. Why should be restarted for go app. Worth the go because you know that endpoint is welcome page then we created in addition to get started right of. To go apps and examples with fmt library to ensure a very different cloud network algorithms and go such as simple. This example will set users to map support the apps should be capable of examples covers both directories from the performance and application a form and array using firestore implementation.
    [Show full text]
  • A Descent Into Limbo Brian W
    A Descent into Limbo Brian W. Kernighan [email protected] Revised April 2005 by Vita Nuova ABSTRACT ‘‘If, reader, you are slow now to believe What I shall tell, that is no cause for wonder, For I who saw it hardly can accept it.’’ Dante Alighieri, Inferno, Canto XXV. Limbo is a new programming language, designed by Sean Dorward, Phil Winter- bottom, and Rob Pike. Limbo borrows from, among other things, C (expression syntax and control flow), Pascal (declarations), Winterbottom’s Alef (abstract data types and channels), and Hoare’s CSP and Pike’s Newsqueak (processes). Limbo is strongly typed, provides automatic garbage collection, supports only very restricted pointers, and compiles into machine-independent byte code for execution on a virtual machine. This paper is a brief introduction to Limbo. Since Limbo is an integral part of the Inferno system, the examples here illustrate not only the language but also a cer- tain amount about how to write programs to run within Inferno. 1. Introduction This document is a quick look at the basics of Limbo; it is not a replacement for the reference manual. The first section is a short overview of concepts and constructs; subsequent sections illustrate the language with examples. Although Limbo is intended to be used in Inferno, which emphasizes networking and graphical interfaces, the discussion here begins with standard text- manipulation examples, since they require less background to understand. Modules: A Limbo program is a set of modules that cooperate to perform a task. In source form, a module consists of a module declaration that specifies the public interface ߝ the functions, abstract data types, and constants that the module makes visible to other modules ߝ and an implementation that provides the actual code.
    [Show full text]
  • Go's Concurrency Constructs on The
    Go’s Concurrency Constructs on the SCC Andreas Prell, Thomas Rauber To cite this version: Andreas Prell, Thomas Rauber. Go’s Concurrency Constructs on the SCC. The 6th Many-core Appli- cations Research Community (MARC) Symposium, Jul 2012, Toulouse, France. pp.2-6. hal-00718924 HAL Id: hal-00718924 https://hal.archives-ouvertes.fr/hal-00718924 Submitted on 18 Jul 2012 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Proceedings of the 6th Many-core Applications Research Community (MARC) Symposium http://sites.onera.fr/scc/marconera2012 July 19th–20th 2012 ISBN 978-2-7257-0016-8 6Th MARC Symposium, 19–20 July 2012, ONERA ISBN: 978-2-7257-0016-8 Go’s Concurrency Constructs on the SCC Andreas Prell and Thomas Rauber Department of Computer Science University of Bayreuth, Germany {andreas.prell,thomas.rauber}@uni-bayreuth.de Abstract—We present an implementation of goroutines and language for writing concurrent programs [4]. CSP introduced channels on the SCC. Goroutines and channels are the building the concept of channels for interprocess communication (not blocks for writing concurrent programs in the Go programming in the original paper but in a later book on CSP, also by Hoare language.
    [Show full text]
  • Newsqueak: a Language for Communicating with Mice
    Computing Science Technical Report No. 143 Newsqueak: A Language for Communicating with Mice Rob Pike April 9, 1994 Newsqueak: A Language for Communicating with Mice Rob Pike ABSTRACT This is the reference manual for the revised Squeak language, a concur- rent language designed for writing interactive graphics programs. The lan- guage is, however, much more generally applicable. This manual defines the language. Separate documents will describe the libraries and give a ratio- nale for the design. April 9, 1994 Newsqueak: A Language for Communicating with Mice Rob Pike This is an informal reference manual for the concurrent language Newsqueak. Newsqueak’s roots are in Squeak, a language designed a few years ago by Luca Cardelli and Rob Pike to illustrate concurrent solutions to problems in user interface design. Newsqueak addresses the same problems but in a broader context: Squeak was for designing devices such as menus and scroll bars; Newsqueak is for writing entire applications, and in particu- lar a window system. Besides a wholesale redesign of Squeak’s syntax, Newsqueak therefore has several major components absent in Squeak: a type system, dynamic process creation, and dynamic channel creation. Also, Squeak deferred most mundane programming details to the language it compiled into, C. Newsqueak is instead a self-contained language. An inter- preter for it, called squint, has been implemented. Newsqueak draws heavily from CSP and C, and the discussion that follows assumes modest familiarity with both these languages. Roughly, the syntax and basic semantics come from C, while the message-passing primitives come from CSP. The way these are put together is, however, unique to Newsqueak.
    [Show full text]
  • The Programming Language Go
    The Programming Language Go The Programming Language Go Jessica Pavlin Department of Computing and Software McMaster University November 16, 2010 The Programming Language Go Outline 1 Who & Why 2 How Basic Structure Types and Interfaces Concurrency Implementation 3 Concluding Remarks The Programming Language Go Who & Why Who Designed and Implemented Go? The Programming Language Go Who & Why A Very Brief History Sept. 2007 Robert Griesemer, Rob Pike and Ken Thompson started sketching the goals for a new language on a white board Sept. 2007 Within a few days they had their goals and plan sketched out Sept. 2007 They continued to design the new language whenever they had time Jan. 2008 Thompson started the compiler May 2008 Taylor started the gcc front end for Go using specs Late 2008 Russ Cox joined in helped to implement the language and libraries The Programming Language Go Who & Why A Very Brief History Sept. 2007 Robert Griesemer, Rob Pike and Ken Thompson started sketching the goals for a new language on a white board Sept. 2007 Within a few days they had their goals and plan sketched out Sept. 2007 They continued to design the new language whenever they had time Jan. 2008 Thompson started the compiler May 2008 Taylor started the gcc front end for Go using specs Late 2008 Russ Cox joined in helped to implement the language and libraries The Programming Language Go Who & Why Motivation for a New Language Frustration with existing languages and environments for systems programming They felt that programming languages were partly to blame for programming becoming “too difficult” Didn’t want to have to choose anymore between: Efficient compilation Efficient execution Ease of programming The Programming Language Go Who & Why Goals for a New Language 1 As easy to program as an interpreted, dynamically typed language 2 The efficiency and safety of a statically typed, compiled language 3 Modern: support for networked and multicore computing 4 Fast 5 Make programming fun again The Programming Language Go Who & Why A Very Brief History Sept.
    [Show full text]
  • Evolving Languages (5 Steps to Go) [email protected]
    Evolving Languages (5 Steps to Go) [email protected] This talk didn’t accompany a paper, which makes the slides harder to follow on their own. Although the talk might be available in video form, it might be useful to have something that can just be read. After the talk, I’ve added speaker’s notes to help. The talk was prompted by the 10th anniversary of Go’s public release. Originally it was to be on Limbo, but I thought a talk on a (now) obscure predecessor, though easy to do, might not be all that valuable. Coincidentally I read a section in Kernighan’s History of Unix that put Limbo into a sequence of languages on the way to Go. I had a slightly different view of it, not as a strict historic sequence but as the result of design choices prompted by the systems or environments in which the languages were to be used. After I’d started preparing the talk, I discovered a talk by Rob Pike that does look at the languages as more of an incremental development (see http://go-lang.cat-v.org/talks/slides/emerging-languages-camp-2010.pdf) and that can be read for contrast. History 1985 CSP book “Communicating Sequential Processes”: Hoare (esp Occam) 1985 Squeak (“A Language for Communicating with Mice”): Cardelli & Pike 1992 Alef (Plan 9): Winterbottom 1994 Newsqueak (“A Language for Communicating with Mice”): Pike 1996 Limbo (Inferno): Dorward, Pike & Winterbottom (Lucent); Vita Nuova * 2009 Go: Griesemer, Pike & Thompson (Google) * There were two versions of Hoare’s Communicating Sequential Processes.
    [Show full text]
  • A Concurrent Window System
    A Concurrent Window System Rob Pike AT&T Bell Laboratories ABSTRACT: When implemented in a concurrent language, a window system can be concise. If its client programs connect to the window system using an interface defined in terms of communication on synchronous channels, much of the complexity of traditional event-based interfaces can be avoided. Once that interface is specified, complex interactive programs can be assembled, not monolithically, but rather by connecting, using the same techniques, small self-contained components that each imple- ment or modify elements of the interface. In partic- ular, the window system itself may be run recur- sively to implement subwindows for multiplexed applications such as multi-frle text editors. This is the software tool approach applied to windows. @ Computing Systems, Vol. 2 . No. 2 . Spring 1989 133 1. Introduction Traditional window systems offer their clients - the programs that call upon them for services an interface consisting primarily of a - o'events": graphics library and a stream of tokens representing key presses, mouse motion and so on. The clients of these systems tend to be written as state machines with transitions triggered by these events. Although this style of programming is adequate, it is uncomfortable; state machines are powerful but inconvenient. There are also engineering reasons to object to this interface style: all types of events come through the same port and must be disen- tangled; the event handlers must relinquish control to the main loop after processing an event; and the externally imposed definition of events (such as whether depressing a mouse button is the same type of event as releasing one) affects the structure of the overall program.
    [Show full text]
  • Go Language Highlights
    Go language highlights Martin Steffen Nov 25, 2016 1 / 112 Outline 1. Introduction 2. OO structuring & type system 3. Control 4. Concurrency 5. Memory model 6. Conclusion 2 / 112 Introduction 4 / 112 5 / 112 Go sales pitch “language for the 21st century” relatively new language (with some not so new features?) a lot of fanfare & backed by Google no less existing show-case applications docker dropbox . 6 / 112 Go’s stated design principles appealing to C programmers KISS: “keep it simple, stupid” built-in concurrency “strongly typed” efficient fast compilation, appealing for scripting 7 / 112 History of Go first plans around 2007 “IPO”: end of 2009 Precursor languages, resp. inspired by: C CSP / Occam At Bell Labs Squeak, Newsqueak Limbo Alef Erlang, Concurrent ML 8 / 112 Go’s non-revolutionary feature mix imperative object-oriented (?) compiled concurrent (goroutines) “strongishly” typed garbage collected portable higher-order functions and closures 9 / 112 OO structuring & type system (Sub)-typing, OO, polymorphism, and all that “In object-oriented programming, the is-a relationship is totally based on inheritance” – from some random Java tutorial “overriding is dynamic polymorphism” – from the blogosphere (stack exchange) “Subclasses of a class can define their own unique behaviors and yet share some of the same functionality of the parent class. – Oracle’s Java tutorial, section on polymorphism 11 / 112 “Orthodox” view class = type (among other things) inheritance = subtyping polymorphism = subtype polymorphism (= subtyping = inheritance) “Orthodox” accepted as true or correct by most people: supporting or believing what most people think is true accepting and closely following the traditional beliefs and customs of a religion 12 / 112 c l a s s P o i n t { p u b l i c i n t x ; p u b l i c P o i n t ( i n t x ) { t h i s .
    [Show full text]
  • Building Distributed Applications with Inferno and Limbo
    Building Distributed Applications with Inferno and Limbo Phillip Stanley-Marbell [email protected] http://www.ece.cmu.edu/~pstanley Intel Research Pittsburgh Seminar Talk Outline • Terminology, Overview and History • Abstraction and Names: Resources as Names (files) in Inferno • The Limbo Programming Language • Multi-platform applications • Ideas & Summary Intel Research Pittsburgh Seminar 2 Terminology • Inferno • An operating system • Limbo • A programming language for developing applications under Inferno • Dis • Inferno abstracts away the hardware with a virtual machine, the Dis VM • Limbo programs are compiled to bytecode for execution on the Dis VM • Plan 9 • A research operating system, being actively developed at Bell Labs and elsewhere • A direct ancestor of Inferno Intel Research Pittsburgh Seminar 3 Inferno • Runs directly over bare hardware • Intel x86, PowerPC, SPARC, MIPS, ARM, more... • Like any other traditional OS • Also available as an emulator • Runs over many modern operating systems (Windows, Linux, *BSD, Solaris, IRIX, MacOS X) or as a browser plugin in IE under Windows • Emulator provides interface identical to native OS, to both users and applications • Filesystem and other system services, applications, etc. • The emulator virtualizes the entire OS, including filesystem, network stack, graphics subsystem — everything — not just code execution (e.g., in Java Virtual Machine) Intel Research Pittsburgh Seminar 4 Inferno System Architecture Built-in Modules Built-in Modules Mount Device Mount Device Native (i.e.,
    [Show full text]