Reactive Internet Programming

Franck Barbier

Description

Is Internet software so different from “ordinary” software? This book practically answers this question through the presentation of a software design method based on the State Chart XML W3C standard along with Java. Web enterprise, Internet-of-Things, and Android applications, in particular, are seamlessly specified and implemented from “executable models.”

Internet software puts forward the idea of event-driven or reactive programming, as pointed out in Bonér et al.’s “Reactive Manifesto” (http://www.reactivemanifesto.org). It tells us that reactiveness is a must. However, beyond concepts, software engineers require effective means with which to put reactive programming into practice. This book’s purpose is to outline and explain such means.

The lack of professional examples in the literature that illustrate how reactive software should be shaped can be quite frustrating. Therefore, this book helps to fill in that gap by providing in-depth professional case studies that contain comprehensive details and meaningful alternatives. Furthermore, these case studies can be downloaded for further investigation.

Internet software requires higher adaptation, at run time in particular. After reading Reactive Internet Programming, the reader therefore will be ready to enter the forthcoming Internet era.

Table of Contents: 1. Introduction / 2. Event and State-based Modeling and Programming / 3. Applying State Chart XML / 4. Programming State Chart XML Models / 5. Execution Semantics / 6. Advanced Programming with PauWare engine / 7. Programming the "Internet of Things" / 8. Programming Web Enterprise Component Management / 9. Software Component Management / Appendix A. Internal Structure of PauWare Engine / Appendix B. Acronyms / Appendix C. Software / References / Author's Biography

Sujets

• Software Development
• Computers
• Informatique
• Internet of Things
• Web application
• Engineering

Informations

• Publié par: Association for Computing Machinery and Morgan & Claypool Publishers
• Date de parution: 01 avril 2016
• Nombre de lectures: 0
• EAN13: 9781970001785
• Langue: English

Extrait

Reactive Internet Programming
ACM Books
Editor in Chief
M. Tamer zsu, University of Waterloo
ACM Books is a new series of high-quality books for the computer science community, published by ACM in collaboration with Morgan Claypool Publishers. ACM Books publications are widely distributed in both print and digital formats through booksellers and to libraries (and library consortia) and individual ACM members via the ACM Digital Library platform.
Reactive Internet Programming: State Chart XML in Action
Franck Barbier, University of Pau, France
2016
Verified Functional Programming in Agda
Aaron Stump, The University of Iowa
2016
The VR Book: Human-Centered Design for Virtual Reality
Jason Jerald, NextGen Interactions
2016
Ada s Legacy
Robin Hammerman, Stevens Institute of Technology; Andrew L. Russell, Stevens Institute of Technology
2016
Edmund Berkeley and the Social Responsibility of Computer Professionals
Bernadette Longo, New Jersey Institute of Technology
2015
Candidate Multilinear Maps
Sanjam Garg, University of California, Berkeley
2015
Smarter than Their Machines: Oral Histories of Pioneers in Interactive Computing
John Cullinane, Northeastern University; Mossavar-Rahmani Center for Business
and Government, John F. Kennedy School of Government, Harvard University
2015
A Framework for Scientific Discovery through Video Games
Seth Cooper, University of Washington
2014
Trust Extension as a Mechanism for Secure Code Execution on Commodity Computers
Bryan Jeffrey Parno, Microsoft Research
2014
Embracing Interference in Wireless Systems
Shyamnath Gollakota, University of Washington
2014
Reactive Internet Programming
State Chart XML in Action
Franck Barbier
University of Pau, France
ACM Books 10
Copyright 2016 by the Association for Computing Machinery and Morgan Claypool Publishers
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, photocopy, recording, or any other except for brief quotations in printed reviews-without the prior permission of the publisher.
Designations used by companies to distinguish their products are often claimed as trademarks or registered trademarks. In all instances in which Morgan Claypool is aware of a claim, the product names appear in initial capital or all capital letters. Readers, however, should contact the appropriate companies for more complete information regarding trademarks and registration.
Reactive Internet Programming: State Chart XML in Action
Franck Barbier
books.acm.org
www.morganclaypool.com
ISBN: 978-1-97000-179-2 hardcover
ISBN: 978-1-97000-176-1 paperback
ISBN: 978-1-97000-177-8 ebook
ISBN: 978-1-97000-178-5 ePub
Series ISSN: 2374-6769 print 2374-6777 electronic
DOIs: 10.1145/2872585 Book
10.1145/2872585.2872586 Preface
10.1145/2872585.2872587 Chapter 1
10.1145/2872585.2872588 Chapter 2
10.1145/2872585.2872589 Chapter 3
10.1145/2872585.2872590 Chapter 4
10.1145/2872585.2872591 Chapter 5
10.1145/2872585.2872592 Chapter 6
10.1145/2872585.2872593 Chapter 7
10.1145/2872585.2872594 Chapter 8
10.1145/2872585.2872595 Chapter 9
10.1145/2872585.2872596 Appendixes
10.1145/2872585.2872597 References
A publication in the ACM Books series, 10
Editor in Chief: M. Tamer zsu, University of Waterloo
Area Editor: Bashar Nuseibeh, The Open University
First Edition
10 9 8 7 6 5 4 3 2 1
To Cabu, Wolinski, Tignous, Oncle Bernard, Charb, and Honor
In memory of those murdered in the Paris attacks on November 13, 2015 .
Contents
Preface
Advice for the Reader
Vocabulary
Stylistic Conventions
Chapter 1 Introduction
1.1 Software Engineering in the Internet Era
1.2 Expected Benefits of Model-driven Software Development
1.3 Programming with Events and States
1.4 Model Execution or Interpretation
1.5 Architectural Issues of Internet Programming
Chapter 2 Event and State-based Modeling and Programming
2.1 States are Universal and Everywhere
2.2 States are Abstract and Discrete
2.3 Event as Dual Notion of State
2.4 Harel s Statecharts
2.5 Discovering State Chart XML
2.6 Statechart Execution
Chapter 3 Applying State Chart XML
3.1 Startup of Barbados Crisis Management System
3.2 Business Case: Route Negotiation
3.3 Timing Constraints
3.4 Introduction to the Run-to-completion Execution Mode
3.5 Variations on Modeling: The Power of Statecharts
3.6 Evaluation
Chapter 4 Programming State Chart XML Models
4.1 Programming My device
4.2 Setup of Entry and Exit Actions
4.3 Setup of Activities
4.4 Sending Events Internally
4.5 Action Parameters
4.6 State Machine Kick-off
4.7 State Machine Shutdown
4.8 State Machine Tracing
4.9 Transition Programming
4.10 Guard Programming
4.11 Event Processing
4.12 Communication Programming
Chapter 5 Execution Semantics
5.1 Example of Execution Semantics Potential Defects
5.2 Run-to-Completion Cycles
5.3 Action and Activity Execution Sequencing
5.4 Execution Sequencing and Orthogonality
5.5 Execution Sequencing and Nesting
5.6 Event Consumption Principle
5.7 Deferred Events
5.8 Transition Conflicts
Chapter 6 Advanced Programming with PauWare engine
6.1 Completion Transitions
6.2 Timer Services
6.3 State and Event Naming
6.4 Single Nesting
6.5 The Notion of internal transition in State Chart XML
6.6 Allowed Events at Large
6.7 Unicast vs. Multicast Calls/Communications
6.8 Cached Transitions vs. Contextual Transitions
6.9 Data Consistency Checking through State Invariants
6.10 History Facilities
6.11 Concurrency
Chapter 7 Programming the Internet of Things
7.1 Characterization of Internet of Things Applications
7.2 Application Requirements (Home Automation System)
7.3 Analysis
7.4 Design
7.5 Implementation Issues
Chapter 8 Programming Web Enterprise Applications
8.1 Characterization of Web Enterprise Applications
8.2 Application Requirements (Railcar Control System)
8.3 Analysis
8.4 Design
8.5 Implementation Issues
Chapter 9 Software Component Management
9.1 Dynamical (Re)configuration
9.2 Extended Management Framework
9.3 Pushing State Machine Data Outside
Appendix A Internal Structure of PauWare Engine
A.1 Organization of a State Machine s States in Memory
A.2 Organization of a State Machine s Transitions in Memory
Appendix B Acronyms
Appendix C Downloadable Software Resources
References
Author s Biography
Preface
During the many years I spent on programming practice with BASIC, COBOL, Pascal, C, COBOL, Fortran, Lisp, etc., I kept getting the feeling that creating software was a constant battle composed of the same steps: frequent testing, debugging, optimizing, etc. Current popular senior languages evolved in complexity (Ada, C++, Java, C , etc.) through richer mechanisms (one language inspired another by copying features) and libraries while newer ones emerged without these complicated mechanisms. Languages that come later are then declared more intuitive and thus simple and productive (e.g., Python, Groovy, Ruby, etc.). Choosing a language is above all a matter of culture, pleasure, and, of course, productivity anticipation. Over time, languages become equipped with some machinery aligned with the way technologies and users are willing to view software applications. Roughly speaking, the role of programming languages is small in light of the challenges raised by programming Internet applications. Therefore, it is difficult to consider a given language as having a definitive competitive advantage.
Moreover, applications also evolve in complexity through, for instance, multimedia data (images, sounds, movies, etc.), sophisticated graphical user interfaces, or innovative architectural styles-the ones imposed by Internet computing especially. Is Internet software so different from classical software? The question remains unanswered as long as developers do not observe radical changes in their daily work. In all honesty, at the moment, there is no super revolution in software development despite the Internet computing new deal endlessly repeated in blogs, papers, speeches, etc., and even in this book!
However, Internet software increases exponentially without planned wiring. In other words, Internet software flows out in a totally uncontrolled way into things : from chips to tiny devices (e.g., meters), appliances (e.g., TVs), robots, vehicles (e.g., in the air, in space, under water, on roads, etc.), and industrial machines (e.g., smartgrids, plants, etc.), not to mention computers (e.g., smartphones, tablets, desktops, servers, etc.). How then is it possible for Internet software parts to meet to create the digital economy and society in a consistent way?
Consider the example of a pedestrian and a driver on the way to their respective jobs. The latter will not crush the former thanks to a traffic light. The former will not indefinitely block the latter thanks to a call button at the traffic light base. Both have states (e.g., Waiting for the green light ) and react to events ( Red, stop! ). They are able to synchronize (due to their intrinsic asynchronous behaviors) even though they just met that morning at a pedestrian crossing. Just as pedestrians, drivers, and others make up human society, so too must Internet software applications meet, after being fabricated and put into production, in a deferred way from the same logic. From an engineering viewpoint, this means that applications embedded in things and distributed across systems must be designed to synchronize in a more or less transparent way. Technically speaking, the question is then: What are the software development methods and application shapes for creating adaptability and reactivity?
For a long time, Internet computing has already gone toward this direction with recognized design principles (e.g., event-driven, message-driven, nonbl