Tabla de Contenidos: “…Support Infrastructure; 4.1.2. Dynamic Locking Callbacks; 4.2. Internal Error Handling; 4.2.2. Human-Readable Error Messages; 4.2.3. …”

Tabla de Contenidos: “…Scope; 5.4.7. Acts; 5.4.8. Callbacks; 5.4.9. Observers; 5.4.10. Migration; 5.5. …”

Tabla de Contenidos: “…The specialization of effect types -- An application with multiple side effects -- Asynchrony -- The side effect of errors -- Monad Transformers -- Generalizing the pattern -- Tagless Final -- Programming to capabilities -- Implementations -- Execution semantics abstraction -- Computation as a value -- Free Monad -- Type-level programming -- A naive implementation of the heterogeneous list -- Type-level solution to the heterogeneous list problem -- Reclusive implicit resolution -- Debugging type-level computations -- Libraries for type-level programming -- Summary -- Questions -- Chapter 11: Introduction to the Actor Model -- Overview of parallelism solutions -- Traditional model synchronization on monitors -- Synchronization -- Problems with the traditional model - race conditions and deadlocks -- The actor model as a replacement for the traditional model -- Deadlock example revisited -- Summary -- Questions -- Chapter 12: The Actor Model in Practice -- Akka overview -- Principles of Akka -- Encapsulation -- Messaging -- No leaking of mutable state -- Fault-tolerance and supervision -- Messaging guarantees -- Asynchrony -- Defining, creating, and messaging actors -- Callbacks -- Supervision -- Context and references -- Managing the actor hierarchy -- Managing the life cycle -- Supervision -- Creating actors -- Actor parameters -- Working with actor systems -- Task specification -- Implementation -- Summary -- Questions -- Chapter 13: Use Case - A Parallel Web Crawler -- Problem statement -- The graph structure of the web -- Collecting information from the graph -- Parallel nature of the task -- Sequential solution -- A parallel solution with Akka -- Strategy -- Implementation -- Caveats -- Visited links -- Fault tolerance -- Counting the responded actors -- Real-world side effects -- Summary -- Appendix A: Introduction to Scala…”

Tabla de Contenidos: “…The Web Components API -- 4.2. The connectedCallback handler -- 4.3. The remaining Web Component lifecycle methods -- 4.4. …”

Tabla de Contenidos: “…Cover -- Title Page -- Copyright and Credit -- Dedicated -- Contributors -- Table of Contents -- Preface -- Part 1: Introducing the Fundamentals -- Chapter 1: Introducing React Anti-Patterns -- Technical requirements -- Understanding the difficulty of building UIs -- Understanding the state management -- Exploring "unhappy paths" -- Errors thrown from other components -- Learning the unexpected user behavior -- Exploring common anti-patterns in React -- Props drilling -- In-component data transformation -- Complicated logic in views -- Lack of tests -- Duplicated code -- Long component with too much responsibility -- Unveiling our approach to demolishing anti-patterns -- Summary -- Chapter 2: Understanding React Essentials -- Technical requirements -- Understanding static components in React -- Creating components with props -- Breaking down UIs into components -- Managing internal state in React -- Understanding the rendering process -- Exploring common React Hooks -- useState -- useEffect -- useCallback -- The React Context API -- Summary -- Chapter 3: Organizing Your React Application -- Technical requirements -- Understanding the problem of a less-structured project -- Understanding the complications of frontend applications -- Exploring common structures in React applications -- Feature-based structure -- Component-based structure -- Atomic design structure -- The MVVM structure -- Keeping your project structure organized -- Implementing the initial structure -- Adding an extra layer to remove duplicates -- Naming files -- Exploring a more customized structure -- Summary -- Chapter 4: Designing Your React Components -- Technical requirements -- Exploring the single responsibility principle -- Don't repeat yourself -- Using composition -- Combining component design principles -- Summary -- Part 2: Embracing Testing Techniques…”

Tabla de Contenidos: “…7.2 Managing multiple to-do lists -- 7.2.1 Implementing a cache -- 7.2.2 Writing tests -- 7.2.3 Analyzing process dependencies -- 7.3 Persisting data -- 7.3.1 Encoding and persisting -- 7.3.2 Using the database -- 7.3.3 Analyzing the system -- 7.3.4 Addressing the process bottleneck -- 7.3.5 Exercise: pooling and synchronizing -- 7.4 Reasoning with processes -- Summary -- 8 Fault-tolerance basics -- 8.1 Runtime errors -- 8.1.1 Error types -- 8.1.2 Handling errors -- 8.2 Errors in concurrent systems -- 8.2.1 Linking processes -- 8.2.2 Monitors -- 8.3 Supervisors -- 8.3.1 Preparing the existing code -- 8.3.2 Starting the supervisor process -- 8.3.3 Child specification -- 8.3.4 Wrapping the supervisor -- 8.3.5 Using a callback module -- 8.3.6 Linking all processes -- 8.3.7 Restart frequency -- Summary -- 9 Isolating error effects -- 9.1 Supervision trees -- 9.1.1 Separating loosely dependent parts -- 9.1.2 Rich process discovery -- 9.1.3 Via tuples -- 9.1.4 Registering database workers -- 9.1.5 Supervising database workers -- 9.1.6 Organizing the supervision tree -- 9.2 Starting processes dynamically -- 9.2.1 Registering to-do servers -- 9.2.2 Dynamic supervision -- 9.2.3 Finding to-do servers -- 9.2.4 Using temporary restart strategy -- 9.2.5 Testing the system -- 9.3 "Let it crash" -- 9.3.1 Processes that shouldn't crash -- 9.3.2 Handling expected errors -- 9.3.3 Preserving the state -- Summary -- 10 Beyond GenServer -- 10.1 Tasks -- 10.1.1 Awaited tasks -- 10.1.2 Non-awaited tasks -- 10.2 Agents -- 10.2.1 Basic use -- 10.2.2 Agents and concurrency -- 10.2.3 Agent-powered to-do server -- 10.2.4 Limitations of agents -- 10.3 ETS tables -- 10.3.1 Basic operations -- 10.3.2 ETS powered key/value store -- 10.3.3 Other ETS operations -- 10.3.4 Exercise: process registry -- Summary -- 11 Working with components -- 11.1 OTP applications…”

Tabla de Contenidos: “…Discussion -- 6.5 Quickly Find a Record in a Linked Table -- Problem -- Solution -- Discussion -- 6.6 Get a Complete List of Field Properties from a Table or Query -- Problem -- Solution -- Discussion -- See Also -- 6.7 Create and Use Flexible AutoNumber Fields -- Problem -- Solution -- Discussion -- 6.8 Back Up Selected Objects to Another Database -- Problem -- Solution -- Discussion -- The MultiSelect property -- Filling the lboObjects list box -- The backup process -- Comments -- VBA -- 7.1 Build Up String References with Embedded Quotes -- Problem -- Solution -- Discussion -- 7.2 Create a Global Procedure Stack -- Problem -- Solution -- Discussion -- 7.3 Create an Execution Time Profiler -- Problem -- Solution -- Steps -- Discussion -- 7.4 Multitask Your VBA Code -- Problem -- Solution -- Discussion -- 7.5 Programmatically Add Items to a List or Combo Box -- Problem -- Solution -- Filling a list box by calling the AddItem method -- Filling a list box by modifying the RowSource property -- Filling a list box by creating a list-filling callback function -- Discussion -- Calling the AddItem method -- Modifying the RowSource property -- Creating a list-filling callback function -- 7.6 Pass a Variable Number of Parameters to a Procedure -- Problem -- Solution -- Discussion -- 7.7 Sort an Array in VBA -- Problem -- Solution -- Discussion -- See Also -- 7.8 Fill a List Box with a List of Files -- Problem -- Solution -- Discussion -- 7.9 Handle Object Properties, in General -- Problem -- Solution -- Discussion -- 7.10 Detect Whether an Object Exists -- Problem -- Solution -- Discussion -- See Also -- Optimization -- 8.1 Accelerate the Load Time of Forms -- Problem -- Solution -- Discussion -- 8.2 Make Slow Forms Run Faster -- Problem -- Solution -- Graphic and memo controls -- Combo and list box controls -- Discussion -- 8.3 Make Combo Boxes Load Faster…”

Tabla de Contenidos: “…-- Using coroutines in real life -- Synchronous implementation -- Callbacks -- Java Futures -- Promises with Kovenant -- Coroutines -- Coroutine context -- Channels -- Channel pipelines -- Managing mutable state -- Switching contexts -- Thread safe structures -- Mutexes -- Actors -- Summary -- Chapter 8: Collections and Data Operations in Kotlin -- An introduction to collections -- The advantages of a collections framework -- List and MutableList -- Set and MutableSet -- Map and MutableMap -- Data operations in a collection -- The map function -- The filter function -- The flatMap function -- The drop functions -- The take functions -- The zip function -- Grouping collections -- Summary…”

Tabla de Contenidos: “…. -- How it works... -- Using callbacks to get the most out of your training cycle -- Getting ready -- How to do it... -- How it works... -- Making your model deployments available to others -- Getting ready -- How to do it... -- How it works... -- Displaying thumbnails in your image classification model deployment -- Getting ready -- How to do it... -- How it works... -- Test your knowledge -- Explore the value of repeatable results -- Displaying multiple thumbnails in your image classification model deployment -- Conclusion and additional resources on fastai -- Other Books You May Enjoy -- Index…”

Tabla de Contenidos: “…-- Installation of tools -- Node.js -- bacon.js -- RxJS -- Your first code using reactive programming -- Summary -- Chapter 2: Reacting for the First Time -- The bacon.js observables -- Creating our first observable -- Observables from DOM events (asEventStream) -- Observables from promises (fromPromise) -- Observable node event emitter (fromEvent) -- Observables from an array (fromArray) -- Observables from an array (sequentially) -- Observables from an interval (interval) -- Observables from other sources -- Properties -- Changes in an observable -- Reacting to changes -- Subscribing -- Subscribing using the onValue() method -- Subscribing using the log method -- Subscribing using the assign method -- Acting when an error occurs -- Reading how an operator works -- Transforming events using bacon.js -- Reusing observables -- Observables' lazy evaluation -- Summary -- Chapter 3: A World Full of Changes - Reactive Extensions to the Rescue -- RxJS observables -- Difference between bacon.js and RxJS observables -- Hot and cold observables -- Installing RxJS -- Creating an observable -- Creating an observable from iterable objects -- Creating an observable from a sequence factory -- Creating an observable using range () -- Creating an observable using period of time -- Creating an observable from callbacks -- Creating an observable from a promise -- Creating empty observables -- Creating an observable from a single value -- Creating an observable from a factory function -- Creating an observable from arbitrary arguments -- Creating an observable from an error -- Creating observables from DOM events (or EventEmitter)…”

Tabla de Contenidos: “…-- OpenFL -- HaxeFlixel -- Installation -- Installing Haxe -- OpenFL -- Setting up an IDE -- Installing HaxeFlixel -- Setting up target platforms -- Flash -- Android -- iOS -- Desktop -- Hello World -- Creating a project -- Running the project -- Copying assets -- Making changes -- Summary -- Chapter 2: Building a New Game -- The Haxe syntax -- Data types and structures -- Operators -- Access modifiers -- Variables -- Functions -- The for loops -- Classes -- Setting up a new HaxeFlixel project -- Creating the new project -- The anatomy of our project -- Changing settings -- Adding assets -- Adding a background and basic UI -- Making enemies -- Creating the enemy class -- Adding variables -- Setting up the display -- Creating the spawn timer -- Instantiating enemies and adding interaction -- Adding new imports -- Adding variables -- Creating instances and adding mouse events -- Creating the end screen -- Creating the end screen class -- Adding variables -- Adding the background and score text -- Restarting the level -- Implementing the game timer -- Importing the end screen -- Adding variables -- Creating the level timer -- Creating the timer callback function -- Summary -- Chapter 3: Dealing with Menus and Screen Flow -- Adding new assets -- Changing the default state -- Building the splash screen -- Adding imports -- Creating variables -- Adding sprites -- Adding instructions -- Starting the animation sequence -- Creating the next stage of the sequence -- Finishing the sequence -- Navigating back to the game -- Updating the level end screen -- Adding imports -- Adding variables -- Housekeeping -- Adding the group and setting up the window -- Adding scores…”

Tabla de Contenidos: “…-- Interrupts, firmware, and I/O -- A simplified overview -- Interrupts -- Firmware -- Summary -- Chapter 2: How Programming Languages Model Asynchronous Program Flow -- Definitions -- Threads -- Threads provided by the operating system -- Creating new threads takes time -- Each thread has its own stack -- Context switching -- Scheduling -- The advantage of decoupling asynchronous operations from OS threads -- Example -- Fibers and green threads -- Each stack has a fixed space -- Context switching -- Scheduling -- FFI -- Callback based approaches -- Coroutines: promises and futures -- Coroutines and async/await -- Summary -- Chapter 3: Understanding OS-Backed Event Queues, System Calls, and Cross-Platform Abstractions -- Technical requirements -- Running the Linux examples…”

Tabla de Contenidos: “…-- Understanding Core Data framework classes -- Using Core Data with SwiftUI -- Creating a Core Data project -- Working with the data model file -- Core Data migrations -- The SQLite data file -- CloudKit -- Summary -- Chapter 13: Modern Structured Concurrency -- A brief introduction to concurrency -- Understanding traditional concurrency mechanisms -- Threads -- Callbacks and event loops -- GCD -- What is structured concurrency? …”

Tabla de Contenidos: “…-- Anonymous functions -- Lambda expressions -- The implicit name of a single parameter -- Higher-order functions -- Providing operations to functions -- Observer (Listener) pattern -- A callback after a threaded operation -- Combination of named arguments and lambda expressions -- The last lambda in an argument convention -- Named code surrounding -- Processing data structures using LINQ style -- Java SAM support in Kotlin -- Named Kotlin function types -- Named parameters in function types -- Type alias -- Underscore for unused variables -- Destructuring in lambda expressions -- Inline functions -- The noinline modifier -- Non-local returns -- Labeled returns in lambda expressions -- Crossinline modifier -- Inline properties -- Function references -- Summary -- Chapter 6: Generics Are Your Friends -- Generics -- The need for generics -- Type parameters versus type arguments -- Generic constraints -- Nullability -- Variance -- Variance modifiers -- Use-site variance versus declaration-site variance…”

Tabla de Contenidos: “…-- Setting up reproducible results -- Summary -- Chapter 2: Training a Prediction Model -- Neural networks in R -- Building neural network models -- Generating predictions from a neural network -- The problem of overfitting data - the consequences explained -- Use case - building and applying a neural network -- Summary -- Chapter 3: Deep Learning Fundamentals -- Building neural networks from scratch in R -- Neural network web application -- Neural network code -- Back to deep learning -- The symbol, X, y, and ctx parameters -- The num.round and begin.round parameters -- The optimizer parameter -- The initializer parameter -- The eval.metric and eval.data parameters -- The epoch.end.callback parameter -- The array.batch.size parameter -- Using regularization to overcome overfitting -- L1 penalty -- L1 penalty in action -- L2 penalty -- L2 penalty in action -- Weight decay (L2 penalty in neural networks) -- Ensembles and model-averaging -- Use case - improving out-of-sample model performance using dropout -- Summary -- Chapter 4: Training Deep Prediction Models -- Getting started with deep feedforward neural networks -- Activation functions -- Introduction to the MXNet deep learning library -- Deep learning layers -- Building a deep learning model -- Use case - using MXNet for classification and regression…”

Tabla de Contenidos: “…Further reading -- Part 2 - Image Classification with TensorFlow -- Chapter 5: Image Classification with Neural Networks -- Technical requirements -- The anatomy of neural networks -- Forward propagation -- Activation functions -- Backward propagation -- Learning rate -- Building an image classifier with a neural network -- Loading the data -- Performing exploratory data analysis -- Building the model -- Compiling the model -- Model visualization -- Model fitting -- Training monitoring -- Evaluating the model -- Model prediction -- Summary -- Questions -- Further reading -- Chapter 6: Improving the Model -- Technical requirements -- Data is key -- Fine-tuning hyperparameters of a neural network -- Increasing the number of epochs -- Early stopping using callbacks -- Adding neurons in the hidden layer -- Changing the optimizers -- Changing the learning rate -- Summary -- Questions -- Further reading -- Chapter 7: Image Classification with Convolutional Neural Networks -- Challenges of image recognition with fully connected networks -- Anatomy of CNNs -- Convolutions -- Impact of the number of filters -- Impact of the size of the filter -- Impact of stride -- The boundary problem -- Impact of padding -- Putting it all together -- Pooling -- The fully connected layer -- Fashion MNIST 2.0 -- Working with real-world images -- Weather dataset classification -- Image data preprocessing -- Summary -- Questions -- Further reading -- Chapter 8: Handling Overfitting -- Technical requirements -- Overfitting in ML -- What triggers overfitting -- Detecting overfitting -- Baseline model -- Early stopping -- Model simplification -- L1 and L2 regularization -- Dropout regularization -- Adjusting the learning rate -- Error analysis -- Data augmentation -- Summary -- Questions -- Further reading -- Chapter 9: Transfer Learning -- Technical requirements…”

Tabla de Contenidos: “…Android N JIT compiler -- Memory leak -- Memory churn -- References -- Memory-side projects -- Project Svelte and Android N -- Best practices -- Data types -- Autoboxing -- Sparse array family -- ArrayMap -- Syntax -- Collections -- Enumerations -- Constants -- Object management -- Strings -- String concatenation -- Local variables -- Arrays versus collections -- Streams -- Memory patterns -- The object pool pattern -- The FlyWeight pattern -- Android component leaks -- Activities -- Services -- Processes -- The memory API -- Main components and memory management -- Debugging tools -- LogCat -- Dalvik -- ART -- The ActivityManager API -- StrictMode -- Dumpsys -- Meminfo -- ProcStats -- Summary -- Chapter 5: Multithreading -- Walkthrough -- Threading basics -- Multicore CPUs -- Threads -- Multithreaded applications -- Thread safety -- Android multithreading environment -- Processes -- Android application thread -- The UI thread -- Worker threads -- The binder thread -- Android thread messaging -- Best practices -- Threads -- HandlerThread -- When to use -- AsyncTask -- Methods -- Generics parameters -- States management -- Executor -- When to use -- Loaders -- LoaderManager -- LoaderCallbacks&lt -- D&gt -- -- Provided loaders -- When to use -- Services -- Life cycle -- Started Service -- Bound Service -- IntentService -- Inter-process communication -- Remote Procedure Call -- AIDL -- Messenger -- Advanced techniques -- BroadcastReceiver asynchronous techniques -- ContentProvider asynchronous techniques -- Repeating tasks -- Debugging tools -- StrictMode -- Summary -- Chapter 6: Networking -- Walkthrough -- Protocols -- Methods -- Headers -- Timeout -- Content -- Compression -- Response code -- Connection types -- Best practices -- Latency gauging -- Batching connections -- Prefetching -- Queuing connections -- Caching responses -- Cache control…”

Tabla de Contenidos: “…Near real-time visualizer/dashboard -- Summary -- Chapter 13: Reactive Programming Using RxJS -- The JS world -- Rx foundations -- RxJS formalism -- Observables and observers -- Observables from arrays -- Observables from events -- Observables from callbacks -- Observable pipeline -- Subject et al. -- Schedulers -- RxJS samples -- Real-time file watcher -- Change galore -- Summary -- Chapter 14: A Road Ahead -- Polyglot programming and design -- Polyglot programming with C/C++ -- The polyglot web programming -- The JavaScript evolution -- Dynamic/scripting languages -- Emergence of functional programming -- Mobile revolution -- A quick note on polyglot persistence -- How to become a polyglot programmer? …”

Tabla de Contenidos: “…-- Solution 2 - using a global flag -- Solution 3 - removing the handler -- Solution 4 - changing the handler -- Solution 5 - disabling the button -- Solution 6 - redefining the handler -- Solution 7 - using a local flag -- A functional solution to our problem -- A higher-order solution -- Testing the solution manually -- Testing the solution automatically -- Producing an even better solution -- Summary -- Questions -- Chapter 3: Starting Out with Functions - A Core Concept -- All about functions -- Of lambdas and functions -- Arrow functions - the modern way -- Functions as objects -- Using functions in FP ways -- Injection - sorting it out -- Callbacks and promises -- Continuation-passing style -- Polyfills -- Stubbing -- Immediate invocation (IIFE) -- Summary -- Questions -- Chapter 4: Behaving Properly - Pure Functions -- Pure functions -- Referential transparency -- Side effects -- Advantages of pure functions -- Impure functions -- Avoiding impure functions -- Is your function pure? …”

Tabla de Contenidos: “…5.1 Updating state without causing a re-render -- 5.1.1 Comparing useState and useRef when updating state values -- 5.1.2 Calling useRef -- 5.2 Storing timer IDs with a ref -- 5.3 Keeping references to DOM elements -- 5.3.1 Setting focus on an element in response to an event -- 5.3.2 Managing a text box via a ref -- Summary -- 6 Managing application state -- 6.1 Passing shared state to child components -- 6.1.1 Passing state from a parent by setting props on the children -- 6.1.2 Receiving state from a parent as a prop -- 6.1.3 Receiving an updater function from a parent as a prop -- 6.2 Breaking components into smaller pieces -- 6.2.1 Seeing components as part of a bigger app -- 6.2.2 Organizing multiple components within a page's UI -- 6.2.3 Creating a BookableDetails component -- 6.3 Sharing the state and dispatch function from useReducer -- 6.3.1 Managing state in the BookablesView component -- 6.3.2 Removing an action from the reducer -- 6.3.3 Receiving state and dispatch in the BookablesList component -- 6.4 Sharing the state value and updater function from useState -- 6.4.1 Managing the selected bookable in the BookablesView component -- 6.4.2 Receiving the bookable and updater function in BookablesList -- 6.5 Passing functions to useCallback to avoid redefining them -- 6.5.1 Depending on functions we pass in as props -- 6.5.2 Maintaining function identity with the useCallback hook -- Summary -- 7 Managing performance with useMemo -- 7.1 Breaking the cook's heart by calling, "O, shortcake!" …”