DOCSLIB.ORG

Regularized Programming with the BOSQUE Language Moving Beyond Structured Programming

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

Regularized Programming with the BOSQUE Language Moving Beyond Structured Programming Mark Marron [email protected] Abstract and compilers/tooling. The first contribution of this paper is The rise of Structured Programming and Abstract Data Types an identification and categorization of unnecessary complex- in the 1970’s represented a major shift in programming lan- ity sources which can be alleviated via thoughtful language guages. These methodologies represented a move away from design (Section 2). a programming model that reflected incidental features of Using the sources of complexity identified in Section 2 the underlying hardware architecture and toward a model as a guide, the second contribution of this paper is the in- that emphasized programmer intent more directly. This shift troduction of the BOSQUE LANGUAGE1 (Section 3). The simultaneously made it easier and less error prone for a de- BOSQUE language demonstrates the feasibility of eliminating veloper to convert their mental model of a system into code these sources of complexity while retaining the expressivity and led to a golden age of compiler and IDE tooling devel- and performance needed for a practical language as well as opment. This paper takes another step on this path by further hinting at opportunities for improved developer productivity lifting the model for iterative processing away from low-level and software quality. loop actions, enriching the language with algebraic data trans- Section 4 goes into detail on how the concepts used in the formation operators, and further simplifying the problem of design of the BOSQUE language represent a larger step in the reasoning about program behavior by removing incidental development of programming languages and models. Thus, ties to a particular computational substrate and indeterminate the third contribution of this paper is the introduction of the behaviors. We believe that, just as structured programming regularized programming model. This model builds on the did years ago, this regularized programming model will lead successes of structured programming and abstract data types to massively improved developer productivity, increased soft- by simplifying existing programming models into a regular- ware quality, and enable a second golden age of developments ized form that eliminates major sources of errors, simplifies in compilers and developer tooling. code understanding and modification, and converts many au- tomated reasoning tasks over code into trivial propositions. 1 Introduction To explore the opportunities that regularized programming enables this paper concludes with three case studies, using The introduction and widespread use of structured program- the ability to precisely analyze the semantics of a program to ming [14] and abstract data types [42] marked a major shift verify correctness, validating SemVer [67] usage, and how the in how programs are developed. Fundamentally, the concepts regularized semantics enable SIMD [34] optimization in sce- and designs introduced by these programming methodologies narios that would be otherwise difficult or impossible. These simplified the reasoning about program behavior by elimi- results demonstrate how the unique properties of regularized nating substantial sources of, usually entirely accidental [8], programming enable the implementation of previously im- complexity. This allowed engineers to focus on the intent practical developer experiences beyond the direct benefits to and core behavior of their code more directly and, as a re- software quality and developer productivity that are possible sult, produced a drastic improvements in software quality and when moving beyond structured programming! ability to construct large software artifacts. Just as accidental complexity is an impediment to human understanding of a 2 Complexity Sources program it is also an impediment to applying formal reasoning techniques. Despite the inability of structured programming Based on a range of experiences and sources including devel- to fully bridge the chasm of formal mathematical analysis, is- oper interviews, personal experience with analysis/runtime/- sues with loop-invariants and mutation-frames among others compiler development, and empirical studies this section iden- prevented the practical use of verification techniques, it did tifies five major sources of accidental complexity that canbe provide the needed simplifications to enable reasoning about addressed via thoughtful language design. These are sources limited forms of program behavior and supported a golden of various of bug families, increase the effort required for a age of IDE tooling and compiler development [34, 54]. developer to reason about and implement functionality in an Drawing inspiration from these successes, this paper seeks to identify additional opportunities to eliminate complexity 1The BOSQUE specification, parser, type checker, reference interpreter, with the intent that these simplifications will lead to simi- and IDE support are open-sourced and available at https://github.com/ lar advances in software quality, programmer productivity, Microsoft/BosqueLanguage. application, and greatly complicate (or make it infeasible to) the number of details that must be tracked and restored can automatically reason about a program. increase drastically increasing opportunities for mistakes and oversights to occur. Section 4.1 shows how the BOSQUE lan- Mutable State and Frames: Mutable state is a deeply com- guage eliminates this problem through the introduction of plicated concept to model and reason about. The introduction algebraic bulk data operators. of mutability into a programming language destroys the abil- ity to reason about the application in a monotone [56] manner Equality and Aliasing: Programming languages live at the which forces the programmer (and any analysis tools) to iden- boundary of mathematics and engineering. Although lan- tify which facts remain true after an operation and which are guage semantics are formulated as a mathematical concept invalidated. The ability for mutable code to affect the state there are common cases, e.g. reference equality, pass by-value of the application via both return values and side affects on vs. by-reference, or evaluation orders, that expose and favor arguments (or other global state) also introduces the need to one particular hardware substrate, generally a Von Neumann reason about the logical frame [47, 64] of every operation. architecture, either intentionally for performance or acciden- Section 4.1 examines how the BOSQUE language eliminates tally by habit or history. While seemingly minor these choices this source of complexity through the use of immutable data have a major impact on comprehensibility – merely expos- representation. ing reference equality pulls in the complexity of reasoning Loops, Recursion, and Invariants: Loops and recursion about aliasing relations and greatly complicates compilation represent a fundamental challenge to reasoning as the code on other architectures. Section 4.3 shows how the BOSQUE describes the effects of a single step but understanding the language eliminates reference equality and, as a consequence, full construct requires generalization to a quantified property eliminates the complexity of aliasing questions and by-value over a set of values. Invariants [19, 27] provide the needed vs. by-ref argument passing issues. connection but a generalized technique for their computation is, of course, impossible in general and has proved elusive 3 BOSQUE Language Overview even for restricted applications. Section 4.5 examines how The BOSQUE language derives from a combination of Type- BOSQUE handles the invariant problem by eliminating loops Script [72] inspired syntax and types plus ML [52] and Node/ and restricting recursion. JavaScript [31, 58] inspired semantics. This section provides the syntax and operators of the BOSQUE language with an Indeterminate Behaviors: Indeterminate behaviors, includ- emphasis on features of the language that are not widely seen ing undefined, under specified, or non-deterministic or envi- ronmental behavior, require a programmer or analysis tool to in other programming languages. Section 4 focuses on how reason about and account for all possible outcomes. While these features and design choices address various sources of truly undefined behavior, e.g. uninitialized variables, has dis- complexity enumerated in Section 2. appeared from most languages there is a large class of under- 3.1 BOSQUE Type System specified behavior, e.g. sort stability, map/dictionary enumer- ation order, etc., that remains. These increase the complexity The BOSQUE language supports a simple and non-opinionated of the development process and, as time goes on, are slowly type system that allows developers to use a range of struc- being seen as liabilities that should be removed [9]. Less tural, nominal, and combination types to best convey their obviously the inclusion of non-deterministic and/or environ- intent and flexibly encode the relevant features of the problem mental interaction results in code that cannot be reliably tested domain. (flakey tests), behaves differently for non-obvious reasons, Nominal Type System: The nominal type system is a mostly and frequently mixes failure logic widely through a codebase. standard object-oriented design with parametric polymor- Section 4.2 explains how BOSQUE eliminates these sources phism provided by generics. Users can define abstract types, of complexity
Recommended publications
  • Ironpython in Action

    Ironpython in Action

    IronPytho IN ACTION Michael J. Foord Christian Muirhead FOREWORD BY JIM HUGUNIN MANNING IronPython in Action Download at Boykma.Com Licensed to Deborah Christiansen <[email protected]> Download at Boykma.Com Licensed to Deborah Christiansen <[email protected]> IronPython in Action MICHAEL J. FOORD CHRISTIAN MUIRHEAD MANNING Greenwich (74° w. long.) Download at Boykma.Com Licensed to Deborah Christiansen <[email protected]> For online information and ordering of this and other Manning books, please visit www.manning.com. The publisher offers discounts on this book when ordered in quantity. For more information, please contact Special Sales Department Manning Publications Co. Sound View Court 3B fax: (609) 877-8256 Greenwich, CT 06830 email: [email protected] ©2009 by Manning Publications Co. All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by means electronic, mechanical, photocopying, or otherwise, without prior written permission of the publisher. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in the book, and Manning Publications was aware of a trademark claim, the designations have been printed in initial caps or all caps. Recognizing the importance of preserving what has been written, it is Manning’s policy to have the books we publish printed on acid-free paper, and we exert our best efforts to that end. Recognizing also our responsibility to conserve the resources of our planet, Manning books are printed on paper that is at least 15% recycled and processed without the use of elemental chlorine.
  • Thriving in a Crowded and Changing World: C++ 2006–2020

    Thriving in a Crowded and Changing World: C++ 2006–2020

    Thriving in a Crowded and Changing World: C++ 2006–2020 BJARNE STROUSTRUP, Morgan Stanley and Columbia University, USA Shepherd: Yannis Smaragdakis, University of Athens, Greece By 2006, C++ had been in widespread industrial use for 20 years. It contained parts that had survived unchanged since introduced into C in the early 1970s as well as features that were novel in the early 2000s. From 2006 to 2020, the C++ developer community grew from about 3 million to about 4.5 million. It was a period where new programming models emerged, hardware architectures evolved, new application domains gained massive importance, and quite a few well-financed and professionally marketed languages fought for dominance. How did C++ ś an older language without serious commercial backing ś manage to thrive in the face of all that? This paper focuses on the major changes to the ISO C++ standard for the 2011, 2014, 2017, and 2020 revisions. The standard library is about 3/4 of the C++20 standard, but this paper’s primary focus is on language features and the programming techniques they support. The paper contains long lists of features documenting the growth of C++. Significant technical points are discussed and illustrated with short code fragments. In addition, it presents some failed proposals and the discussions that led to their failure. It offers a perspective on the bewildering flow of facts and features across the years. The emphasis is on the ideas, people, and processes that shaped the language. Themes include efforts to preserve the essence of C++ through evolutionary changes, to simplify itsuse,to improve support for generic programming, to better support compile-time programming, to extend support for concurrency and parallel programming, and to maintain stable support for decades’ old code.
  • Introduction to Groovy and Grails

    Introduction to Groovy and Grails

    Introduction to Groovy and Grails Mohamed Seifeddine November 25, 2009 1 Contents 1 Foreword 5 2 Introduction to Groovy 7 3 Getting started 9 3.1 Installing Groovy . .9 3.1.1 JDK - A Prerequisite . .9 3.1.2 Installing Groovy . .9 3.2 Updating Groovy . 10 3.3 Editors for Groovy and Grails . 10 3.4 groovysh, groovyConsole & groovy . 10 4 Boolean Evaluation, Elvis Operator & the Safe Navigation Op- erator 13 4.1 Elvis Operator . 15 4.2 Safe Navigation Operator . 15 5 String & GString 19 6 Classes, Dynamic type, Methods, Closures the & Meta-Object Protocol 21 6.1 Dynamic type . 25 6.2 Closure . 29 6.2.1 Create . 29 6.2.2 Call . 30 6.2.3 Getting Information . 33 6.2.4 Method Reference Pointer . 33 6.3 More on Methods . 35 6.3.1 Optional Parantheses . 35 6.3.2 Positional Parameters . 35 6.3.3 Optional Parameters . 36 6.3.4 Mapped Parameters . 37 6.3.5 Dynamic Method Call . 37 6.4 Meta-Object Protocol . 39 6.4.1 Adding Methods & Properties . 39 6.4.2 Add Constructor . 41 6.4.3 Intercepting Method Calls . 41 6.4.4 Getting Information . 42 7 Collections (List, Range, Map) and Iterative Object Methods 47 7.1 List . 47 7.2 Range . 50 7.3 Map . 52 8 Other 55 8.1 Groovy Switch . 55 8.2 Groovy SQL . 56 8.3 File . 58 8.4 Exception Handling . 60 2 8.5 Other . 60 9 Introduction to Grails 61 10 Getting Started 63 10.1 Installing Grails .
  • TARDIS: Affordable Time-Travel Debugging in Managed Runtimes

    TARDIS: Affordable Time-Travel Debugging in Managed Runtimes

    TARDIS: Affordable Time-Travel Debugging in Managed Runtimes Earl T. Barr Mark Marron University College London Microsoft Research [email protected] [email protected] Abstract 1. Introduction Developers who set a breakpoint a few statements too late or Developers spend a great deal of time debugging. Skilled de- who are trying to diagnose a subtle bug from a single core velopers apply the scientific method: they observe a buggy dump often wish for a time-traveling debugger. The ability program’s behavior on different inputs, first to reproduce the to rewind time to see the exact sequence of statements and bug, then to localize the bug in the program’s source. Re- program values leading to an error has great intuitive appeal producing, localizing, then fixing a bug involves forming but, due to large time and space overheads, time-traveling and validating hypotheses about the bug’s root cause, the debuggers have seen limited adoption. first point at which the program’s state diverges from the in- A managed runtime, such as the Java JVM or a JavaScript tended state. To validate a hypothesis, a developer must halt engine, has already paid much of the cost of providing core program execution and examine its state. Especially early in features — type safety, memory management, and virtual debugging, when the developer’s quarry is still elusive, she IO — that can be reused to implement a low overhead time- will often halt execution too soon or too late to validate her traveling debugger. We leverage this insight to design and current hypothesis.
  • Cornell CS6480 Lecture 3 Dafny Robbert Van Renesse Review All States

    Cornell CS6480 Lecture 3 Dafny Robbert Van Renesse Review All States

    Cornell CS6480 Lecture 3 Dafny Robbert van Renesse Review All states Reachable Ini2al states states Target states Review • Behavior: infinite sequence of states • Specificaon: characterizes all possible/desired behaviors • Consists of conjunc2on of • State predicate for the inial states • Acon predicate characterizing steps • Fairness formula for liveness • TLA+ formulas are temporal formulas invariant to stuering • Allows TLA+ specs to be part of an overall system Introduction to Dafny What’s Dafny? • An imperave programming language • A (mostly funconal) specificaon language • A compiler • A verifier Dafny programs rule out • Run2me errors: • Divide by zero • Array index out of bounds • Null reference • Infinite loops or recursion • Implementa2ons that do not sa2sfy the specifica2ons • But it’s up to you to get the laFer correct Example 1a: Abs() method Abs(x: int) returns (x': int) ensures x' >= 0 { x' := if x < 0 then -x else x; } method Main() { var x := Abs(-3); assert x >= 0; print x, "\n"; } Example 1b: Abs() method Abs(x: int) returns (x': int) ensures x' >= 0 { x' := 10; } method Main() { var x := Abs(-3); assert x >= 0; print x, "\n"; } Example 1c: Abs() method Abs(x: int) returns (x': int) ensures x' >= 0 ensures if x < 0 then x' == -x else x' == x { x' := 10; } method Main() { var x := Abs(-3); print x, "\n"; } Example 1d: Abs() method Abs(x: int) returns (x': int) ensures x' >= 0 ensures if x < 0 then x' == -x else x' == x { if x < 0 { x' := -x; } else { x' := x; } } Example 1e: Abs() method Abs(x: int) returns (x': int) ensures
  • Neufuzz: Efficient Fuzzing with Deep Neural Network

    Neufuzz: Efficient Fuzzing with Deep Neural Network

    Received January 15, 2019, accepted February 6, 2019, date of current version April 2, 2019. Digital Object Identifier 10.1109/ACCESS.2019.2903291 NeuFuzz: Efficient Fuzzing With Deep Neural Network YUNCHAO WANG , ZEHUI WU, QIANG WEI, AND QINGXIAN WANG China National Digital Switching System Engineering and Technological Research Center, Zhengzhou 450000, China Corresponding author: Qiang Wei ([email protected]) This work was supported by National Key R&D Program of China under Grant 2017YFB0802901. ABSTRACT Coverage-guided graybox fuzzing is one of the most popular and effective techniques for discovering vulnerabilities due to its nature of high speed and scalability. However, the existing techniques generally focus on code coverage but not on vulnerable code. These techniques aim to cover as many paths as possible rather than to explore paths that are more likely to be vulnerable. When selecting the seeds to test, the existing fuzzers usually treat all seed inputs equally, ignoring the fact that paths exercised by different seed inputs are not equally vulnerable. This results in wasting time testing uninteresting paths rather than vulnerable paths, thus reducing the efficiency of vulnerability detection. In this paper, we present a solution, NeuFuzz, using the deep neural network to guide intelligent seed selection during graybox fuzzing to alleviate the aforementioned limitation. In particular, the deep neural network is used to learn the hidden vulnerability pattern from a large number of vulnerable and clean program paths to train a prediction model to classify whether paths are vulnerable. The fuzzer then prioritizes seed inputs that are capable of covering the likely to be vulnerable paths and assigns more mutation energy (i.e., the number of inputs to be generated) to these seeds.
  • Sindarin: a Versatile Scripting API for the Pharo Debugger

    Sindarin: a Versatile Scripting API for the Pharo Debugger

    Sindarin: A Versatile Scripting API for the Pharo Debugger Thomas Dupriez Guillermo Polito Steven Costiou Univ. Lille, CNRS, Centrale Lille, CNRS - UMR 9189 - CRIStAL, Univ. Inria, Univ. Lille, CNRS, Centrale Inria, UMR 9189 - CRIStAL Lille, Centrale Lille, Inria Lille, UMR 9189 - CRIStAL France France France [email protected] [email protected] [email protected] Vincent Aranega Stéphane Ducasse Univ. Lille, CNRS, Centrale Lille, Inria, Univ. Lille, CNRS, Centrale Inria, UMR 9189 - CRIStAL Lille, UMR 9189 - CRIStAL France France [email protected] [email protected] Abstract Studies and work on debugging acknowledge that main- Debugging is one of the most important and time consuming stream debuggers are not well adapted to several debugging activities in software maintenance, yet mainstream debuggers scenarios [3, 27, 31]. This has led to the appearance of new de- are not well-adapted to several debugging scenarios. This bugging techniques proposing to augment traditional interac- has led to the research of new techniques covering specific tive debuggers with, e.g., stateful breakpoints [4], control-flow families of complex bugs. Notably, recent research proposes aware breakpoints [5], object-centric breakpoints [10, 34], the to empower developers with scripting DSLs, plugin-based and automatic insertion of breakpoints based on dynamic execu- moldable debuggers. However, these solutions are tailored to tions [45], or declarative statements from the developer [21]. specific use-cases, or too costly for one-time-use scenarios. A line of research has also started to study scripting APIs to In this paper we argue that exposing a debugging scripting empower developers to implement debugging scripts adapted interface in mainstream debuggers helps in solving many chal- to their needs.
  • Intel® Software Guard Extensions: Data Center Attestation Primitives

    Intel® Software Guard Extensions: Data Center Attestation Primitives

    Intel® Software Guard Extensions Data Center Attestation Primitives Installation Guide For Windows* OS Revision <1.0> <3/10/2020> Table of Contents Introduction .......................................................................................................................... 3 Components – Detailed Description ....................................................................................... 4 Platform Configuration .......................................................................................................... 6 Windows* Server OS Support ................................................................................................. 7 Installation Instructions ......................................................................................................... 8 Windows* Server 2016 LTSC ................................................................................................................. 8 Downloading the Software ........................................................................................................................... 8 Installation .................................................................................................................................................... 8 Windows* Server 2019 Installation ....................................................................................................... 9 Downloading the Software ........................................................................................................................... 9 Installation
  • Fine-Grained Energy Profiling for Power-Aware Application Design

    Fine-Grained Energy Profiling for Power-Aware Application Design

    Fine-Grained Energy Profiling for Power-Aware Application Design Aman Kansal Feng Zhao Microsoft Research Microsoft Research One Microsoft Way, Redmond, WA One Microsoft Way, Redmond, WA [email protected] [email protected] ABSTRACT changing from double precision to single), or quality of service pro- Significant opportunities for power optimization exist at applica- vided [10]. Third, energy usage at the application layer may be tion design stage and are not yet fully exploited by system and ap- made dynamic [8]. For instance, an application hosted in a data plication designers. We describe the challenges developers face in center may decide to turn off certain low utility features if the en- optimizing software for energy efficiency by exploiting application- ergy budget is being exceeded, and an application on a mobile de- level knowledge. To address these challenges, we propose the de- vice may reduce its display quality [11] when battery is low. This velopment of automated tools that profile the energy usage of vari- is different from system layer techniques that may have to throttle ous resource components used by an application and guide the de- the throughput resulting in users being denied service. sign choices accordingly. We use a preliminary version of a tool While many application specific energy optimizations have been we have developed to demonstrate how automated energy profiling researched, there is a lack of generic tools that a developer may use helps a developer choose between alternative designs in the energy- at design time. Application specific optimizations require signif- performance trade-off space. icant development effort and are often only applicable to specific scenarios.
  • Perception and Effects of Implementing Kotlin in Existing Projects

    Perception and Effects of Implementing Kotlin in Existing Projects

    Bachelor thesis Undergraduate level Perception and effects of implementing Kotlin in existing projects A case study about language adoption Author: Emil Sundin Supervisor: Wei Song Examiner: Azadeh Sarkheyli Discipline: Informatics Course: IK2017 Credit: 15 credits Examination date: 2018-05-25 Dalarna University provides the opportunity for publishing the thesis through DiVA as Open Access. This means that the thesis work will become freely available to read and download through their portal. Dalarna University encourages students as well as researchers to publish their work in the Open Access format. We approve the publishing of this thesis work under the Open Access format: Yes ☒ No ☐ Dalarna University – SE-791 88 Falun – Phone +4623-77 80 00 Abstract The Kotlin programming language has seen an increase of adoption since its launch in 2011. In late 2017 Google announced first-class support for Kotlin on the Android platform which further popularized the language. With this increase in popularity we felt it was interesting to investigate how Kotlin affects the developer experience. We performed a case study to see how Java developers perceive the Kotlin language, and how it meets the requirements of these developers. To gather the developer requirements and their perception of Kotlin we performed two sets of interviews and rewrote parts of their codebase. The first set of interviews identified developer requirements and the second set of interviews showcased the Kotlin language and its potential use in their codebase. The results show that Kotlin can meet most of the developer requirements and that the perception of Kotlin is positive. Kotlin’s ability to be incrementally adopted was a prominent feature which reduced the inherent risks of technology adoption while providing them the ability to further evaluate the language.
  • Groovy and Java: a Comparison Groovy’S Resemblance to Java Is Often Quite Striking

    Groovy and Java: a Comparison Groovy’S Resemblance to Java Is Often Quite Striking

    APPENDIX ■ ■ ■ The Groovy Language Groovy is an all-purpose programming language for the JVM. It was born in 2003 when James Strachan and Bob McWhirter founded the Groovy project with the goal of creating a glue lan- guage to easily combine existing frameworks and components. Groovy is a language that aims to bring the expressiveness of languages such as Ruby, Lisp, and Python to the Java platform while still remaining Java friendly. It attracted much excitement with these ambitious goals, because the majority of other scripting languages on the Java platform either used an entirely alien syntax and APIs or were simply Java without the need to specify types. Despite its youth, Groovy is a stable, feature-rich language that forms the perfect base for Grails. This is a fantastic achievement, given the limited resources available to an open source project such as Groovy. Groovy was an obvious choice as a platform for the Grails framework, because it provides the necessary underlying infrastructure to create the diverse range of miniature domain-specific languages utilized throughout Grails. ■Note Martin Fowler has written an excellent article about domain-specific languages: http://www.mar- tinfowler.com/bliki/DomainSpecificLanguage.html. What does this mean? Well, the syntax you see used throughout the book has often been magically enhanced and shortened by using a combination of Groovy’s already concise syntax and its support for metaprogramming. Groovy performs a lot of magic under the covers, abstracted away from the developer. This removes the burden from the programmer who would otherwise be required to write reams of unnecessary, repetitive code.
  • 451 Angular CLI, 77, 412 Component, 89 Detection, 398–399 Http Client, 320–321 Module System, 119 Deployment, 130 Ex100

    451 Angular CLI, 77, 412 Component, 89 Detection, 398–399 Http Client, 320–321 Module System, 119 Deployment, 130 Ex100

    Index A AngularJS vs. Angular Angular JavaScript using JavaScript CLI, 77, 412 engines, 18 component, 89 platform, 17 detection, 398–399 semantic versioning, 16–17 Http client, 320–321 shims and polyfills, 18 module system, 119 controllers and components, 22 deployment, 130 dependency and constructor ex100, 123–126, 128–129 injection, 22–23 feature module, 122–123 forms, 24 Node commands, 131 modules, 21 root module, 121 module system, 116 routing module, 122 scope, controllers, and components, 24 shared module, 123 templates, 25 Start project, 120–121 Annotations, 91 pipes app.component.spec.ts, 412 combining date formats, 388 Application component, 89 currency, 386 Asynchronous data streams date, 386 event-based reactive programs, 291 json, 388 observable sequences, 292 lowercase, 385 observers, 292–294 percentage, 386 operators predefined date formats, 387 buffer, 300 shortdate, 386 debounce, 302–303 UK pound currency, 386 distinct, 304 uppercase, 385 filter, 304 variety of, 388, 390 from, 298 uses observables, 310 interval, 298 451 © Mark Clow 2018 M. Clow, Angular 5 Projects, https://doi.org/10.1007/978-1-4842-3279-8 INDEX Asynchronous data streams (cont.) Command line interface (CLI) map, 301 bootstrapping, 84–85 of (Was just), 299 compilation, 86 range, 299 compile errors, 82 repeat, 299 creating project, 78–79 scan, 301 file watcher and web server, 84 share, 306–307 modifying project, 81 take, 305 options, 85 timer, 300 root folder, 80 subscription, 295 runtime errors, 82 Asynchronous JavaScript and XML (AJAX) source code, 80 callbacks, 6 Component(s) encoding, 7–8 child, 159–160 HAL and HATEOAS, 8–10 class, 97 JSON and XML, 5 class life cycle promises, 6 constructor vs.