Service-Oriented Computing and System Integration: Software, IoT, Big Data, and AI as Services (Seventh Edition)
Yinong Chen, Arizona State University
Kendall Hunt Publishing, 2020.
PAK ISBN: 978-1-7924-3088-6, Text alone ISBN: 978-1-7924-3089-3
Table of Contents in PDF,  Link to Publisher's site of the book , Link to the Sixth Edition , - Link to the Fifth Edition , - Third Edition, - Second Edition, - First Edition

Service-Oriented Computing (SOC), web software development, cloud computing, big data processing, and artificial intelligence represent the modern software engineering theories, practices, and technologies, which have reshaped the world in all aspects. The amount of the data is not the key. The relationship among all data and the meaning behind the data are the key. Efficiently finding the connections of all related data and using these connections to make intelligent decisions become possible after the maturity of these cutting-edge theories, practices, and technologies. The goals of the book are to introduce and exercise these cutting-edge theories, practices, and technologies through lectures and assignments based on the lectures.

The text takes a comprehensive and coherent approach to studying the latest service-oriented architecture, distributed computing paradigm, and distributed software development and system integration technologies. The goal is to learn the concepts, principles, methods, development frameworks, and their applications. The methodology is learning by developing examples. In the service development part, we assume that students have good knowledge in object-oriented computing, such as C++, C#, Java, or Python. Students learn to build services through class definition, interface specification, the association between class methods and service operations, service deployment, and service hosting. In the system integration part, we assume that students have a basic understanding of software architecture through a general software engineering course. We take an architecture-driven approach to help students create the working solution step-by-step from their architecture design. The first step is to design the architecture, which includes the major components and the interconnection. The next step is to define the interfaces among the components using the standard data types. Finally, the behavior of each component is linked to remote services or local objects. The elaborated architecture is automatically translated into the executable.

The text consists of 12 chapters and 3 appendices. They are organized into three parts. Each part can be taught as a separate course, even though they are intrinsically related to the central goals and objectives of the book.


Part I: Distributed Service-Oriented Software Development and Web Data Management

Chapter 1    Introduction to Distributed Service-Oriented Computing

Chapter 2           Distributed Computing with Multithreading 

Chapter 3    Essentials in Service-Oriented Software Development

Chapter 4    XML and Web Data Formats

Chapter 5    Web Application and State Management

Chapter 6    Dependability of Service-Oriented Software


Part II: Advanced Service-Oriented Computing and System Integration

Chapter 7    Advanced Services and Architecture-Driven Application Development

Chapter 8    Enterprise Software Development and Integration

Chapter 9    IoT, Robotics, and Device Integration via Visual Programming

Chapter 10  Interfacing Service-Oriented Software with Databases

Chapter 11 Big Data Processing and Cloud Computing

Chapter 12 Artificial Intelligence and Machine Learning


Part III: Appendices: Tutorials on Service-Oriented System Development

Appendix A       Web Application Development

Appendix B Visual IoT/Robotics Programming Language Environment

Appendix C ASU Repository of Services and Applications

Part I includes the first six chapters, which can be used for a distributed computing, service-oriented computing, or web software development course at the junior, senior or graduate level of universities. This part emphasizes the computing paradigm, data representation, state management, and programming languages based SOC software development. It introduces fundamental concepts and principles, in addition to technologies and tools, which are not being taught in traditional software engineering courses.

Chapter 1 gives an overview and explains fundamental concepts of distributed software architecture, design patterns, distributed computing, service-oriented architecture, and enterprise software architecture. The connections and distinctions between object orientation and service orientation are discussed in detail.

Chapter 2 studies parallel computing in multithreading. It discusses threading, synchronization, coordination, event-driven programming, and performance of parallel computing under multicore computers.

Chapter 3 introduces the essential concepts and techniques in service-oriented architecture, particularly the three-party model of service-oriented software development: Service providers, service brokers, and service consumers. Service interfaces, service communication protocols, and service hosting are keys for supporting this new computing paradigm.

Chapter 4 discusses XML and related technologies, which are used almost everywhere in service-oriented software development. XML is used for representing data, interface, standards, protocols, and even the execution process definition. This chapter studies not only XML representations, but also XML processing and transforming.

Chapter 5 is a longer chapter and comprises application logic, data and state management, and presentation design. It involves application building based on architecture design using existing services and components, stateful web application development using different state management techniques, including view state, session state, application state, file management, and web caching. At the presentation layer, it discusses dynamic graphics generation, animation, and phone app development.

Chapter 6 deals with the dependability issues in web-based applications, including access control through Forms security, encryption and decryption applications, and Secure Sockets Layer in web communication. The chapter also discusses the reliability issues in web application design and particularly in web communication.

Part II includes the next six chapters. These chapters are built on the basic concepts and principles discussed in Part I, yet they do not rely on the details of the first six chapters. This part emphasizes software and system composition and integration using existing services and components. It is based on an architecture-driven approach, workflow, higher-level data management, and message-based integration. The material is good for an advanced software engineering, software integration, or system integration course at the senior or graduate level of universities.

Chapter 7 starts with reviewing service-oriented computing and service development covered in Part I. Then the chapter moves on to discuss more advanced service development that supports self-hosting and asynchronous communications. It also presents more detail in RESTful service development that has been briefly discussed in Part I, as well microservices. Finally, the chapter moves on to advanced web application development in HTML5, MVC, and .Net Core architecture development.

Chapter 8 starts with workflow-based software development and Workflow Foundation that supports architecture-driven software development. It uses examples and case studies to demonstrate software development by drawing the flowchart consisting of blocks of services and local components, adding inputs/outputs to the blocks, and then compiling the flowchart into executables. The chapter further discusses flowchart-based and architecture-driven software development by using other process languages and development environments. It first discusses BPEL (Business Process Execution Language) and BPEL-based development environments. Then the discussion is extended into message-based software integration and Enterprise Service Bus tools for integrating web contents.

Chapter 9 extends web-based computing to Internet of Things (IoT) and Robot as a Service (RaaS). As an example, robotics applications are studied in detail, using the service-oriented Visual IoT/Robotics Programming Language Environment (VIPLE) developed at Arizona State University. Full programming examples in VIPLE and hardware platform supported are discussed.

Chapter 10 covers service-oriented database management, which focuses on the interface between service-oriented software and relational databases, XML databases, and LINQ (Language Integrated Query), and using LINQ to access object, relational, and XML databases.

Chapter 11 studies the cutting-edge topics in big data and cloud computing. It discusses major issues in big data, including big data infrastructure, big data management, big data analytics, and big data applications. Hadoop and VIPLE are used for illustrating automated data splitting and parallel computing. The relationship between big data and cloud computing is discussed. Finally, the chapter presents cloud computing and its main layers: Software as a Service, Platform as a Service, and Infrastructure as a Service. As examples, cloud platforms from Amazon Web Services, Google, IBM, Microsoft, and Oracle are discussed.

Chapter 12 presents the latest artificial intelligence, machine learning, and ontology theories and technologies. The latest generation of artificial intelligence is based on big data analysis and processing. This chapter presents its development, main concepts, and examples of developing machine-learning programs. Ontology is presented as a part of knowledge representation for big data processing and artificial intelligence applications.

Part III consists of three appendices that supplement and support the main contents on web application development and IoT/robotics application development.

Appendices A and B contain tutorial-based materials that provide stepwise instructions, without missing pieces, to build working applications from scratch. These tutorials and exercises can help students to learn concepts by examples. This part, in conjunction with parts of Chapter 3 and Chapter 9, can also be used for a freshman level course to introduce computing concepts through basic web application development and robotics programming.

Appendix C is the entrance to ASU Repository of Services and Applications. It lists and explains some of the deployed examples and URLs of SOAP services, RESTful services, web applications, and other resources used in this text. Free services found on the Internet come and go without any guarantee on quality of service. The repository provides a stable resource for teaching from this book without worrying about the availability and performance of the free services found on the Internet. ASU Repository of Services and Applications is open to the public and can be accessed at:

Updates are carried out throughout the book, and major revisions have focused on several chapters in this edition. The programming examples using the early editions of Visual Studio programming environment are updated to Visual Studio 2019 edition. The links to external services have been checked and updated where applicable.

In this edition, Chapter 7 is significantly extended. Microservices are included, and the advanced web application architecture is extended to HTML5 and Core MVC architecture. Workflow-based application development and Workflow Foundation are moved from Chapter 7 to Chapter 8, forming a stronger composition and integration-oriented enterprise application development chapter.

Major revisions are made in Chapter 9. The latest VIPLE version is incorporated, and new functions and examples are added. For example, CodeActivity–Python and TORCS autonomous driving simulation are included in this edition.

In Chapter 10, a section on installing a database and using SQL Server Management Studio to create local SQL database projects are added.

Major revisions and extensions are done to Chapter 11, resulting in its splitting into two chapters in this edition. The new Chapter 11 keeps big data processing and cloud computing contents, while the new Chapter 12 focuses on artificial intelligence, machine learning, and ontology. VIPLE simulation is used for illustrating automated parallel computing principles in big data processing. New case studies, on a guide dog project and on flight data collection, training, and flight path recognition are added to Chapter 12.

The book embraces extensive contents. It can be used in multiple courses. At Arizona State University, we use the book as the text for two major required courses. The first course is CSE445/598 (Distributed Software Development), where the CSE445 session is for juniors and seniors, while the CSE598 session is for graduate students. The course started in Fall 2006, and first edition of the book was developed for this course in 2008. The first six chapters in Part I of this text are used for this course.

A second course CSE446/598 (Software Integration and Engineering) was piloted in 2010 and 2011, and the course became a regular course in 2012. The six chapters in Part II of this text is used for this course.

Both CSE445 and CSE446 are required courses of the Software Engineering Concentration in the Computer Science program at Arizona State University.

The following table illustrates the lectures of CSE445/598 and CSE446/598. Each lecture is 75-min long and counts as 1.5 lecture hours. Each course is completed in about 44 lecture hours.

The first course focuses on distributed software development, including multithreading programming, event-driven programming, Web data representation, service development, and application building using programming languages as the composition language. Both C# and Java are used in the development. The course objectives and outcomes of ASU CSE445/598 are as follows:

  1. To develop an understanding of the software engineering of programs using concurrency and synchronization.
    • The student can identify the application, advantages and disadvantages of concurrency, threads, and synchronization.
    • The student can apply design principles for concurrency and synchronization.
    • The student can design and write programs demonstrating the use of concurrency, threads, and synchronization.
  1. To develop an understanding of the development of distributed software.
    • The student can recognize alternative distributed computing paradigms and technologies.
    • The student can identify the phases and deliverables of the software life cycle in the development of distributed software.
    • The student can create the required deliverables in the development of distributed software in each phase of a software life cycle.
    • The student understands the security and reliability attributes of distributed applications.
  1. To develop an ability to design and publish services as building blocks of service-oriented applications.
    • The student understands the role of service publication and service directories
    • The student can identify available services in service registries.
    • The student can design services in a programming language and publish services for the public to use.
  1. To build skills in using a current technology for developing distributed systems and applications.
    • The student can develop distributed programs using the current technology and standards.
    • The student can use the current framework to develop programs and web applications using graphical user interfaces, remote services, and workflow.


CSE445/598 Lecture by Lecture Contents

CSE446/598 Lecture by Lecture Contents

The second course focuses on software and system integration using workflow languages and cutting-edge topics in software and system development. The course objectives and outcomes of ASU CSE446/598 are as follows:

  1. To understand software architecture and software process.
    • Students understand the requirement and specification process in problem solving.
    • Students understand software life cycle and process management
    • Students can identify advantages and disadvantages of software architectures and their trade-offs in different applications.
  1. To understand and apply composition approach in software development.
    • Students can apply software architecture to guide software development in the problem-solving process.
    • Students understand interface requirement of software services.
    • Students can compose software based on interfaces of services and components.
    • Students can develop software system using different composition methods and tools.
  1. To understand and apply data and information integration in software development.
    • Students can compose software systems using different data resources in different data formats.
    • Students can integrate application logic with different databases.
    • Students can apply the entire software life cycle to develop working software systems.

We recommend teaching the two courses in a sequence. However, the two courses can be taught independently without making one to be the prerequisite of the other. In this case, the basic concepts and principles from Part I, including those from a part of Chapter 1 and the first section of Chapter 4, should be reviewed or be assigned as reading materials for preparing the course using Part II. It is also sensible to choose a few topics from Part I and Part II to teach one course from the book. For example, Chapters 1, 3, 5, and 8 can form a good service-oriented computing course. Chapter 9 and Appendix B can be used for a computational thinking-based robotics course for students who do not have much programming language background.

We like to thank my colleagues at Arizona State University in preparing this book and related courses. Prof. Wei-Tek Tsai has taught CSE445/598. He was a coauthor of the book’s first five editions. Dr. Janaka Balasooriya has been teaching CSE445/598 for several semesters and has constantly provided feedback and suggestions for improving the contents of the course and the book. Prof. Yann-Hang Lee contributed to the course contents related to IoT and robotics development. Prof. Hessam Sarjoughian and Prof. Stephen Yau contributed to the development of CSE445/598 and CSE446/598 courses. Many of our sponsors, colleagues, cooperators, and students have been involved in this project, including Prof. Xiaoying Bai of Tsinghua University, Prof. Farokh Bastani of University of Texas at Dallas, Dr. J. Y. Chung of IBM, Prof. Zhongshi He of Chongqing University, Prof. Mei Hong of Beijing Institute of Technology, Prof. Yingxu Lai of Beijing University of Technology, Prof. Yinsheng Li of Fudan University, Prof. Zhongtao Li of University of Jinan, Prof. K. J. Lin of University of California at Irvine, Mr. John Oliver of Intel, Dr. Raymond Paul of DoD OSD NII, Profs. Qian Wang and Yongkang Xing of Chongqing University, Profs. Ruzhi Xu and Zhizheng Zhou of Qilu University of Technology, and Prof. I-Ling Yen of University of Texas at Dallas. They contributed to our understanding of the materials. We also acknowledge the generous support from Intel, the US Department of Education, the US Department of Defense, and the National Science Foundation. Without their support, this book would not be possible. We also thank the teaching assistants and research assistants at Arizona State University, including Calvin Cheng, Gennaro De Luca, Jay Elston, Qian Huang, Adam Lew, Wu Li, Gavin Liu, Mengxue Liu, Sami Mian, Xin Sun, Jingjing Xu, Xinyu Zhou, Thomas Zelpha, and Peide Zhong. Gennaro De Luca is the main developer of the VIPLE environment. They implemented and validated many of the examples and assignments used in the book. Finally, we would like to thank our families for their support and understanding of taking on such a project while carrying out a full research and teaching load at the university.

Note for Instructors

All the assignments and projects have been classroom-tested at Arizona State University for many years. Furthermore, all the code presented in this book has been developed and tested. Contact the authors if you are interested in obtaining more materials in this book. Instructor-only resources, such as complete presentation slides, assignments, and tests, can be obtained by directly contacting the authors at


Yinong Chen

April 2020



Table of Contents


Part I Distributed Service-Oriented Software Development and Web Data Management

Chapter 1 Introduction to Distributed Service-Oriented Computing
1.1 Computer Architecture and Computing Paradigms
1.1.1 Computer Architecture
1.1.2 Software Architecture
1.1.3 Computing Paradigms
1.2 Distributed Computing and Distributed Software Architecture
1.2.1 Distributed Computing
1.2.2 N-Tier Architecture
1.2.3 Distributed Object Architecture
1.3 Service-Oriented Architecture and Computing
1.3.1 Basic Concepts and Terminologies
1.3.2 Service-Oriented Computing
1.3.3 Service-Oriented System Engineering
1.4 Service-Oriented Software Development and Applications
1.4.1 Traditional Software Development Processes
1.4.2 Service-Oriented Software Development
1.4.3 Applications of Service-Oriented Computing
1.4.4 Web Application Composition
1.5 Enterprise Software Development
1.6 Discussions
1.7 Exercises and Projects

Chapter 2 Distributed Computing with Multithreading
2.1 Introduction to C# and .Net
2.1.1 Getting Started with C# and .Net
2.1.2 Comparison between C++ and C#
2.1.3 Namespaces and the “using” Directive
2.1.4 Class and Object in C#
2.1.5 Parameters: Passing by Reference with ref & out
2.1.6 Base Class and Base Calling Class Constructor
2.1.7 Constructor, Destructor, and Garbage Collection
2.1.8 Pointers in C#
2.1.9 C# Unified Type System
2.2 Memory Management and Garbage Collection
2.2.1 Static Variables and Static Methods
2.2.2 Runtime Stack for Local Variables
2.2.3 Heap for Dynamic Memory Allocation
2.2.4 Scope and Garbage Collection
2.3 General Issues in Multitasking and Multithreading
2.3.1 Basic Requirements
2.3.2 Critical Operations and Synchronization
2.3.3 Deadlock and Deadlock Resolving
2.3.4 Order of Execution
2.3.5 Operating System Support for Multitasking and Multithreading
2.4 Multithreading in Java
2.4.1 Creating and Starting Threads
2.4.2 Thread Synchronization
2.4.3 Synchronized Method
2.4.4 Synchronized Statements
2.5 Multithreading in C#
2.5.1 Thread Classes and Properties
2.5.2 Monitor
2.5.3 Reader and Writer Locks
2.5.4 Mutexes
2.5.5 Semaphore
2.5.6 Coordination Event
2.6 Event-Driven Programming
2.6.1 Exception Handling
2.6.2 Event-Driven Programming Concepts and Mechanisms
2.6.3 Case Study: An Electronic Commerce Application in Event-Driven Approach
2.7 Multithreading Performance
2.7.1 Amdahl’s Law
2.7.2 Multithreading Experiments
2.8 Discussions
2.9 Exercises and Projects

Chapter 3 Essentials in Service-Oriented Software Development
3.1 Service-Oriented Software Development Environments
3.1.1 Overview
3.1.2 Windows Communication Foundation
3.1.3 Service Interface: Address, Binding, and Contract
3.2 Service Provider: Creating and Hosting Services
3.2.1 Getting Started with Developing WCF Services
3.2.2 Testing Web Services in WCF Test Client
3.2.3 Writing a Console Application to Consume a WCF Service
3.2.4 File Service and Data Management
3.2.5 Hosting Your Web Services as a Service Provider
3.2.6 Source Code Deployment and Precompiled Code Deployment
3.3 Service Brokers: Publishing and Discovering Services
3.3.1 An Ideal Service Broker with All Desired Features
3.3.2 UDDI Service Registry
3.3.3 ebXML Service Registry and Repository
3.3.4 Ad Hoc Registry Lists
3.4 SOAP and HTTP
3.4.1 SOAP Format
3.4.2 HTTP
3.4.3 SOAP over HTTP
3.5 WSDL: Web Services Description Language
3.5.1 Elements of WSDL Documents
3.5.2 WSDL Document Example
3.6 Service Requesters: Building Applications Using Services
3.6.1 Connecting Endpoint and Proxy
3.6.2 Creating a Windows Forms Application in ASP.Net
3.6.3 Developing a Website Application to Consume WCF Services
3.7 Web Service Testing and Dynamic Service Invocation
3.7.1 Get Web Content from URL
3.7.2 Analyze WSDL Document
3.7.3 Test Web Service through Dynamic Proxy
3.7.4 Test Web Service Using Independent Tools
3.7.5 Dynamic Web Services and Web Applications
3.8 Java-Based Web Service Development
3.8.1 Web Application Building Using AJAX Programming
3.8.2 Java-Based Web Service Development and Hosting
3.9 Discussions
3.10 Exercises and Projects

Chapter 4 XML and Web Data Formats
4.1 XML Fundamentals
4.1.1 XML versus HTML
4.1.2 XML Syntax
4.1.3 XML Namespaces
4.2 XML Data Processing
4.2.1 DOM: Document Object Model
4.2.2 SAX: Simple API for XML
4.2.3 XML Text Writer
4.2.4 XML Processing in Java
4.3 XPath
4.4 XML Type Definition Languages
4.4.1 XML Document Type Definition (DTD)
4.4.2 XML Schema
4.4.3 Namespace
4.4.4 XML Validation
4.5 Extensible Stylesheet Language
4.6 Other Web Data Formats
4.6.1 XHTML
4.6.2 RSS
4.6.3 Atom
4.6.4 JSON
4.6.5 HTML5
4.6.6 Google Protocol Buffers and BigTable
4.7 Discussions
4.8 Exercises and Projects

Chapter 5 Web Application and State Management
5.1 Models of Web Applications
5.1.1 Pure HTML-Based Web Application
5.1.2 Client-Side Scripting
5.1.3 Server-Side Scripting and Code-Behind Page Computing
5.1.4 Client-Side Out-of-Browser Computing
5.2 Web Application Structure and Architecture
5.2.1 Components of Web Applications
5.2.2 Server Controls
5.2.3 User Controls
5.2.4 Web Application Configuration
5.2.5 Global Application Class
5.2.6 Dynamic Link Library and Package
5.3 State Management
5.3.1 Overview of State Management Techniques
5.3.2 View State
5.3.3 View State Security and Machine Key
5.3.4 Session State
5.3.5 Cookies
5.3.6 Session State and Cookies
5.3.7 Application State and Service Execution Model
5.4 Save User Data to Server File System
5.4.1 File System and Standard File Operations
5.4.2 Reading and Writing XML Files
5.5 Caching and Recommendation
5.5.1 Output Caching
5.5.2 Fragment Caching
5.5.3 Data Caching
5.6 Dynamic Graphics Design and Generation
5.6.1 Dynamic Graphics
5.6.2 Getting Started with Dynamic Graphics Generation
5.6.3 Generating Dynamic Graphics in User Control
5.7 Discussions
5.8 Exercises and Projects

Chapter 6 Dependability of Service-Oriented Software
6.1 Basic Concepts
6.1.1 Dependability
6.1.2 Dependability Attributes and Quality of Service
6.1.3 Security Issues in SOA Software
6.1.4 Reputation Management System
6.2 Access Control in Web Applications
6.2.1 IIS and Windows-Based Security Mechanisms
6.2.2 Forms-Based Security
6.2.3 Forms-Based Security with Self-Registration
6.2.4 User Registration Using the Built-in Account Management
6.3 Encryption and Decryption
6.3.1 Developing Encryption and Decryption Service in WCF
6.3.2 Developing a Secure Hashing Service in WCF
6.3.3 WCF Service Client
6.3.4 Error Control Code
6.3.5 Secure Sockets Layer Cryptographic Protocols
6.4 Dependable Computing in Windows Communication Foundation
6.4.1 WS-Security
6.4.2 WS-Reliability
6.4.3 Transactions
6.5 Discussions
6.6 Exercises and Projects

Part II Advanced Service-Oriented Computing and System Integration

Chapter 7 Advanced Services and Application Development
7.1 Self-Hosting Services
7.1.1 Developing a Service and a Hosting Service
7.1.2 Developing Clients to Consume Self-Hosting Services
7.2 Advanced WCF Services
7.2.1 Advanced Communication Models
7.2.2 Advanced Bindings
7.2.3 Service Behavior and State Management
7.3 REST Concept and RESTful Services
7.3.1 REST Concept and REST Architecture
7.3.2 RESTful Services
7.3.3 Microservices
7.3.4 Developing RESTful Service
7.3.5 Developing an Image Verifier in RESTful Service
7.3.6 Consuming Simple RESTful Service
7.3.7 Google RESTful Services: Map Services
7.3.8 Making Asynchronous Calls to RESTful Services
7.3.9 RESTful Service-Based Web Application Description Language
7.4 Advanced Web Application Architecture
7.4.1 ASP .Net Forms-Centric Architecture
7.4.2 HTML5 on ASP .Net Core Framework
7.4.3 MVC Architecture on ASP .Net Core Framework
7.4.4 MVC Web Application Development Example
7.5 Discussions
7.6 Exercises and Projects

Chapter 8 Enterprise Software Development and Integration
8.1 Overview of Composition Languages
8.2 Workflow Foundation
8.2.1 Architecture and Components
8.2.2 Creating a WF Flowchart Application
8.2.3 Creating Custom Code Activity for Workflow Application
8.2.4 Implementing Finite State Machine in Workflow
8.2.5 Creating Services and Persistence Services Using Workflow
8.3 BPEL
8.3.1 BPEL Activities and Constructs
8.3.2 BPEL Process
8.3.3 WSDL Interface Definition of BPEL Process
8.3.4 BPEL Process
8.3.5 An Example Invoking Real Web Services
8.4 Stateless versus Stateful Web Services
8.4.1 BizTalk’s Singleton Object Approach
8.4.2 BPEL’s Correlation Approach
8.5 Frameworks Supporting BPEL Composition
8.5.1 Oracle SOA Suite
8.5.2 ActiveBPEL
8.5.3 BizTalk
8.5.4 Simple Workflow Service
8.6 Message-Based Integration
8.6.1 Java Message Service
8.6.2 Microsoft Message Queue
8.6.3 Database-Supported Messaging
8.6.4 E-mail Supported Messaging
8.6.5 Enterprise Service Bus
8.7 Other Composition Languages
8.7.1 SCA/SDO
8.7.2 WSFL: Web Services Flow Language
8.8 Discussions
8.9 Exercises and Projects

Chapter 9 IoT, Robotics, and Device Integration via Visual Programming
9.1 Introduction
9.1.1 Internet of Things
9.1.2 Service-Oriented Robotics Computing
9.1.3 Event-Driven Robotics Applications
9.2 Robot as a Service
9.2.1 Robot as a Service Definition
9.2.2 Robot as a Service Design
9.2.3 Robot as a Service Implementation
9.3 Robotics Developer Studio and Visual Programming Language
9.3.1 MRDS and VPL Overview
9.3.2 Application Development in MRDS and VPL
9.4 VIPLE: A New Visual Programming Language
9.4.1 ASU VIPLE versus Microsoft VPL
9.4.2 Service-Oriented Computing: RESTful, WSDL, and VIPLE Service
9.4.3 Workflow with Code Activities
9.4.4 Finite State Machine
9.4.5 Event-Driven Programming
9.5 Robot Programming and Maze Navigation
9.5.1 VIPLE Robot Services
9.5.2 Maze Navigation Algorithms in Finite State Machine
9.5.3 Maze Navigation Algorithms Using Unity Simulator
9.5.4 Maze Navigation Algorithms Using Web Simulator
9.5.5 Maze Navigation Using Lego EV3 Robot
9.5.6 Other Platforms Supported by VIPLE
9.6 Discussions
9.7 Exercises and Projects

Chapter 10 Interfacing Service-Oriented Software with Databases
10.1 Database Systems and Operations
10.2 Relational Databases in Service-Oriented Software
10.2.1 Installing a Database
10.2.2 Interface between Database and Software
10.2.3 SQL Database in ADO .Net
10.2.4 DataAdapter and DataSet in ADO .Net
10.3 LINQ, Language Integrated Query
10.3.1 What Is the Purpose of LINQ?
10.3.2 Lambda Expressions
10.3.3 LINQ to Object
10.3.4 LINQ to SQL
10.3.5 LINQ to XML
10.3.6 GraphQL
10.4 XML-Based Database and Query Language XQuery
10.4.1 Expressing Queries
10.4.2 Transforming XML Document
10.4.3 XQuery Discussions
10.5 Discussions
10.6 Exercises and Projects

Chapter 11 Big Data Processing and Cloud Computing
11.1 Big Data Systems and Management
11.1.1 Big Data Concepts
11.1.2 Big Data Management
11.2 Big Data Processing and Analytics
11.2.1 Map and Reduce
11.2.2 Hadoop and Cassandra
11.2.3 Big Data Simulation in VIPLE
11.2.4 Apache Pig
11.2.5 Big Data Analytics
11.3 Big Data Applications and Case Studies
11.3.1 Big Data Applications in Different Domains
11.3.2 Recommender System
11.4 Cloud Computing
11.4.1 Definitions
11.4.2 Software Engineering and Software Architecture Leading to Cloud Computing
11.4.3 Software as a Service and Multitenancy
11.4.4 Platform as a Service
11.4.5 Infrastructure as a Service and Data Center
11.5 Discussions
11.6 Exercises and Projects

Chapter 12 Artificial Intelligence and Machine Learning
12.1 Development of Artificial Intelligence and Machine Learning
12.2 From Traditional Programming to AI Programming
12.3 Machine Learning Case Study on Traffic Sign Recognition
12.3.1 Using Traditional Programming
12.3.2 Using Machine Learning
12.3.3 Machine Learning Experiments
12.4 Machine Learning Case Study on Flight Path Recognition
12.4.1 Flight Activity Recognition
12.4.2 Implementation
12.4.3 Experiment and Configurations
12.5 Machine Learning Case Study on Network Traffic Monitoring
12.6 Ontology
12.6.1 Ontology Language RDF
12.6.2 RDF Schema
12.6.3 Reasoning and Verification in Ontology
12.6.4 Web Ontology Language OWL
12.6.5 OWL-S and Semantic Web Services
12.6.6 Linked Data
12.6.7 Ontology Development Environments
12.7 Discussions
12.8 Exercises and Projects

Part III Appendices: Tutorials on Service-Oriented System Development

Appendix A Web Application Development
A.1 Design of Graphical User Interface
A.2 Discovering Web Services Available Online
A.3 Access Web Services in Your Program: ImageService
A.4 Access Web Services in Your Program: Weather Forecasting Service
A.5 Access Web Services in Your Program: USZip Service
A.6 Exercises and Projects
Appendix B Visual IoT/Robotics Programming Language Environment
B.1 Introduction to VIPLE
B.1.1 Basic Activities in VIPLE Toolbox
B.1.2 Built-in VIPLE Services
B.2 Getting Started with VIPLE Programming
Ex. 1. “Hello World” in VIPLE
Ex. 2. Favorite Movie
Ex. 3. Create While Loop Block Using Merge and If Activities
Ex. 4. Creating While Loop Block Using the While Activity
Ex. 5. Creating an Activity
Ex. 6. Creating Counter Activity
Ex. 7. Build a 2-1 Multiplexor
Ex. 8. Convert an Activity into a Service
B.3 Building Larger Systems Using Modules
Ex. 1. Creating an AND Gate in VIPLE
Ex. 2. Creating OR, NOT, and XOR Gates
Ex. 3. Build a 1-bit Adder
Ex. 4. Build a 2-1 Multiplexor and a 4-1 Multiplexor
Ex. 5. Build a 1-Bit ALU
Ex. 6. Automated Testing
Ex. 7. Create Automated Testing for ALU
Ex. 8. Create a 4-Bit ALU
Ex. 9. Drive-by-Wire Simulation
B.4 Exercises and Projects
Appendix C ASU Repository of Services and Applications