O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

ASP.NET Core: Cloud-ready, Enterprise Web Application Development

Book Description

Create fast, scalable, and high-performance applications with C# and ASP.NET Core

About This Book

  • Get first-principle coverage of the latest ASP.NET Core MVC
  • Find out how to bring together the capabilities and features of both Angular 2 and ASP.NET Core
  • Discover common areas you might encounter performance problems with and areas you don’t need to worry about

Who This Book Is For

This book is for developers who want to learn to build web applications using ASP.NET Core, those who want to make a career building web applications using Microsoft technology, and those who are working on other web frameworks and want to learn ASP.NET Core.

What You Will Learn

  • Get to know the concepts of ASP.NET MVC
  • Create a Controller with action methods
  • Build a view using several features of the Razor View engine
  • Construct a Model for ASP.NET Core MVC application
  • Find out how the features of ASP.NET Core and Angular 2 perfectly complement each other
  • Handle requests and actions using server-side and client-side Routing
  • Create a Data Model using Entity Framework Core
  • Learn how to use Angular 2 components and master directives
  • Improve performance at the network level and I/O level, and how to optimize the application as a whole
  • Monitor performance as part of Continuous Integration and regression testing

In Detail

ASP.NET Core is the new, open source, and cross-platform, web-application framework from Microsoft. ASP.NET Core MVC helps you build robust web applications using the Model-View-Controller design. This guide will help you in building applications that can be deployed on non-Windows platforms such as Linux.

Starting with an overview of the MVC pattern, you will quickly dive into the aspects that you need to know to get started with ASP.NET. You will learn about the core architecture of model, view, and control. Integrating your application with Bootstrap, validating user input, interacting with databases, and deploying your application are some of the things that you will learn to execute with this fast-paced guide. You will test your knowledge as you build a fully working sample application using the skills you’ve learned throughout the book.

Moving forward, this guide will teach you to combine the impressive capabilities of ASP.NET Core and Angular 2. Not only will you learn how Angular 2 can complement your .NET skills and toolkit, you'll also learn everything you need to build a complete, dynamic single-page application. Find out how to get your data model in place and manage an API, before styling and designing your frontend for an exceptional user experience. You will find out how to optimize your application for SEO, identify and secure vulnerabilities, and how to successfully deploy and maintain your application. From here, you will delve into the latest frameworks and software design patterns to improve your application performance.

The course offers premium, highly practical content on the recently released ASP.NET Core, and includes material from the following Packt books: Learning ASP.NET Core MVC Programming, ASP.NET Core and Angular 2, and ASP.NET Core 1.0 High Performance.

Style and approach

This learning path takes a first-principles approach to help you understand and implement ASP.NET MVC solutions.

Downloading the example code for this book. You can download the example code files for all Packt books you have purchased from your account at http://www.PacktPub.com. If you purchased this book elsewhere, you can visit http://www.PacktPub.com/support and register to have the code file.

Table of Contents

  1. ASP.NET Core: Cloud-ready, Enterprise Web Application Development
    1. ASP.NET Core: Cloud-ready, Enterprise Web Application Development
    2. ASP.NET Core: Cloud-ready, Enterprise Web Application Development
    3. Credits
    4. Preface
      1. What this learning path covers
      2. What you need for this learning path
      3. Who this learning path is for
      4. Reader feedback
      5. Customer support
      6. Downloading the example code
      7. Errata
      8. Piracy
      9. Questions
    5. 1. Module 1
      1. 1. Introduction to ASP.NET Core
        1. How web applications work
          1. So what is an HTTP protocol?
            1. Request-response pattern
            2. Stateless nature of HTTP
        2. Client-side and server-side
        3. HTTP methods
          1. GET method
          2. POST method
        4. What is ASP.NET?
          1. ASP.NET Web Forms
          2. ASP.NET Web Pages
          3. ASP.NET MVC
        5. Features of ASP.NET MVC
          1. Convention over configuration
          2. Separation of concerns
          3. Control over the generated HTML
          4. Better support for unit testing
        6. ASP.NET 5
          1. Features of ASP.NET 5
        7. Summary
      2. 2. Setting Up the Environment
        1. Purpose of IDE
        2. Visual Studio offerings
          1. System requirements
            1. Visual Studio Community 2015
            2. Visual Studio Professional
            3. Visual Studio Enterprise
            4. Visual Studio Test Professional
        3. Installing Visual Studio Community
        4. Installing ASP.NET 5
        5. Project structure in ASP.NET 5 application
          1. File-based project
            1. Support for full .NET and .NET core
            2. The Project.json package
            3. Controllers
            4. Models
            5. Views
            6. Migrations
            7. The wwwroot folder
            8. Other files
        6. Summary
      3. 3. Controllers
        1. Role of the Controller in ASP.NET MVC applications
        2. Introduction to routing
        3. Creating ASP.NET 5 application
        4. Installing the ASP.NET Core NuGet package in your application
        5. Our first Controller
          1. IActionResult
        6. Adding Views
        7. Adding Models
        8. Passing data from Controller to View
        9. Filters
          1. Authorization filters
          2. Resource filters
          3. Action filters
          4. Exception filters
          5. Result filters
        10. Summary
      4. 4. Views
        1. The View engine and the Razor View engine
          1. Razor View engine
            1. Programming in Razor View engine
            2. Variables in Razor View
              1. The for loop
              2. The while loop
              3. The foreach loop
              4. The if condition
        2. Layout
          1. Creating _ViewStart.cshtml
          2. Creating _Layout.cshtml
          3. Adding a page-specific View
        3. Generating HTML
          1. HTML Helpers
        4. Partial View
          1. Calling the Partial View
        5. View components
          1. Creating a View component
        6. Tag Helpers
          1. Creating custom Tag Helpers
        7. Summary
      5. 5. Models
        1. Models
          1. Models specific to a View component
          2. Note on ViewModels
          3. Data flow with respect to a Model
        2. Model binding
        3. The Entity Framework
          1. The Entity Framework is independent of ASP.NET MVC
          2. Creating console applications with the Entity Framework
          3. Installing the Entity Framework 7 NuGet package
            1. Using the NuGet Package Manager
            2. Using the Package Manager Console
          4. Installing Entity Framework commands
            1. Creating Model classes
            2. Creating the DbContext class
          5. Create a migration
          6. How the SaveChanges method works
          7. Updating the record
          8. Deleting the record
        4. Using the Entity Framework in ASP.NET MVC applications
        5. Database migration
        6. Summary
      6. 6. Validation
        1. Client-side and server-side validation
        2. Server-side validation
          1. Updating View models with the Data Annotation attribute
          2. Updating the View model to display the validation error message
          3. Updating the controller action method to verify the model state
        3. Client-side validation
        4. Implementation
        5. Summary
      7. 7. Routing
        1. Convention-based routing
          1. Example 1
          2. Example 2
          3. Example 3
          4. Example 4
        2. Attribute-based routing
        3. Route attribute at the controller level
        4. Passing routing values in HTTP action verbs in the Controller
        5. Route Constraints
        6. Summary
      8. 8. Beautifying ASP.NET MVC Applications with Bootstrap
        1. Knowing HTML and CSS
        2. Bootstrap
          1. Bootstrap Grid system
          2. Forms
            1. Inline forms
            2. Horizontal forms
          3. Table CSS classes
            1. Striped tables
            2. Hover tables
            3. Bordered tables
            4. Contextual classes in table
          4. Buttons
            1. Button sizes
          5. Contextual colors
        3. Using Bootstrap in your ASP.NET MVC application
        4. Installing with Bower
        5. HTML doctype
        6. Summary
      9. 9. Deployment of ASP.NET Core Application
        1. The project.json file
          1. The dependencies node
          2. The frameworks node
        2. Microsoft Azure
          1. Signing up to Microsoft Azure
          2. Prerequisites to Azure deployment
        3. Deploying the ASP.NET Core application in Azure
        4. Deploying the ASP.NET Core web application in the Linux environment
          1. Creating a Linux machine
          2. Installing the PuTTY client
          3. Installing of .NET Core in a Linux machine
        5. Creating a new ASP.NET 5 project
        6. Configuring the Nginx server
        7. Summary
      10. 10. Building HTTP-based Web Services Using ASP.NET Web API
        1. HTTP basics
          1. HTTP verbs
          2. GET method
          3. PUT method
          4. POST method
          5. DELETE method
          6. Fiddler tool
        2. Dependency Injection
          1. Delete method
            1. The Web API method for deleting a resource
            2. Web Repository layer code for deleting the employee data
        3. Summary
      11. 11. Improving Performance of an ASP.NET Core Application
        1. The UI layer
        2. Reducing the number of HTTP requests
          1. Using GZip compression
          2. Using the Content Delivery Network (CDN)
          3. Using JavaScript wherever possible
          4. Using CSS stylesheets
        3. Minification of JavaScript and CSS files and their combination
        4. The caching process
          1. Client-side caching
          2. Response caching
        5. The web/application layer
          1. No business logic in Views
          2. Using asynchronous logging
          3. The DB layer
            1. Understanding the queries generated by the ORM
            2. Using classic ADO.NET if you really want to
            3. Return only the required data
            4. Fine tuning the indices
            5. Using the correct column type and size for your database columns
            6. Avoiding correlated subqueries
        6. Generic performance improvement tips
          1. Avoiding the Response.Redirect method
          2. Using string builder
        7. Summary
      12. 12. ASP.NET Core Identity
        1. Authentication
        2. Authorization
        3. Adding the relevant dependencies to the project.json file
          1. Adding ApplicationUser and ApplicationDbContext classes
        4. Configuring the application to use Identity
        5. Creating ViewModels
        6. Creating Controllers and associated action methods
        7. Creating Views
        8. E-mail and SMS services
        9. Securing an action method in a Controller
        10. Summary
    6. 2. Module 2
      1. 1. Getting Ready
        1. Two players  one goal
          1. What's new in Angular 2?
          2. The ASP.NET Core revolution
        2. The field of choice – single-page application
          1. Common features of a competitive SPA
          2. Product owner expectations
        3. A sample single-page application project
          1. The vision
          2. Core requirements
        4. Preparing the workspace
          1. Setting up the project
          2. Package and resource managers
          3. Installing the packages
            1. NuGet and ASP.NET
              1. Project.json
              2. Startup.cs
              3. Testing the HTTP request pipeline
              4. Newtonsoft.Json
            2. JavaScript, TypeScript, or Dart?
            3. Adding the tsconfig.json file
            4. Introducing NPM
            5. Working with Gulp
              1. Dependent tasks
              2. Using Grunt instead of Gulp
            6. Adding Angular 2
              1. Using NPM
              2. Adding Typings
              3. Using a CDN
            7. Upgrading the typescriptServices.js file
          4. Setting up the client code
            1. The component file
              1. A word on components and modules
            2. The module file
            3. The bootstrap file
            4. The module loader configuration file
              1. Why use a dynamic module loader?
            5. The index.html file
        5. First run
          1. Caching issues
          2. The new ASP.NET Core configuration pattern
        6. A faster alternative using scaffolding tools
          1. The reasons to say no (not yet)
          2. A quick scaffolding sample
        7. References
        8. Suggested topics
        9. Summary
      2. 2. ASP.NET Controllers and Server-Side Routes
        1. Data flow
          1. The role of the ViewModel
        2. Our first Controller
          1. The ItemViewModel
          2. The ItemsController
        3. Understanding routes
          1. Defining routing
            1. Routing through the ages
            2. Handling routes in ASP.NET Core
              1. Convention-based routing
              2. Attribute-based routing
              3. Three choices to route them all
          2. Adding more routes
            1. The dummy data provider
        4. Dealing with single items
        5. Suggested topics
        6. Summary
      3. 3. Angular 2 Components and Client-Side Routing
        1. Master-detail binding
          1. The Item class
          2. The ItemService class
          3. The ItemListComponent class
            1. A quick implementation test
          4. The ItemDetailComponent class
            1. Adding the @angular/forms library
            2. Updating the root module
            3. Connecting the dots
          5. Testing it up
        2. Adding additional lists
          1. Multiple component instances
        3. Two-way data binding
          1. Disabling two-way data binding
        4. Client-side routing
          1. Adding the @angular/router library
            1. PathLocationStrategy versus HashLocationStrategy
          2. Refactoring our app
            1. Adding the AppRouting scheme
            2. Adding the HomeComponent
            3. Adding new components
              1. AboutComponent
              2. LoginComponent
              3. PageNotFoundComponent
            4. Updating the root module
            5. Revising the master-detail strategy
              1. Adding the ItemDetail route
              2. Changing the ItemListComponent
              3. Updating the ItemDetailComponent
        5. Full routing test
          1. Handling rewrites in ASP.NET Core
            1. Showing the issue
            2. Understanding the causes
            3. Implementing the fix
            4. Validating the outcome
        6. Suggested topics
        7. Summary
      4. 4. The Data Model
        1. Getting ready
          1. Installing the EntityFramework Core
          2. Data modeling approaches
            1. The model-first approach
              1. Pros
              2. Cons
            2. The database-first approach
              1. Pros
              2. Cons
            3. The code-first approach
              1. Pros
              2. Cons
            4. Making a choice
        2. Creating entities
          1. Items
          2. Comments
          3. Users
        3. Defining relationships
        4. Setting up DbContext
          1. Database initialization strategies
        5. Choosing the database engine
          1. Updating appsettings.json
        6. Creating the database
          1. Updating Startup.cs
          2. Configuring the EF tools
          3. Adding the initial migration
            1. Understanding migrations
        7. Implementing a data seed strategy
          1. Creating a DbSeeder class
            1. Private members
            2. Constructor
            3. Public methods
            4. Seed methods
            5. Utility methods
          2. Adding the DbSeeder to Startup.cs
            1. Handling exceptions
        8. Seeding the database
          1. Updating the ItemsController
            1. Installing TinyMapper
            2. Implementing the mapping
        9. Testing the data provider
        10. Suggested topics
        11. Summary
      5. 5. Persisting Changes
        1. Add, update, and delete items
          1. Updating the Web API
          2. Adapting the client
            1. Improving the ItemService
            2. Updating the GUI
              1. Add new
              2. Update and Delete
              3. Testing it out
              4. Adding a new test
              5. Update test
              6. Delete test
        2. Splitting the ItemDetail component
          1. Adding the ItemDetailView component
          2. Refactoring ItemDetail into ItemDetailEdit
          3. Updating the Root module
          4. Updating the Routes
          5. Tracking the outdated references
          6. Implementing the tab menu
            1. Template
            2. Class code
            3. Styles
          7. Testing it out
        3. Suggested topics
        4. Summary
      6. 6. Applying Styles
        1. How bad is it, doc?
        2. Introducing LESS
          1. Style sheet languages
          2. CSS
            1. CSS code sample
          3. What is LESS and why to use it
            1. Variables
            2. Import directives
            3. Nested selectors
            4. Mixins
            5. Extend pseudo-class
          4. LESS docs and support
          5. Systematically Awesome Style Sheets, Stylus, and other alternatives
        3. Configuring LESS
          1. Adding the LESS file
          2. Updating Gulp script
          3. Linking the stylesheet
          4. Testing it up
        4. DIY versus framework-based styling
          1. Do it yourself approach
            1. Pros
            2. Cons
          2. Framework-based approach
            1. Pros
            2. Cons
          3. Conclusions
        5. Adding Bootstrap
          1. Choosing a native directives module
          2. Installing ng2-bootstrap
        6. Applying styles
          1. Main navigation bar
            1. Detecting the active route
          2. Welcome View
          3. Item Detail View
            1. Display mode
            2. Edit mode
          4. Conclusions
        7. Suggested topics
        8. Summary
      7. 7. Authentication and Authorization
        1. Do we really need these?
        2. Authentication
          1. Third-party authentication
        3. Authorization
          1. Third-party authorization
        4. Proprietary or third-party?
        5. Choosing an authentication mode
        6. Installing AspNetCore.Identity
          1. Adding the package
          2. Updating the project classes
            1. ApplicationDbContext.cs
            2. ApplicationUser.cs
            3. Startup.cs
            4. DbSeeder.cs
        7. Updating the database
        8. Authentication methods
          1. Sessions
          2. Tokens
          3. Signatures
          4. Two-factor
          5. Conclusions
        9. Implementing JSON web token authentication
          1. JWT provider
            1. Private members
            2. Static members
            3. Constructor
            4. Public methods
            5. Private methods
            6. Extension methods
            7. Full source code
          2. Adding the middleware to the pipeline
          3. Angular 2 login form
            1. Adding styles
            2. Updating the root module file
            3. UI and validation test
          4. AuthService component
            1. Updating the AppModule
            2. Updating the LoginComponent
            3. Login test
          5. AuthHttp wrapper
          6. Adding authorization rules
            1. Adapting the client
              1. Testing the client
            2. Protecting the server
            3. Retrieving the user ID
            4. Authorization test
        10. Suggested topics
        11. Summary
      8. 8. Third-Party Authentication and External Providers
        1. Introducing OpenID connect servers
        2. Installing OpenIddict
          1. Adding MyGet to the package sources
          2. Installing the OpenIddict package
          3. Updating ApplicationUser and ApplicationDbContext
          4. Adding a new migration
          5. Updating the DbSeeder
            1. Moving literal values to appsettings.json
          6. Configuring the Startup class
          7. Updating the Web.Config rewrite rules
          8. Seeding the database
        3. External authentication providers
          1. OAuth2 authorization flow
          2. Facebook
            1. Creating a Facebook App
            2. Storing the keys in App settings
            3. Adding the Facebook middleware
            4. Adding the AccountsController
              1. BaseController
              2. AccountsController
              3. Namespaces
              4. Class declaration
              5. Constructor
              6. ExternalLogin
              7. ExternalLoginCallBack
              8. Logout
            5. Updating the ItemsController
            6. Configuring the client
              1. Updating the LoginComponent
              2. Updating the AuthService
              3. Updating the AppComponent
              4. Understanding zones
            7. Testing it out
          3. Google
          4. Twitter
            1. Elevated permissions request
          5. Troubleshooting
        4. Conclusions
        5. Suggested topics
        6. Summary
      9. 9. User Registration and Account Edit
        1. User Registration
          1. UserViewModel
          2. AccountsController
            1. Get
            2. Add
              1. E-mail confirmation
            3. Update
            4. Delete
          3. User class
          4. AuthService
          5. UserEditComponent
          6. Connecting the dots
            1. Updating the root module
            2. Implementing the route
            3. Adding the Register link
            4. Defining the styles
            5. Updating the menu
          7. Testing it out
        2. Edit Account
          1. Two routes, one component
          2. Adapting the UserEditComponent
          3. Updating the navigation menu
            1. Adding styles
            2. Final test
        3. Conclusions
        4. Suggested topics
        5. Summary
      10. 10. Finalization and Deployment
        1. Switching to SQL Server
        2. Installing SQL Server 2016 Express
        3. Installing SQL Server Management Studio
          1. Configuring the database
            1. Changing the authentication mode
            2. Adding the OpenGameList database
            3. Adding the OpenGameList login
            4. Mapping the login to the database
            5. Adding a SQL Server connection string
            6. Creating an application settings file for production
              1. Updating AppSettings
            7. Updating external providers
            8. Configuring the publishOptions
            9. Checking the Startup class
            10. Updating the launchSettings.json
        4. Publishing our native web application
          1. Creating a Publish profile
            1. File System Publish profile
            2. FTP Publish profile
        5. Configuring IIS
          1. Installing the ASP.NET Core module for IIS
          2. Adding the website
          3. Configuring the Application Pool
        6. Firing up the engine
          1. Troubleshooting
            1. The Kestrel test
        7. Suggested topics
        8. Summary
    7. 3. Module 3
      1. 1. Why Performance Is a Feature
        1. Performance as a feature
        2. Common classes of performance problems
          1. Language considerations
          2. Types of performance problems
            1. When performance matters
              1. Slower is sometimes better
            2. Why issues are missed
              1. Measuring
          3. The benefits of planning ahead
        3. Understanding hardware
          1. Storage access speeds
          2. Scaling approach changes
        4. Tools and costs
          1. Tools
          2. Looking at some alternative tools
        5. The new .NET
        6. Summary
      2. 2. Measuring Performance Bottlenecks
        1. Tools
          1. SQL
            1. SQL Server Profiler
              1. Executing a simple query
            2. MiniProfiler
          2. Application profiling
            1. Glimpse
              1. Using Glimpse
            2. IDE
          3. Monitoring HTTP
            1. Browsers
              1. Chrome
              2. Firefox
            2. Fiddler
          4. Network
            1. Microsoft Message Analyzer
            2. Wireshark
          5. Roll your own
        2. Science
          1. Repeatability
            1. Only change one thing
        3. Summary
      3. 3. Fixing Common Performance Problems
        1. Latency
        2. Asynchronous operations
          1. Simple asynchronous tools
          2. Background queuing
          3. Hangfire
        3. Select N+1 problems
          1. Efficient paging
          2. Static site generators
        4. Pragmatic solutions with hardware
          1. A desktop example
          2. Web applications
        5. Oversized images
          1. Image resolution
          2. Image format
        6. Summary
      4. 4. Addressing Network Performance
        1. Internet protocols
          1. TCP/IP
            1. Slow-start
          2. HTTP
            1. Headers
            2. HTTP methods
            3. Status codes
            4. Encryption
              1. Key exchange
              2. Delay diagnostics
              3. Performance tweaks
            5. HTTP/2
            6. WebSockets
        2. Compression
          1. Lossless compression algorithms
          2. Bundling and minification
            1. Bundling
            2. Minification
            3. Changes in ASP.NET Core
          3. Image optimization
            1. PNG
            2. JPEG
            3. Other image formats
            4. Resizing images
        3. Caching
          1. Browser
          2. Server
          3. Proxy servers between you and your users
            1. CDNs
        4. Summary
      5. 5. Optimizing I/O Performance
        1. Input/output
          1. Categories of I/O
            1. Disks
            2. Virtual file systems
            3. Databases
            4. APIs
          2. Network diagnostics tools
            1. Ping
            2. Tracert
            3. Nslookup
            4. Build your own
        2. Solutions
          1. Batching API requests
          2. Efficient DB operations
            1. Database tuning
            2. Reporting
              1. Aggregates
              2. Sampling
            3. Inserting data
              1. GUIDs
            4. Advanced DB topics
        3. Simulation and testing
        4. Summary
      6. 6. Understanding Code Execution and Asynchronous Operations
        1. Getting started with the core projects
          1. .NET Core
          2. ASP.NET Core
            1. Kestrel
        2. Data structures
          1. Lists
          2. Dictionaries
          3. Collection benchmarks
          4. Bloom filters
        3. Hashing and checksums
          1. Hashing benchmarks
        4. Serialization
        5. SIMD CPU instructions
        6. Parallel programming
          1. Task Parallel Library
          2. Parallel LINQ
          3. Parallel benchmarking
          4. Parallel programming limitations
        7. Practices to avoid
          1. Reflection
          2. Regular expressions
          3. String concatenation in tight loops
          4. Dynamic typing
          5. Synchronous operations
          6. Exceptions
        8. Summary
      7. 7. Learning Caching and Message Queuing
        1. Why caching is hard
          1. Web caching
            1. Caching background
              1. HTTP headers
              2. Cache busting
            2. Service workers
              1. Service worker example
            3. Web and proxy servers
              1. IIS
              2. Varnish
            4. Working with a content delivery network
            5. When not to cache
          2. Application layer caching
            1. Redis
            2. Database result set caching
        2. Message queuing
          1. Coffee shop analogy
          2. Message queuing styles
          3. Common messaging patterns
            1. Unicast
            2. Pub/sub
          4. RabbitMQ
          5. Queuing frameworks and libraries
        3. Summary
      8. 8. The Downsides of Performance-Enhancing Tools
        1. Managing complexity
          1. Understanding complexity
          2. Complexity reduction
            1. Frameworks
            2. Architecture
              1. Monolith versus microservices
              2. Architecture comparison
            3. Refactoring
        2. A culture of high performance
          1. A blameless culture
          2. Intellectual dishonesty
          3. Slow down to go faster
          4. From the ground up
          5. Shared values
        3. The price of performance
        4. Distributed debugging
          1. Logging
            1. Error logging
            2. Application Insights
            3. Integrated logging
            4. Centralized logging
          2. Statistics
        5. Managing stale caches
        6. Summary
      9. 9. Monitoring Performance Regressions
        1. Profiling and measurement
        2. Testing
          1. Automated testing
          2. Continuous integration
          3. Slow testing
          4. Fixing performance regressions
          5. Load testing
          6. Realism
            1. Realistic environments
            2. Realistic workloads
              1. Feature switching
          7. Experimenting for science
          8. A/B testing
          9. User interface testing
            1. Web UI testing tools
            2. Automating UI performance tests
        3. Staying alert
        4. DevOps
          1. DevOps tooling
            1. Provisioning
            2. Monitoring
        5. Hosting
        6. Summary
      10. 10. The Way Ahead
        1. Reviewing what we learned
        2. Further reading
          1. Going native
          2. Processor architecture
          3. Hardware is hard
          4. Machine learning
          5. Big data and MapReduce
          6. Orleans
          7. Custom transports
          8. Advanced hashing
        3. Library and framework support
        4. The future
        5. Summary
    8. Bibliography