Index

A

• acceptance test / Acceptance tests 
• advanced C#, problems
  • about / Problems
  • LINQ style / 38. Directory size, LINQ style
  • directory size / 38. Directory size, LINQ style, 39. Directory size, PLINQ style
  • PLINQ style / 39. Directory size, PLINQ style
  • DirectoryInfo class / 40. Find files, LINQ style
  • parallel Monte Carlo π / 41. Parallel Monte Carlo π
  • primes, yielding / 42. Yielding primes
  • Fibonacci numbers, yielding / 43. Yielding Fibonacci numbers
  • complex numbers / 44. Complex numbers
• advanced C#, solutions
  • about / Solutions
  • directory size / 38. Directory size, LINQ style, 39. Directory size, PLINQ style
  • LINQ style / 38. Directory size, LINQ style, 40. Find files, LINQ style
  • PLINQ style / 39. Directory size, PLINQ style
  • DirectoryInfo class / 40. Find files, LINQ style
  • parallel Monte Carlo π / 41. Parallel Monte Carlo π
  • primes, yielding / 42. Yielding primes
  • Fibonacci numbers, yielding / 43. Yielding Fibonacci numbers
  • complex numbers / 44. Complex numbers
• API calls
  • verifying, into service / Verify the API calls into the service
  • TestServer / TestServer
  • ServerFixture / ServerFixture
• API project
  • configuring / Configuring the API project
  • integration test project / Integration test project
  • test, creating / Where to begin?
  • repository calls, verifying into DB context / Verifying the repository calls into the DB context
  • service calls, verifying through repository / Verify that the service calls the DB through the repository
  • API calls, verifying into service / Verify the API calls into the service
• API service
  • unit testing / Unit-testing an API service
  • implementing / Implementing a real API service
  • mock API, replacing / Replacing the mock API with the real API service
  • Sinon, used to mock Ajax responses / Using Sinon to mock Ajax responses
  • application configuration / Application configuration
• application configuration / Application configuration
• Application Secrets
  • used, for storing sensitive information / Storing sensitive information using Application Secrets
• argument / 44. Complex numbers
• arrowheads / 9. Arrowheads, 9. Arrowheads
• ASP.NET Core 2.0
  • about / What comes with ASP.NET Core 2.0
  • Razor pages / ASP.NET Core Razor Pages
  • simplified configuration, for Application Insights / Simplified configuration for Application Insights
• ASP.NET core APIs
  • protecting / Protecting ASP.NET Core APIs
• ASP.NET Core application
  • SSL (Secure Socket Layer), enabling in / Enabling SSL in an ASP.NET Core application
  • CORS, enabling in / Enabling CORS in the ASP.NET Core application
  • properties, adding in user table / Adding more properties in the user table
• ASP.NET Core Identity framework
  • using, for authentication / Using ASP.NET Core Identity for authentication and authorization, Authentication
  • using, for authorization / Using ASP.NET Core Identity for authentication and authorization, Authorization
  • used, for implementing authentication / Implementing authentication and authorization using the ASP.NET Core Identity framework
  • used, for implementing authorization / Implementing authentication and authorization using the ASP.NET Core Identity framework
• ASP.NET Core Razor Pages
  • about / ASP.NET Core Razor Pages
  • automatic page and view compilation, on publishing / Automatic Page and View compilation on publishing
• asynchronous programming
  • versus multithreading / Multithreading versus asynchronous programming
• Asynchronous Programming Model (APM) / Implementing TAP with greater control over Task
• Async Main / Async Main
• augmented matrix / 5. Gaussian elimination
• authentication
  • about / Authentication and authorization
  • implementing, ASP.NET Core Identity framework used / Implementing authentication and authorization using the ASP.NET Core Identity framework
• authorization
  • about / Authentication and authorization
  • implementing, ASP.NET Core Identity framework used / Implementing authentication and authorization using the ASP.NET Core Identity framework

B

• backsolving / 5. Gaussian elimination
• Base Class libraries (BCL) / Evolution of .NET
• bases / 8. Trapezoid rule integration
• Behavior Driven Development (BDD) / An alternative approach , Jest
• BenchmarkDotNet
  • exploring / Exploring BenchmarkDotNet
  • working / How it works
  • parameters, setting / Setting parameters
  • memory diagnostics / Memory diagnostics using BenchmarkDotnet
  • configurations, adding / Adding configurations
  • reference / Adding configurations
• bisection root-finding / 3. Bisection root-finding
• bugs
  • fixing / Fixing bugs 

C

• C# 7.0
  • features / New features in C# 7.0
• C# 7.1
  • Razor support / Razor support for C# 7.1
• Caesar cipher / 45. Caesar cipher, 45. Caesar cipher
• Chai
  • about / Mocha and Chai, Chai
  • configuring / Configuring to use Mocha and Chai, Configuring Mocha, Chai, Enzyme, and Sinon 
• checklist, for migrating .NET Core 1.x to 2.0
  • .NET Core 2.0 installation / 1. Install .NET Core 2.0
  • TargetFramework, upgrading / 2. Upgrade TargetFramework
  • .NET Core SDK version, updating / 3. Update .NET Core SDK version
  • .NET Core CLI, updating / 4. Update .NET Core CLI
  • changes, in ASP.NET Core Identity / Changes in ASP.NET Core Identity
• circle-circle intersection / 16. Circle-circle intersection, 16. Circle-circle intersection
• circle-line tangents / 17. Circle-line tangents, 17. Circle-line tangents
• circle selection / 14. Circle selection, 14. Circle selection
• code kata
  • about / Code katas
  • setting up / A quick kata to check our test setup
  • requisites / The requirements
  • execution / The execution
  • beginning / Starting the kata
• coder decoder (codec) / 37. Compressing images
• Command-Line Interface (CLI) / Exploring .NET Core CLI and New Project Templates
• Comma Separated Value (CSV) / Exploring BenchmarkDotNet
• Common Language Infrastructure (CLI) / Understanding MSIL, CLI, CTS, and CLS
• Common Language Specification (CLS) / Understanding MSIL, CLI, CTS, and CLS
• Common Type System (CTS) / Understanding MSIL, CLI, CTS, and CLS
• connections
  • pooling, in Entity Framework Core 2.0 / Pooling connections in Entity Framework Core 2.0
• constant pattern / Constant pattern
• convexity testing / 20. Convexity testing, 20. Convexity testing
• convex polygon / 20. Convexity testing
• CoreCLR
  • about / CoreCLR
  • working / How the CLR works
• CoreFX / CoreFX
• Create React App
  • about / Create React App, What is Create React App?
  • global module, installing / Installing the global module
  • creating / Creating a React application
  • script, executing / Running the Create React App script
  • ejecting / Ejecting the React app
• Cross-Origin Resource Sharing (CORS)
  • enabling, in ASP.NET Core application / Enabling CORS in the ASP.NET Core application
• cross product / 19. Point in a polygon
• Cryptographically Secure Pseudorandom Number Generator (CSPRNG) / 47. Cryptographic pseudorandom numbers
• Cryptographic Pseudorandom Number Generator (CPRNG) / 47. Cryptographic pseudorandom numbers, 47. Cryptographic random numbers
• cryptography, problems
  • Caesar cipher / 45. Caesar cipher
  • Vigenère cipher / 46. Vigenère cipher
  • cryptographic pseudorandom numbers / 47. Cryptographic pseudorandom numbers
  • primes, searching / 48. Find primes
  • hash files / 49. Hash files
  • steganography / 50. Steganography
  • strings, encrypting / 51. Encrypt and decrypt strings
  • strings, decrypting / 51. Encrypt and decrypt strings
  • files, encrypting / 52. Encrypt and decrypt files
  • files, decrypting / 52. Encrypt and decrypt files
  • CryptoPad / 53. CryptoPad
• cryptography, solutions
  • about / Solutions
  • Caesar cipher / 45. Caesar cipher
  • Vigenère cipher / 46. Vigenère cipher
  • cryptographic random numbers / 47. Cryptographic random numbers
  • primes, searching / 48. Find primes
  • hash files / 49. Hash files
  • steganography / 50. Steganography
  • strings, encrypting / 51. Encrypt and decrypt strings
  • strings, decrypting / 51. Encrypt and decrypt strings
  • files, decrypting / 52. Encrypt and decrypt files
  • files, encrypting / 52. Encrypt and decrypt files
  • CryptoPad / 53. CryptoPad
• CryptoPad / 53. CryptoPad, 53. CryptoPad
• CSRF (Cross-Site Request Forgery) attacks
  • preventing / Preventing CSRF (Cross-Site Request Forgery) attacks

D

• dataflow pattern / Dataflow pattern
• debug mode
  • versus release mode / How releasing builds increases performance
• Dependency Injection
  • about / Dependency Injection
  • static / Static
  • singleton / Singleton
  • global state / Global state
• Dependency Injection (DI) / Pooling connections in Entity Framework Core 2.0, Implementing circuit breaker
• Dependency Inversion principle / The Dependency Inversion principle
• discriminant / 15. Line-circle intersection
• dot product / 19. Point in a polygon
• dummies / Dummies
• dummy logger
  • about / Dummy logger
  • example, in C# / Example in C#
  • example, in JavaScript / Example in JavaScript

E

• early tests
  • gold standard tests / Gold standard tests
  • potential outcomes , testing / Testing all potential outcomes 
• end-to-end integration tests
  • about / End-to-end integration tests
  • benefits / Benefits
  • detriments / Detriments
  • performing / How much end-to-end testing should you do?
• Entity Framework Core 2.0
  • connections, pooling / Pooling connections in Entity Framework Core 2.0
• Enzyme
  • about / Enzyme
  • configuring / Configuring Mocha, Chai, Enzyme, and Sinon 
• Event-based Asynchronous Pattern (EAP) / Implementing TAP with greater control over Task

F

• fakes
  • about / Fakes
  • example, in C# / Example in C#
  • example, in JavaScript / Example in JavaScript
• features, C# 7.0
  • tuples / Tuples
  • patterns / Patterns
  • reference returns / Reference returns
  • expression bodied member extended / Expression bodied member extended
  • Local Functions / Creating Local Functions
  • out variables / Out variables
  • Async Main / Async Main
• files
  • encrypting / 52. Encrypt and decrypt files, 52. Encrypt and decrypt files
  • decrypting / 52. Encrypt and decrypt files, 52. Encrypt and decrypt files
• files, problems
  • about / Problems
  • blank lines, removing / 29. Removing blank lines
  • directory size / 30. Directory size
  • duplicate files, finding / 31. Finding duplicate files
  • thumbnails / 32. Thumbnails
  • thumbnails web page / 33. Thumbnail web page
  • directory, searching / 34. Find files
  • Find and Replace / 35. Find and Replace
  • images, saving / 36. Saving images
  • images, compressing / 37. Compressing images
• files, solution
  • about / Solutions
  • blank lines, removing / 29. Removing blank lines
  • directory size / 30. Directory size
  • duplicate files, finding / 31. Finding duplicate files
  • thumbnails / 32. Thumbnails
  • thumbnails web page / 33. Thumbnail web page
  • directory, searching / 34. Find files
  • Find and Replace / 35. Find and Replace
  • images, saving / 36. Saving images
  • images, compressing / 37. Compressing images
• First In First Out (FIFO) / The thread pool in .NET
• FizzBuzz
  • about / FizzBuzz, FizzBuzz
  • new requirement / A new feature
  • number not found error / Number not found
• fragile tests
  • about / Fragile tests
  • false positives / False positives and false failures
  • false failures / False positives and false failures
  • abstract DateTime / Abstract DateTime
• framework-dependent deployments (FDDs) / How the CLR works
• Framework Class Library (FCL) / Evolution of .NET

G

• garbage collection (GC)
  • about / CoreCLR, Garbage collection
  • generations / Generations in GC
• Gaussian elimination / 5. Gaussian elimination, 5. Gaussian elimination
• geometry, problems
  • about / Problems
  • Monte Carlo π / 1. Monte Carlo π
  • Newton's π / 2. Newton's π
  • bisection root-finding / 3. Bisection root-finding
  • Newton's method / 4. Newton's method
  • Gaussian elimination / 5. Gaussian elimination
  • Monte Carlo integration / 6. Monte Carlo integration
  • rectangle rule integration / 7. Rectangle rule integration
  • trapezoid rule integration / 8. Trapezoid rule integration
  • arrowheads / 9. Arrowheads
  • line-line intersection / 10. Line-line intersection
  • point-line distance / 11. Point-line distance
  • point-segment distance / 12. Point-segment distance
  • segment-segment distance / 13. Segment-segment distance
  • circle selection / 14. Circle selection
  • line-circle intersection / 15. Line-circle intersection
  • circle-circle intersection / 16. Circle-circle intersection
  • circle-line tangents / 17. Circle-line tangents
  • polygon area / 18. Polygon area
  • point in polygon / 19. Point in a polygon
  • convexity testing / 20. Convexity testing
  • stars / 21. Stars
• geometry, solutions
  • about / Solutions
  • Monte Carlo π / 1. Monte Carlo π
  • Newton's π / 2. Newton's π
  • bisection root-finding / 3. Bisection root-finding
  • Newton's method / 4. Newton's method
  • Gaussian elimination / 5. Gaussian elimination
  • Monte Carlo integration / 6. Monte Carlo integration
  • rectangle rule integration / 7. Rectangle rule integration
  • trapezoid rule integration / 8. Trapezoid rule integration
  • arrowheads / 9. Arrowheads
  • line-line intersection / 10. Line-line intersection
  • point-line distance / 11. Point-line distance
  • point-segment distance / 12. Point-segment distance
  • segment-segment distance / 13. Segment-segment distance
  • circle selection / 14. Circle selection
  • line-circle intersection / 15. Line-circle intersection
  • circle-circle intersection / 16. Circle-circle intersection
  • circle-line tangents / 17. Circle-line tangents
  • polygon area / 18. Polygon area
  • point in polygon / 19. Point in a polygon
  • convexity testing / 20. Convexity testing
  • Stars / 21. Stars
• Gherkin
  • about / Gherkin 
  • Given / Givens 
  • When / When 
  • Then / Then 

H

• hashing / 49. Hash files, 49. Hash files
• Hello World
  • about / Hello World
  • requirements / A change in requirements
  • good evening feature / Good evening 
• HTTP strict transport security header
  • adding / Adding the HTTP strict transport security header
  • X-Content-Type-Options header, adding / Adding the X-Content-Type-Options header
  • X-Frame-Options header, adding / Adding the X-Frame-Options header
  • X-Xss-Protection header, adding / Adding the X-Xss-Protection header
  • Content-Security-Policy header, adding / Adding the Content-Security-Policy header
  • referrer-policy header, adding / Adding the referrer-policy header

I

• immutable / 44. Complex numbers
• initialization vector (IV) / 51. Encrypt and decrypt strings
• Integrated Development Environment (IDE) / Writing quality code
• Integrated Development Environment (IDEs)
  • downloading / Downloading the IDE
  • about / A quick introduction to JavaScript IDEs
• integration / 6. Monte Carlo integration
• integration test / Integration tests 
• integration test project / Integration test project
• Interface Segregation principle / The Interface Segregation Principle
• Intermediate Language (IL) / Understanding MSIL, CLI, CTS, and CLS
• issues, preventing test addition
  • about / Issues that prevent adding tests 
  • Law of Demeter / Law of Demeter
  • constructor / Work in the constructor
  • global state / Global state
  • static methods / Static methods
  • large classes and functions / Large classes and functions 
• issues, resulting from legacy code
  • unintended side effects / Unintended side effects
  • over-optimization / Over-optimization
  • overly clever code / Overly clever code
  • third-party software, tight coupling / Tight coupling to third-party software

J

• JavaScript IDEs
  • about / A quick introduction to JavaScript IDEs
  • VS Code, installing / Visual Studio Code
  • WebStorm / WebStorm
  • Create React App / Create React App
  • Mocha / Mocha and Chai
  • Chai / Mocha and Chai
  • code kata, setting up / A quick kata to check our test setup
• Jest / Jest
• JIT compilation / .NET Native and JIT compilation
• Just In Time (JIT) compiler / RyuJIT compiler in .NET Core, CoreCLR

L

• legacy code
  • about / What is legacy code?
  • shortcomings / Why does code go bad?
  • on project / When does a project become a legacy?
  • preventing / What can be done to prevent legacy decay?
  • resulting issues / Typical issues resulting from legacy code
  • Open Closed Principle / Open Closed Principle and legacy code
  • Liskov Substitution Principle / Liskov Substitution Principle and legacy code
  • inheriting / Inheriting code
  • Mastermind game / The game
  • change, requesting / A change is requested
  • transferring / Life sometimes hands you lemons
  • working with / Getting started
  • third-party class, abstracting / Abstracting a third-party class
  • unexpected input / Unexpected Input
  • customizing / Final beautification
  • enhancements / Ready for enhancements
• legacy problems
  • dealing with / Dealing with legacy problems
  • safe refactoring / Safe refactoring
  • early tests / Early tests
• legs / 8. Trapezoid rule integration
• line-circle intersection / 15. Line-circle intersection, 15. Line-circle intersection
• line-line intersection / 10. Line-line intersection, 10. Line-line intersection
• Liskov Substitution Principle (LSP)
  • about / The Liskov Substitution principle, Unintended side effects
  • URL / The Liskov Substitution principle
• Live Static Code analysis / Writing quality code
• Local Functions / Creating Local Functions
• Long Term Support (LTS) / Installing Node

M

• Markdown Documentation (MD) / Exploring BenchmarkDotNet
• Mastermind class / Making sense of the madness
• memory diagnostics
  • with BenchmarkDotnet / Memory diagnostics using BenchmarkDotnet
• Microsoft Intermediate Language (MSIL) / Understanding MSIL, CLI, CTS, and CLS
• midpoint rule / 7. Rectangle rule integration
• Mocha
  • about / Mocha and Chai, Mocha
  • configuring / Configuring to use Mocha and Chai, Configuring Mocha, Chai, Enzyme, and Sinon 
• mock API service / A mock API service
• mocking frameworks / Mocking frameworks
• mocks
  • about / Mocks
  • example, in C# / Example in C#
  • examples, in JavaScript / Example in JavaScript
• Model View Controller (MVC) / Evolution of .NET
• modulus / 44. Complex numbers
• Monte Carlo algorithm / 1. Monte Carlo π, 1. Monte Carlo π
• Monte Carlo integration / 6. Monte Carlo integration, 6. Monte Carlo integration
• multiple cores, of CPU
  • utilizing, for high performance / Utilizing multiple cores of the CPU for high performance
• Multipurpose Internet Mail Extensions (MIME) / 37. Compressing images
• multithreading
  • versus asynchronous programming / Multithreading versus asynchronous programming
  • using, in .NET Core / Multithreading in .NET Core
  • limitations / Multithreading caveats
  • thread synchronization / Thread synchronization
  • task parallel library (TPL) / Task parallel library (TPL)
  • parallel programming, design patterns / Design patterns for parallel programming

N

• .NET Core
  • benefits / Evolution of .NET
  • about / Evolution of .NET
  • portable deployment / Evolution of .NET
  • self-contained application deployment / Evolution of .NET
  • components / .NET Core internals
  • compilation process / From compilation to execution – Under the hood
  • multithreading / Multithreading in .NET Core
  • threads / Threads in .NET Core
  • threads, creating / Creating threads in .NET Core
  • thread lifetime / Thread lifetime
  • thread pool / The thread pool in .NET
• .NET Core 1.x, migrating to 2.0
  • checklist / Upgrading path from .NET Core 1.x to 2.0
• .NET Core 2.0
  • reference / Evolution of .NET
  • improvements / New improvements in .NET Core 2.0
  • performance improvements / Performance improvements
  • simplified packaging / Simplified packaging
  • applications, benchmarking / Benchmarking .NET Core 2.0 applications
• .NET Core CLI
  • exploring / Exploring .NET Core CLI and New Project Templates
  • commands / Exploring .NET Core CLI and New Project Templates
  • project level commands / Exploring .NET Core CLI and New Project Templates
  • server level commands / Exploring .NET Core CLI and New Project Templates
• .NET Core SDK
  • installing / Installing the .NET Core SDK
  • VS Code, setting up / Getting set up with VS Code
• .NET Core source browser
  • reference / CoreFX
• .NET framework
  • evolution / Evolution of .NET
  • components / Evolution of .NET
• .NET Native / .NET Native and JIT compilation
• .NET Standard
  • about / Understanding .NET Standard
  • versioning / Versioning of .NET Standard
• .NET Standard 2.0
  • improvements / New improvements in .NET Standard 2.0
  • APIs / More APIs in .NET Standard 2.0
  • compatibility mode / Compatibility mode
  • creating / Creating a .NET Standard library
• N-Tiered
  • about / N-Tiered example
  • presentation layer / Presentation layer
  • moq / Moq
  • business layer / Business layer
• New Project Templates
  • exploring / Exploring .NET Core CLI and New Project Templates
• Newton's method / 2. Newton's π, 4. Newton's method
• Newton-Raphson method / 4. Newton's method
• Node
  • about / What is Node?
  • need for / Why do we need Node?
  • installing / Installing Node
  • URL / Installing Node
  • installing, for Linux / Linux
  • installing, for Mac OSX / Mac OSX
  • installing, on Windows / Windows
• Node.js / Node.js
• Node Package Manager (NPM)
  • about / NPM, What is NPM?
  • need for / Why do we need NPM?
  • installing / Installing NPM?
• norm / 44. Complex numbers
• Not a Number (NaN) / 2. Newton's π

O

• OCP (Open Closed Principle) / Unintended side effects
• out variables / Out variables

P

• Parallel.ForEach / Parallel.ForEach
• Parallel LINQ (PLINQ) / Parallel LINQ (PLINQ)
• parallel programming
  • design patterns / Design patterns for parallel programming
  • pipeline pattern / Pipeline pattern
  • dataflow pattern / Dataflow pattern
  • producer/consumer pattern / Producer/consumer pattern
  • Parallel.ForEach / Parallel.ForEach
  • Parallel LINQ (PLINQ) / Parallel LINQ (PLINQ)
• parametric equation / 10. Line-line intersection
• patterns
  • about / Patterns
  • constant patterns / Constant pattern
  • type pattern / Type pattern
  • var pattern / Var pattern
  • reference / Var pattern
• PDD (Pain Driven Development) / What can be done to prevent legacy decay?
• performance improvements, .NET Core 2.0
  • RyuJIT compiler / Performance improvements
  • profile guided optimization / Profile guided optimization
• perpendicular / 9. Arrowheads
• phase / 44. Complex numbers
• pipeline pattern / Pipeline pattern
• point-line distance / 11. Point-line distance, 11. Point-line distance
• point-segment distance / 12. Point-segment distance, 12. Point-segment distance
• point in polygon / 19. Point in a polygon
• polygon area / 18. Polygon area, 18. Polygon area
• Portable Class Libraries (PCL) / Understanding .NET Standard
• portable executable (PE) file / From compilation to execution – Under the hood
• proactive policies
  • about / Proactive policies
  • timeout implementation / Implementing timeout
  • caching implementation / Implementing caching
  • health checks implementation / Implementing health checks
• producer/consumer pattern / Producer/consumer pattern
• profile-guided optimization (PGO) / Profile guided optimization
• pseudorandom techniques / 47. Cryptographic pseudorandom numbers

Q

• quality code
  • writing / Writing quality code

R

• randomization, problems
  • about / Problems
  • random doubles / 22. Random doubles
  • random items / 23. Random items
  • Randomize extension / 24. Randomize items
  • ChooseGroup extension methods / 25. Random groups
  • items, selecting with probabilities / 26. Choose items with probabilities
  • random passwords / 27. Random passwords
  • random walks / 28. Random walks
• randomization, solutions
  • random doubles / 22. Random doubles
  • random items / 23. Random items
  • items, randomizing / 24. Randomize items
  • random groups / 25. Random groups
  • items, selecting with probabilities / 26. Choose items with probabilities
  • random passwords / 27. Random passwords
  • random walks / 28. Random walks
• Razor support
  • for C# 7.1 / Razor support for C# 7.1
• React app
  • creating / Creating a React app
  • ejecting / Ejecting the app
  • Mocha, configuring / Configuring Mocha, Chai, Enzyme, and Sinon 
  • Enzyme, configuring / Configuring Mocha, Chai, Enzyme, and Sinon 
  • Chai, configuring / Configuring Mocha, Chai, Enzyme, and Sinon 
  • Sinon, configuring / Configuring Mocha, Chai, Enzyme, and Sinon 
• React component
  • considering / Considering the React component
• reactive policies
  • about / Reactive policies
  • retry pattern, implementing / Implementing the retry pattern
  • circuit breaker, implementing / Implementing circuit breaker
  • circuit breaker, wrapping with retry pattern / Wrapping the circuit breaker with retry
  • fallback policy, with circuit breaker and retry / Fallback policy with circuit breaker and retry
• rectangle rule / 7. Rectangle rule integration
• rectangle rule integration / 7. Rectangle rule integration
• Redux testability
  • about / Looking at Redux testability
  • store / The store
  • actions / Actions
  • reducers / Reducers
• release build / How releasing builds increases performance
• release mode
  • versus debug mode / How releasing builds increases performance
• repository calls
  • verifying, into DB context / Verifying the repository calls into the DB context
  • InMemory database / InMemory database
  • speakers, adding to InMemory database / Adding speakers to the InMemory database
• resilient applications / Introduction to resilient applications
• resilient policies
  • about / Resilient policies
  • reactive policies / Reactive policies
  • proactive policies / Proactive policies
• Riemann sum / 7. Rectangle rule integration
• root-finding algorithms / 3. Bisection root-finding
• row operation / 5. Gaussian elimination
• RyuJIT compiler / RyuJIT compiler in .NET Core

S

• safe refactoring
  • about / Safe refactoring
  • values, converting to variables / Converting values to variables
  • method, extracting / Extracting a method
  • class, extracting / Extracting a class
  • third-party libraries, abstracting / Abstracting third-party libraries and framework code
  • framework code, abstracting / Abstracting third-party libraries and framework code
• security headers
  • reinforcing / Reinforcing security headers
• segment-segment distance / 13. Segment-segment distance, 13. Segment-segment distance
• self-contained deployments (SCDs) / How the CLR works
• service calls
  • verifying, through repository / Verify that the service calls the DB through the repository
  • ContextFixture / ContextFixture
• Single Page Application (SPA) / What is Speaker Meet?
• Single Responsibility Principle (SRP) / The Single Responsibility Principle
• Sinon
  • about / Sinon
  • configuring / Configuring Mocha, Chai, Enzyme, and Sinon 
  • used, to mock Ajax responses / Using Sinon to mock Ajax responses
  • existing tests, fixing / Fixing existing tests
  • server, mocking / Mocking the server
• Software Development Life Cycle (SDLC) / Big design up front
• SOLID principles
  • about / The SOLID principles
  • URL / The SOLID principles
  • Single Responsibility Principle / The Single Responsibility Principle
  • Open/Closed principle / The Open/Closed principle
  • Liskov Substitution principle (LSV) / The Liskov Substitution principle
  • Interface Segregation principle / The Interface Segregation Principle
  • Dependency Inversion principle / The Dependency Inversion principle
• Speaker listing
  • about / Speaker listing
  • mock API service / A mock API service
  • get all speakers action / The Get All Speakers action
  • standard action, testing / Testing a standard action
  • thunk, testing / Testing a thunk
  • get all speakers reducer / The Get All Speakers reducer
  • component / The Speaker listing component
• Speaker Meet
  • about / What is Speaker Meet?
  • Web API project / Web API project
  • Speakers (API), listing / Listing Speakers (API)
  • spliting / Breaking down Speaker Meet
  • speakers / Speakers
  • communities / Communities
  • conferences / Conferences
  • technical requisites / Technical requirements
• Speaker Meet application
  • changes / Changes to Speaker Meet
  • backend, changes / Changes to the back-end
  • frontend, changes / Changes to the front-end 
  • speakers, sorted by rating on client side / Sorted by rating on client side
  • changes, implementing / What now?
  • premature optimization / Premature optimization
• speakers
  • mock API Service, adding / Speaker detail
  • Get speaker action / The Get Speaker action
  • Get Speaker reducer / The Get Speaker reducer
  • Speaker Detail component / The Speaker Detail component
• Speakers (API)
  • listing / Listing Speakers (API)
  • requisites / Requirements
  • test file / A new test file
• spies
  • about / Spies
  • example, in C# / Example in C#
  • example, in JavaScript / Example in JavaScript
• SSL (Secure Socket Layer)
  • about / SSL (Secure Socket Layer)
  • enabling, in ASP.NET Core application / Enabling SSL in an ASP.NET Core application
• Stars / 21. Stars
• steganography / 50. Steganography, 50. Steganography
• strings
  • encrypting / 51. Encrypt and decrypt strings, 51. Encrypt and decrypt strings
  • decrypting / 51. Encrypt and decrypt strings, 51. Encrypt and decrypt strings
• stubs
  • about / Stubs
  • example, in C# / Example in C#
  • example, in JavaScript / Example in JavaScript

T

• task / Utilizing multiple cores of the CPU for high performance
• task-based asynchronous pattern (TAP)
  • about / Task-based asynchronous pattern (TAP)
  • naming convention / Naming convention
  • return type / Return type
  • parameters / Parameters
  • exceptions / Exceptions
  • task status / Task status
  • task cancellation / Task cancellation
  • task progress reporting / Task progress reporting
  • implementing, with compilers / Implementing TAP using compilers
  • implementing, with control over Task / Implementing TAP with greater control over Task
• task parallel library (TPL)
  • about / Utilizing multiple cores of the CPU for high performance, Task parallel library (TPL)
  • reference / Utilizing multiple cores of the CPU for high performance
  • used, for creating task / Creating a task using TPL
  • Task-based asynchronous pattern (TAP) / Task-based asynchronous pattern (TAP)
  • TAP, implementing with compilers / Implementing TAP using compilers
  • TAP, implementing with control over Task / Implementing TAP with greater control over Task
• test
  • types / Different types of test
  • unit test / Unit tests 
  • acceptance test / Acceptance tests 
  • integration test / Integration tests 
  • end-to-end test / End to end tests 
  • requisites / Requirements 
  • in C# / Our first tests in C#
  • application, growing / Growing the application with tests
  • in JavaScript / Our first tests in JavaScript
• test, requisites
  • about / Why are they important? 
  • user story / User stories 
  • Gherkin / Gherkin 
• Test-Driven Development (TDD)
  • about / First, a little background, John's story on TDD, Clayton's story on TDD, So, what is TDD?, Where to begin, A clean slate
  • approach / An approach to TDD 
  • alternative approach / An alternative approach 
  • process / The process, Red, green, and refactor, Coder's block
  • validating / Why should we care?
  • arguments / Arguments against TDD, Arguments in favor of TDD
  • testing / Testing takes time, Testing is expensive, Testing is difficult, We don't know how, Test small, When testing is painful
  • manual testing, reducing / Reduces the effort of manual testing
  • bug count, reducing / Reduces bug count
  • level of correctness, ensuring / Ensures some level of correctness
  • refactoring, removing / Removes the fear of refactoring
  • architecture / A better architecture 
  • development / Faster development 
  • code, writing / Why does it matter?
  • monolithic application, developing / One bite at a time
  • Minimum Viable Product / Minimum Viable Product
  • recover approach / Different mindset
  • method / YAGNI – you aren't gonna need it
  • test, executing / Devil's advocate
  • negative cases, testing / Test negative cases first
  • spike / A spike
  • assert / Assert first
  • organized / Stay organized
• test doubles / Test doubles
• test double types
  • about / Test double types
  • dummies / Dummies
  • dummy logger / Dummy logger
  • stubs / Stubs
  • spies / Spies
  • mocks / Mocks
  • fakes / Fakes
• third-party software
  • abstracting / Abstracting third-party software
• thread synchronization
  • about / Thread synchronization
  • monitors / Monitors
• timely greeting / Timely greeting
• TLS (Transport Level Security) / Adding the HTTP strict transport security header
• TODO app
  • about / TODO app  
  • mark complete / Mark complete
  • tests, adding / Adding tests, Adding tests
  • production code / Production code, Production code
  • task removal, avoiding / But don't remove from the list!
• trapezoid / 8. Trapezoid rule integration
• trapezoid rule integration / 8. Trapezoid rule integration
• tuples
  • characteristics / Tuples
• type
  • quantity / Quantity of each test type 
• type pattern / Type pattern

U

• UML (Unified Modeling Language) / When does a project become a legacy?
• unit test
  • about / Unit tests 
  • parts / Parts of a unit test
  • arrange / Arrange
  • act / Act
  • assert / Assert
• Universal Windows Platform (UWP) / Understanding .NET Standard, .NET Native and JIT compilation
• unsafe refactoring / Free to do unsafe refactoring 
• user story
  • about / User stories 
  • Role / Role 
  • Request / Request 
  • Reason / Reason 

V

• var pattern / Var pattern
• Vigenère cipher / 46. Vigenère cipher, 46. Vigenère cipher
• Visual Studio Community
  • setting up / Setting up Visual Studio Community
  • downloading / Downloading Visual Studio Community
  • installing / Installing Visual Studio Community
• VS Code
  • IDE, downloading / Downloading the IDE
  • installing / Installing the VS Code, Installing Visual Studio Code
  • extensions, adding / Adding extensions
  • project, creating / Creating a project in VS Code
  • about / Why Visual Studio Code?
  • installing, on Linux / Linux
  • installing, on Mac / Mac
  • installing, on Windows / Windows
  • plugins, installing / Installing the plugins you will need
  • testing environment, configuring / Configuring the testing environment

W

• watermarking / 50. Steganography
• Web API project / Web API project
• WebStorm
  • about / WebStorm, Why WebStorm?
  • installing / Installing WebStorm
  • installing, on Linux / Linux
  • installing, on Mac / Mac
  • installing, on Windows / Windows
  • plugins, installing / Installing the plugins you will need
  • testing environment, configuring / Configuring the testing environment
• Windows Presentation Foundation (WPF) / Understanding .NET Standard

X

• xUnit
  • switching / Switching to xUnit
  • code kata / Code katas
  • test project, creating / Creating the test project
  • Given3ThenFizz test / The Given3ThenFizz test
  • Given5ThenBuzz test / The Given5ThenBuzz test
  • Given15ThenFizzBuzz test / The Given15ThenFizzBuzz test
  • Given1Then1 test / The Given1Then1 test
  • theories / Theories
  • FizzBuzz Problem, solution / Solution to the FizzBuzz Problem

Y

• yak shaving
  • about / Yak shaving
  • big design / Big design up front