The Transparent Web
Functional, Reactive, Isomorphic
Christopher J. Wilson
  • MEAP began June 2016
  • Publication in November 2017 (estimated)
  • ISBN 9781633430013
  • 250 pages (estimated)
  • printed in black & white

The way we think about building web applications is changing fast to meet increased demands of user traffic, data load, and development cycle time. New approaches, many influenced by functional and reactive programming models, along with the languages and frameworks that support them, are becoming mainstream. In this exploratory book, you'll tour emerging frameworks and languages, gaining ideas that will show up in next-generation programming.

The Transparent Web presents a survey of new tools and techniques for web development focused on the themes of reactive programming, unifying separate platforms (isomorphic apps & more), and functional programming. You'll explore the benefits of modern type systems and functional reactive programming. You'll also learn how these new approaches can make you a more productive developer by shortening revision cycles and making it easier to share code, scale applications, and add features.

"Reading the book will make plenty of readers feel empowered for future projects and jobs."

~ James Anaipakos

"The topics are very important to me. The book covers new technics that I didn't know before."

~ Othman Doghri

"This book is excellent for you to enhance your skill of web development."

~ Riza Fahmi

"There are 2 value propositions for this book: 1. You build exactly the same app in different languages which makes it easier to compare and contrast them. 2. It exposes you to different languages that are viable options."

~ Nick McGinness

Table of Contents detailed table of contents

1. Advancing The Web

1.1. Major Themes of The Functional Web

1.1.1. Unified Stacks

1.1.2. Functional Programming

1.1.3. Reactive Programming

1.2. Summary

Part 1: Unified Stack

2. Transparent Client-Server Programming With Opa

2.1. Tutorial Overview

2.1.1. Variables

2.1.2. Functions

2.1.3. Special syntax

2.1.4. Records

2.2. Re-visiting the Biking App: Opa Example

2.2.1. Model code

2.2.2. View code

2.2.3. Controller code

2.3. Summary

3. Unify the Server With MirageOS

3.1. Installing OCaml and MirageOS

3.2. Crash Course

3.2.1. Overall File Layout

3.2.2. Syntax

3.2.3. Strings, Lists, & Numbers

3.2.4. Records

3.2.5. Defining and Calling Functions

3.2.6. Modules & Functors

3.3. Example

3.3.1. Config

3.3.2. Biking (Main)

3.3.3. Model

3.3.4. View

3.3.5. Controller

3.3.6. Form handler

3.4. Summary

4. Unify the Client With WebAssembly

4.1. Assembly, Web and Otherwise

4.1.1. Assembly

4.1.2. High-level assembly, WebAssembly

4.2. Gossamer: Compiling to WebAssembly

4.2.1. Lexing and Parsing: from text to grammar

4.2.2. Type checking

4.2.3. Intermediate Representation & Transformation

4.2.4. Compiler pipeline

4.3. Summary

Part 2: Functional Programming

5. Understanding Static Typing

5.1. Collections of Values

5.2. What types can be used for

5.2.1. Avoiding null-pointer errors

5.2.2. Solving injections

5.3. How types work

5.3.1. A definition of "type system"

5.3.2. How a type system is implemented

5.3.3. An example of a hard-to-spot bug

5.4. Summary

6. Writing Functional Code

6.1. What Functional Programming Is

6.2. How Functional Programming Helps

6.3. Immutability & Purity

6.3.1. Purity

6.3.2. Immutability

6.3.3. Unifying pass-by-value and pass-by-reference

6.4. Recursive functions

6.5. Higher-order Functions

6.5.1. Zip

6.5.2. Curry

6.6. Processing Lists & the Mighty Fold

6.7. Summary

7. A Type Safe Web App in Haskell

7.1. Installation

7.2. Haskell Crash Course

7.2.1. Overall File Layout

7.2.2. Syntax

7.2.3. Strings, Lists, and Numbers

7.2.4. Defining and Calling Functions

7.2.5. Control Structures

7.2.6. Crash Course Summary

7.3. An Example Web Application in Haskell

7.3.1. Main

7.3.2. Database Connection

7.3.3. Controllers

7.3.4. Views

7.3.5. Types

7.4. Features of Haskell

7.4.1. Type Safe Routing

7.4.2. Double-duty Forms

7.5. Summary

Part 3: Reactive Programming

8. Writing Reactive GUIs With Elm

8.1. Elm Language Crash Course

8.1.1. Basic Syntax and Values

8.1.2. Types and Type Aliases

8.1.3. Functions

8.1.4. Records

8.1.5. Commands, Messages, and Subscriptions

8.2. Biking Example

8.2.1. Types

8.2.2. Model

8.2.3. Update

8.2.4. View

8.2.5. Forms

8.2.6. Main

8.3. Summary

What's inside

  • Seamless client/server integration at runtime
  • Scrap boilerplate, imperative code, in favor of reactive updates
  • Writing web applications all in the same codebase and language
  • Use static typing to save time debugging and write more trustworthy code
  • Get applications up and running faster with all-in-one frameworks

About the reader

This book is for developers who have some experience developing web applications in a more traditional MVC style. Readers should also be familiar with dynamic languages or statically-typed languages in the style of Java or C#.

About the author

Chris Wilson is a science nerd turned software developer. He's worked as a software consultant and is now developing healthcare applications.


Manning Early Access Program (MEAP) Read chapters as they are written, get the finished eBook as soon as it’s ready, and receive the pBook long before it's in bookstores.
Buy
MEAP combo $44.99 pBook + eBook + liveBook
MEAP eBook $35.99 pdf + ePub + kindle + liveBook

FREE domestic shipping on three or more pBooks