Livebook sitemap

Deep Learning with JavaScript: Neural Networks in TensorFlow.js MEAP V06
Deep Learning with JavaScript: Neural Networks in TensorFlow.js MEAP V06

Deep learning has transformed the fields of computer vision, image processing, and natural language applications. Thanks to TensorFlow.js, now JavaScript developers can build deep learning apps without relying on Python or R. Deep Learning with JavaScript shows developers how they can bring DL technology to the web. Written by the main authors of the TensorFlow library, this new book provides fascinating use cases and in-depth instruction for deep learning apps in JavaScript in your browser or on Node.

Copyright 2019 Manning Publications
welcome
brief contents
1 Deep Learning and JavaScript
2 Getting Started: Simple Linear Regression in TensorFlow.js
3 Adding Nonlinearity: Beyond Weighted Sums
4 Recognizing Images and Sounds Using Convolutional Neural Networks
5 Transfer Learning: Reusing Pretrained Neural Networks
6 Working with Data
7 Visualizing Data and Models
8 Deep Learning for Sequences and Text
10 Basics of Deep Reinforcement Learning
Appendix A
TypeScript Quickly MEAP V07
Math for Programmers: 3D graphics, machine learning, and simulations with Python MEAP V06
Math for Programmers: 3D graphics, machine learning, and simulations with Python MEAP V06

To score a job in data science, machine learning, computer graphics, and cryptography, you need to bring strong math skills to the party. Math for Programmers teaches the math you need for these hot careers, concentrating on what you need to know as a developer. Filled with lots of helpful graphics and more than 200 exercises and mini-projects, this book unlocks the door to interesting–and lucrative!–careers in some of today’s hottest programming fields.

Copyright 2019 Manning Publications
brief contents
welcome
1 Learning Math in Code
2 Drawing with 2D Vectors
3 Ascending to the 3D World
4 Transforming Vectors and Graphics
5 Computing Transformations with Matrices
6 Generalizing to Higher Dimensions
7 Solving Systems of Linear Equations
8 Simulating Moving Objects
9 Reverse-engineering the laws of physics
A Loading and Rendering 3D Models with OpenGL and PyGame
B Getting set up with Python
Grokking Machine Learning MEAP V02
Grokking Machine Learning MEAP V02

It's time to dispel the myth that machine learning is difficult. Grokking Machine Learning teaches you how to apply ML to your projects using only standard Python code and high school-level math. No specialist knowledge is required to tackle the hands-on exercises using readily-available machine learning tools!

Copyright 2019 Manning Publications
welcome
brief contents
1 What is machine learning?
2 Types of machine learning
3 Drawing a line close to our points: Linear regression
4 Using lines to split our points: The perceptron algorithm
Real-World Natural Language Processing MEAP V01
Real-World Natural Language Processing MEAP V01

Voice assistants, automated customer service agents, and other cutting-edge human-to-computer interactions rely on accurately interpreting language as it is written and spoken. Real-world Natural Language Processing teaches you how to create practical NLP applications without getting bogged down in complex language theory and the mathematics of deep learning. In this engaging book, you’ll explore the core tools and techniques required to build a huge range of powerful NLP apps.

Copyright 2019 Manning Publications
welcome
brief contents
1 Introduction to Natural Language Processing
2 Your First NLP Application
3 Word and Document Embeddings
Deep Learning for Vision Systems MEAP V04
Deep Learning for Vision Systems MEAP V04

Computer vision is central to many leading-edge innovations, including self-driving cars, drones, augmented reality, facial recognition, and much, much more. Amazing new computer vision applications are developed every day, thanks to rapid advances in AI and deep learning (DL). Deep Learning for Vision Systems teaches you the concepts and tools for building intelligent, scalable computer vision systems that can identify and react to objects in images, videos, and real life. With author Mohamed Elgendy’s expert instruction and illustration of real-world projects, you’ll finally grok state-of-the-art deep learning techniques, so you can build, contribute to, and lead in the exciting realm of computer vision!

Copyright 2019 Manning Publications
welcome
brief contents
Table of Contents
1 Welcome to Computer Vision
2 Deep learning and neural networks
3 Convolutional Neural Networks (CNNs)
4 Structuring Deep Learning Projects and Hyperparameters tuning
5 Advanced CNN Architectures
6 Transfer Learning
Object Design Style Guide MEAP V01
Object Design Style Guide MEAP V01

Objects are the central concept of languages like Java, Python, C#. Applying best practices for object design means that your code will be easy to read, write, and maintain. Object Design Style Guide captures dozens of techniques for creating pro-quality OO code that can stand the test of time. Examples are in an instantly-familiar pseudocode, teaching techniques you can apply to any OO language, from C++ to PHP.

About this MEAP
Welcome
1 Creating services
2 Creating other objects
3 Manipulating objects
4 Using objects
5 Retrieving information
6 Performing tasks
7 Dividing responsibilities
8 Changing the behavior of services
9 A field guide to objects
10 Epilogue
MEAP VERSION 1
Front Matter
A Coding standard for the code samples
Web Components in Action MEAP V08
Web Components in Action MEAP V08

Web components are a standardized way to build reusable custom elements for web pages and applications using HTML, CSS, and JavaScript. A web component is well-encapsulated, keeping its internal structure separate from other page elements so they don’t collide with the rest of your code. In Web Components in Action you’ll learn to design, build, and deploy reusable web components from scratch.

Copyright 2019 Manning Publications
welcome
brief contents
Part 1: First steps
1 The framework without a framework
2 Your first Web Component
3 Making your component reuseable
4 The component lifecycle
5 Instrumenting a better web app through modules
Part 2: Ways to improve your component workflow
6 Markup managed
7 Templating your content with HTML
8 The Shadow DOM
9 Shadow CSS
10 Shadow CSS rough edges
Part 3: Putting your components together
11 A real-world UI component
12 Building and supporting older browsers
13 Component testing
14 Events and application data flow
15 Hiding your complexities
A ES2015 for Web Components
Microservices Security in Action MEAP V03
Microservices Security in Action MEAP V03

Unlike traditional enterprise applications, Microservices applications are collections of independent components that function as a system. Securing the messages, queues, and API endpoints requires new approaches to security both in the infrastructure and the code. Microservices Security in Action teaches you how to address microservices-specific security challenges throughout the system. This practical guide includes plentiful hands-on exercises using industry-leading open-source tools and examples using Java and Spring Boot.

Copyright 2019 Manning Publications
welcome
brief contents
1 Welcome to microservices security
2 Hello World microservices security
3 Deploying a microservice behind an API gateway
4 Building a single-page application to talk to microservices
5 Engaging throttling, monitoring, and access control
6 Securing service-to-service communication with certificates
Human-in-the-Loop Machine Learning MEAP V01
Human-in-the-Loop Machine Learning MEAP V01

How humans and machines should work together to solve problems is one of the most important questions in technology. However, in machine learning, the accuracy of innovative algorithms often end up with the most attention. But to build the most accurate model quickly you also need clean, relevant, correctly-labeled data for your system to train on. Human-in-the-Loop Machine Learning is a practical guide to optimizing the entire machine learning process, including techniques for annotation, sampling, and even using ML systems to help automate the process.

Copyright 2019 Manning Publications
welcome
brief contents
1 Introduction to Human-in-the-Loop Machine Learning
2 Getting Started with Human-in-the-Loop Machine Learning
3 Uncertainty Sampling
Mastering Large Datasets with Python: Parallelize and Distribute your Python Code MEAP V04
Mastering Large Datasets with Python: Parallelize and Distribute your Python Code MEAP V04

Modern data science solutions need to be clean, easy to read, and scalable. In Mastering Large Datasets with Python, author J.T. Wolohan teaches you how to take a small project and scale it up using a functionally-influenced approach to Python coding. You’ll explore methods and built-in Python tools that lend themselves to clarity and scalability, like the high-performing parallelism method, as well as distributed technologies that allow for high data throughput. The abundant hands-on exercises in this practical tutorial will lock in these essential skills for any large scale data science project.

Copyright 2019 Manning Publications
welcome
brief contents
1 Introduction
2 Working with large datasets faster: parallelization and the map function
3 Function pipelines for mapping complex transformations
4 Processing large datasets with lazy workflows
5 Accumulation operations with Reduce
6 Speeding up map and reduce with advanced parallelization
7 Processing truly big datasets with Hadoop and Spark
8 Best practices for large data with Apache Streaming and MRJob
Real-World Cryptography MEAP V01
Real-World Cryptography MEAP V01

If you’re browsing the web, using public APIs, making and receiving electronic payments, registering and logging in users, or experimenting with blockchain, you’re relying on cryptography. And you’re probably trusting a collection of tools, frameworks, and protocols to keep your data, users, and business safe. It’s important to understand these tools so you can make the best decisions about how, where, and why to use them. Real World Cryptography teaches you applied cryptographic techniques to understand and apply security at every level of your systems and applications.

About this MEAP
Welcome
1 Introduction
2 Hash Functions
3 Message Authentication Codes
MEAP VERSION 1
Elm in Action MEAP V10
Elm in Action MEAP V10

Elm is more than just a cutting-edge programming language, it's a chance to upgrade the way you think about building web applications. Once you get comfortable with Elm's refreshingly different approach to application development, you'll be working with a clean syntax, dependable libraries, and a delightful compiler that essentially eliminates runtime exceptions. Elm compiles to JavaScript, so your code runs in any browser, and Elm's best-in-class rendering speed will knock your socks off. Let's get started!

Elm in Action teaches you how to build well-designed, highly performant web applications using the Elm language. As you read, you'll follow an application called Photo Groove that will show you how to structure your application's domain and behavior, how to maintain a pleasantly modular architecture, and how to deliver a quality product using the Elm language. Along the way, you'll learn how to interact smoothly with browser functionality, servers, and JavaScript libraries, as well and picking up a few tricks for building fluid, intuitive user experiences. If you're new to functional programming, you'll also gain a practical understanding of techniques that will make you a better developer no matter what you're writing!

Copyright 2019 Manning Publications
welcome
brief contents
1 Welcome to Elm
2 Your First Elm Application
3 Compiler as Assistant
4 Talking to Servers
5 Talking to JavaScript
6 Testing
7 Data Modeling
8 Single-Page Applications
A Getting Set Up
B Installing Elm Packages
C Html.Lazy’s Change Check
Docker in Action, Second Edition MEAP V07
Docker in Action, Second Edition MEAP V07

Even small applications have dozens of components. Large applications may have thousands, which makes them challenging to install, maintain, and remove. Docker bundles all application components into a package called a container that keeps things tidy and helps manage any dependencies on other applications or infrastructure. Used by everyone from small start-ups to eBay and Lyft, Docker has changed development for the better. If you’re looking to join the container revolution, Docker in Action, Second Edition will get you started.

Copyright 2019 Manning Publications
welcome
brief contents
Part 1: Process Isolation and Environment-Independent Computing
1 Welcome to Docker
2 Running software in containers
3 Software installation simplified
4 Working with storage and volumes
5 Single Host Networking
6 Limiting risk with resource controls
Part 2: Packaging Software for Distribution
7 Packaging software in images
8 Building images automatically with Dockerfiles
9 Public and private software distribution
10 Image Pipelines
Part 3: Higher-Level Abstractions and Orchestration
11 Services with Docker and Compose
12 First-Class Configuration Abstractions
13 Orchestrate Services on a Cluster of Docker Hosts with Swarm
Index
Practices of the Python Pro MEAP V05
Practices of the Python Pro MEAP V05

Professional developers know the many benefits of writing application code that’s clean, well-organized, and easy to maintain. By learning and following established patterns and best practices, you can take your code and your career to a new level. With Practices of the Python Pro, you’ll learn to design professional-level, clean, easily-maintainable software at scale using the incredibly popular programming language, Python. You’ll find easy-to-grok examples that use pseudocode and Python to introduce software development best practices, along with dozens of instantly-useful techniques that will help you code like a pro.

About this MEAP
Welcome
1 The bigger picture
2 Separation of concerns
3 Abstraction and Encapsulation
4 Designing for high performance
5 Testing your software
6 Separation of Concerns in Practice
7 Extensibility and Flexibility
MEAP VERSION 5
A Installing Python
API Design Patterns MEAP V01
API Design Patterns MEAP V01

Modern software systems are composed of many servers, services, and other components that communicate through APIs. As a developer, your job is to make sure these APIs are stable, reliable, and easy to use for other developers. API Design Patterns provides you with a unique catalog of design standards and best practices to ensure your APIs are flexible and user-friendly. Fully illustrated with examples and relevant use-cases, this essential guide covers patterns for API fundamentals and real-world system designs, along with quite a few not-so-common scenarios and edge-cases.

Copyright 2019 Manning Publications
welcome
brief contents
1 Introduction to APIs
2 Introduction to API design patterns
4 Resource layout
Azure Data Engineering: Real-time, streaming, and batch analytics MEAP V03
Azure Data Engineering: Real-time, streaming, and batch analytics MEAP V03

The Microsoft Azure cloud is an ideal platform for data-intensive applications. Designed for productivity, Azure provides pre-built services that make collection, storage, and analysis much easier to implement and manage. Azure Data Engineering teaches you how to design a reliable, performant, and cost-effective data infrastructure in Azure by progressively building a complete working analytics system.

About this MEAP
Welcome
1 What is data engineering
2 Building an analytics system in Azure
3 Azure Storage Blob service
4 Azure Data Lake storage
5 Queueing with Event Hubs
MEAP VERSION 3
A Set up of Azure resources through Powershell
Grokking Functional Programming MEAP V06
Grokking Functional Programming MEAP V06

Grokking Functional Programming is a practical book. Written especially for object-oriented programmers, it will help you map familiar ideas like objects and inheritance to FP concepts such as programming with immutable data, higher order functions, composing functions, concurrent programming and even the dreaded monad. And you'll be pleased to know that we skip the academic baggage of lambda calculus, category theory, and the mathematical foundations of FP in favor of applying functional programming to everyday programming tasks. At the end of the book, you'll be ready to pick a functional language and start writing useful software.

Copyright 2019 Manning Publications
welcome
brief contents
1 Learning functional programming
2 Pure functions
Voice-First Development: Designing, developing, and deploying conversational interfaces MEAP V05
Voice-First Development: Designing, developing, and deploying conversational interfaces MEAP V05

Voice-commanded applications are everywhere, running on smart speakers like the Amazon Echo and Google Home, digital assistants like Apple’s Siri, speech-based automotive chatbots, and even novelties like the Alexa-enabled Big Mouth Billy Bass. In Voice-First Development, authors Ann Thyme-Gobbel and Charles Jankowski draw from more than three decades of experience in voice-related development and research to bring you up to speed with a host of voice-controlled applications. This engaging guide focuses on end-to-end voice app development, concrete best practices, and how to avoid common pitfalls. Including practical instruction, real-world examples, and lots of code samples, this book is perfect for developers ready to create fully-functioning voice solutions that users will love!

Copyright 2019 Manning Publications
welcome
brief contents
1 Voice-first development components
2 Keeping voice in mind
3 Running a voice-first application – and noticing issues
4 Defining your vision: Building What, How, and Why for Whom
5 From discovery to UX and UI: Tools of the voice design trade
6 Applying human 'rules of dialog' to reach voice-first dialog resolution
7 Resolving incomplete requests through disambiguation
8 Conveying reassurance with confidence and confirmation
Machine Learning with R, tidyverse, and mlr MEAP V03
Machine Learning with R, tidyverse, and mlr MEAP V03

Machine learning is a collection of programming techniques for discovering relationships in data. With ML algorithms, you can cluster and classify data for tasks like making recommendations or fraud detection and make predictions for sales trends, risk analysis, and other forecasts. Once the domain of academic data scientists, machine learning has become a mainstream business process, and tools like the easy-to-learn R programming language put high-quality data analysis in the hands of any programmer. Machine Learning with R, tidyverse, and mlr teaches you widely used ML techniques and how to apply them to your own datasets using the R programming language and its powerful ecosystem of tools. This book will get you started!

About this MEAP
Welcome
1 Introduction
2 Tidying, manipulating and plotting data with the tidyverse
3 Classifying based on similar observations: the k-Nearest neighbors algorithm
4 Classifying based on odds: logistic regression
5 Classifying by maximizing class separation: discriminant analysis
6 Classifying based on probabilities and hyperplanes: naive Bayes and support vector machines
7 Classifying with trees: Decision trees, random forests and gradient boosting
8 Regression with lines: linear regression and generalized additive models
MEAP VERSION 3
Seriously Good Software: Code that works, wins, and survives MEAP V03
Seriously Good Software: Code that works, wins, and survives MEAP V03

Serious developers know that code can always be improved. With each iteration, you make optimizations—small and large—that can have a huge impact on your application’s speed, size, resilience, and maintainability. In Seriously Good Software: Code that Works, Survives, and Wins, author, teacher, and Java expert Marco Faella teaches you techniques for writing better code. You’ll start with a simple application and follow it through seven careful refactorings, each designed to explore another dimension of quality.

About this MEAP
Welcome
1 Software qualities and problem statement
2 Reference implementation
3 Need for speed: Time efficiency
4 Precious memory: Space efficiency
5 Self-conscious code: Reliability through monitoring
6 Lie to me: Reliability through testing
7 Coding aloud: Readability
8 Many cooks in the kitchen: Thread safety
MEAP VERSION 3
Index
Python Workout: Fifty short projects MEAP V02
Python Workout: Fifty short projects MEAP V02

The only way to master a skill is to practice. In Python Workout, author Reuven M. Lerner guides you through 50 carefully selected exercises that invite you to flex your programming muscles. As you take on each new challenge, you’ll build programming skill and confidence. The thorough explanations help you lock in what you’ve learned and apply it to your own projects. Along the way, Python Workout provides over four hours of video instruction walking you through the solutions to each exercise and dozens of additional exercises for you to try on your own.

Welcome
1 Numeric types
2 Strings
3 Lists and tuples
4 Dictionaries and sets
MEAP VERSION 2
How to use the video supplements
Programming with Types MEAP V04
Programming with Types MEAP V04

Type-related failures are common and can be very costly. Famously, in 1999, NASA’s Mars Climate Orbiter burned up in the atmosphere because of an error that could have easily been prevented with typing. By taking advantage of the strong type systems available in most modern programming languages, you can eliminate whole classes of errors. Programming with Types teaches you type system techniques for writing software that’s safe, correct, easy to test and maintain, and that practically documents itself. Master these techniques, and you may even help prevent an interstellar catastrophe!

Copyright 2019 Manning Publications
welcome
brief contents
1 Introduction to Typing
2 Basic Types
3 Composition
4 Type Safety
5 Function Types
6 Advanced Applications of Function Types
7 Subtyping
8 Elements of Object-Oriented Programming
Fighting Churn with Data MEAP V01
Fighting Churn with Data MEAP V01

Don’t let your hard-won customers vanish from subscription services, taking their money with them. In Fighting Churn with Data you’ll learn powerful data-driven techniques to maximize customer retention and minimize actions that cause them to stop engaging or unsubscribe altogether. This hands-on guide is packed with techniques for converting raw data into measurable metrics, testing hypotheses, and presenting findings that are easily understandable to non-technical decision makers

Copyright 2019 Manning Publications
welcome
brief contents
1 The World of Subscriptions and Churn
2 Measuring Churn
WebAssembly in Action: With examples using C++ and Emscripten MEAP V07
WebAssembly in Action: With examples using C++ and Emscripten MEAP V07

“Any application that can be written in JavaScript, will eventually be written in JavaScript.”
 — Jeff Atwood, Cofounder of StackOverflow

“Atwood’s Law” is driven by the idea that all applications will ultimately wind up on the web and therefore must be written in JavaScript. WebAssembly may be your way out! With WebAssembly, you can write in nearly any modern language and run your code in the browser through a memory-safe, sandboxed execution environment that can be embedded in a web browser and other platforms. Getting set up and moving with WebAssembly requires you to modify your web dev process; WebAssembly in Action will get you started quickly and guide you through real-world examples and detailed diagrams that help you create, run, and debug WebAssembly modules.

Copyright 2019 Manning Publications
welcome
brief contents
1 Meet WebAssembly
2 A look inside WebAssembly modules
3 Creating your first WebAssembly module
4 Creating a WebAssembly module that JavaScript talks to
5 Creating a WebAssembly module that calls into JavaScript
6 Creating a WebAssembly module that talks to JavaScript using function pointers
7 Dynamic linking: the basics
8 Dynamic linking: the implementation
9 Threading: web workers and pthreads
10 WebAssembly modules in Node.js
11 WebAssembly text format
12 Debugging
A Installation & tool setup
B ccall, cwrap, and direct function calls
C Emscripten macros
D Exercise solutions
E Text format extras
Index
Machine Learning for Business: Using Amazon SageMaker and Jupyter MEAP V05
Machine Learning for Business: Using Amazon SageMaker and Jupyter MEAP V05

  • Imagine predicting which customers are thinking about switching to a competitor or flagging potential process failures before they happen
  • Think about the benefits of forecasting tedious business processes and back-office tasks
  • Envision quickly gauging customer sentiment from social media content (even large volumes of it).
  • Consider the competitive advantage of making decisions when you know the most likely future events
Machine learning can deliver these and other advantages to your business, and it’s never been easier to get started!

About this MEAP
Welcome
1 How machine learning applies to business automation
2 Should you send a purchase order to a technical approver?
3 Should you call a customer because they are at risk of churning
4 Should a tweet be escalated to your support team
5 Should you question an invoice sent by a supplier
6 Forecasting your company’s monthly power usage
7 Adding features to your company’s monthly power usage forecast
8 Serving predictions over the web
MEAP VERSION 5
A Signing up to Amazon AWS
B Setting up and using S3 to store files
C Setting up and using AWS Sagemaker to build a machine learning system
D Shutting it all down
Clojure: The Essential Reference MEAP V24
Clojure: The Essential Reference MEAP V24

The Clojure standard library is a treasure trove of functions and macros that have been battle-tested over the years to solve the most challenging programming problems. Knowing what's available in the standard library not only liberates programmers from mundane tasks like connecting to data sources, parsing XML, dealing with numbers but also more advanced problems like handling concurrency and parallelism. Having a deep knowledge of the Clojure standard library helps you solve problems quickly and more efficiently.

Clojure: The Essential Reference is an extensive reference to the standard library but it doesn't read as a dull list of functions. In addition to providing clear explanations for each topic, this guide is full of real-world examples, links, and background information. The book approaches difficult topics by illustrating them in a readable and pleasant way, using visual structure to emphasize the essential information. The book is designed to be used as a reference, but each function provides an interesting reading on its own, offering insight into functional and general programming. By using this reference, you will be able to make the most idiomatic and efficient choice while developing a Clojure application.

About this MEAP
Welcome
1 Know Your Tools
2 Creating and manipulating functions
3 Basic Constructs
4 Creating and inspecting macros
5 Operations on Numbers
6 Comparison and Equality
7 Reducers and Transducers
8 Collections
9 Sequential Generation
10 Sequential Processing
11 Maps
12 Vectors
13 Sets
14 Concurrency
15 Classes, Hierarchies and Polymorphism
16 Vars and Namespaces
17 Evaluation
18 Formatting and Printing
19 Strings and Regular Expressions
20 Mutation and Side Effects
21 Java Interoperation
22 The Toolbox
MEAP VERSION 24
Probabilistic Deep Learning with Python MEAP V01
Probabilistic Deep Learning with Python MEAP V01

Probabilistic Deep Learning with Python teaches the increasingly popular probabilistic approach to deep learning that allows you to tune and refine your results more quickly and accurately without as much trial-and-error testing. Emphasizing practical techniques that utilize the Python-based Tensorflow Probability Framework, you’ll learn to build highly-performant deep learning applications that can reliably handle the noise and uncertainty of real-world data.

Copyright 2019 Manning Publications
welcome
brief contents
1 Introduction to deep learning
2 Neural network architectures
Perrin V12 0
Perrin V12 0

The Spark distributed data processing platform provides an easy-to-implement tool for ingesting, streaming, and processing data from any source. In Spark in Action, Second Edition, you'll learn to take advantage of Spark's core features and incredible processing speed, with applications including real-time computation, delayed evaluation, and machine learning. Spark skills are a hot commodity in enterprises worldwide, and with Spark's powerful and flexible Java APIs, you can reap all the benefits without first learning Scala or Hadoop.

Unlike many Spark books written for data scientists, Spark in Action, Second Edition is designed for data engineers and software engineers who want to master data processing using Spark without having to learn a complex new ecosystem of languages and tools. You'll instead learn to apply your existing Java and SQL skills to take on practical, real-world challenges.

Copyright 2019 Manning Publications
welcome
foreword
about the cover
brief contents
Table of Contents
Part 1: The theory crippled by awesome examples
1 So, what is Spark, anyway?
2 Architecture and flow
3 The majestic role of the dataframe
4 Fundamentally lazy
5 Building a simple app for deployment
6 Deploying your simple app
Part 2: Ingestion
7 Ingestion from files
8 Ingestion from databases
9 Advanced ingestion: finding data sources & building your own
10 Ingestion through structured streaming
Part 3: Transformation
11 Working with SQL
12 Transforming your data
13 Transforming entire documents
14 Extending transformations with user-defined functions (UDFs)
15 Aggregating your data
I Reference for ingestion
Appendixes:
A Installing Eclipse
B Installing Maven
C Installing Git
D Downloading the code and getting started with Eclipse
E Installing Elasticsearch and sample data
F Maven quick cheat sheet
G Getting help with relational databases
H A history of enterprise data
K Static functions ease your transformations
L Lexicon
M Generating streaming data
N Reference for streaming
P Installing Spark in production and a few tips
S Enough (of) Scala
T Reference for transformations and actions
Z Finding help when you’re stuck
GANs in Action: Deep learning with generative adversarial networks MEAP V08
GANs in Action: Deep learning with generative adversarial networks MEAP V08

Deep learning systems have gotten really great at identifying patterns in text, images, and video. But applications that create realistic images, natural sentences and paragraphs, or native-quality translations have proven elusive. Generative Adversarial Networks, or GANs, offer a promising solution to these challenges by pairing two competing neural networks—one that generates content and the other that rejects samples that are of poor quality.

Copyright 2019 Manning Publications
welcome
brief contents
1 Introduction to GANs
2 Intro to Generative Modeling with Autoencoders
3 Your First GAN: Generating Handwritten Digits
4 Deep Convolutional GAN (DCGAN)
5 Training & Common Challenges: GANing for Success
6 Progressing with GANs
7 Semi-Supervised GAN
8 Conditional GAN
9 CycleGAN
10 Adversarial Examples
11 Practical Applications of GANs
12 Looking Ahead
Practical Data Science with R, Second Edition MEAP V05
Practical Data Science with R, Second Edition MEAP V05

Practical Data Science with R, Second Edition takes a practice-oriented approach to explaining basic principles in the ever-expanding field of data science. You’ll jump right to real-world use cases as you apply the R programming language and statistical analysis techniques to carefully explained examples based in marketing, business intelligence, and decision support.

Numerous updates in this brand new edition include: an introduction to the vtreat data preparation tool, a section on model explanation, and additional modeling techniques such as boosting and regularized regression!

About this MEAP
Welcome
Part 1: Introduction to data science
1 The data science process
2 Starting with R and data
3 Exploring data
4 Managing data
5 Data Engineering and Data Shaping
Part 2: Modeling methods
6 Choosing and evaluating models
7 Linear and logistic regression
8 Advanced Data Preparation
9 Unsupervised methods
10 Exploring advanced methods
MEAP VERSION 5
Index
Vert.x in Action MEAP V04
Vert.x in Action MEAP V04

As enterprise applications become larger and more distributed, new architectural approaches like reactive designs, microservices, and event streams are required knowledge. The Vert.x framework provides a mature, rock-solid toolkit for building reactive applications using Java, Kotlin, or Scala. Vert.x in Action teaches you to build responsive, resilient, and scalable JVM applications with Vert.x using well-established reactive design patterns.

About this MEAP
Welcome
1 Vertx, asynchronous programming and reactive systems
2 Verticles: the basic processing units of Vert.x
3 The event-bus: connecting verticles
4 Asynchronous data and event streams
5 Beyond callbacks
6 Beyond the event-bus
MEAP VERSION 4
Flutter in Action MEAP V07
Flutter in Action MEAP V07

In 2017, consumers downloaded 178 billion apps, and analysts predict growth to 258 billion by 2022. Mobile customers are demanding more—and better—apps, and it’s up to developers like you to write them! Flutter, a revolutionary new cross-platform software development kit created by Google, makes it easier than ever to write secure, high-performance native apps for iOS and Android. Flutter apps are blazingly fast because this open source solution compiles your Dart code to platform-specific programs with no JavaScript bridge! Flutter also supports hot reloading to update changes instantly. And thanks to its built-in widgets and rich motion APIs, Flutter’s apps are not just highly responsive, they’re stunning!

About this MEAP
Welcome
1 Welcome
2 A Brief Intro to Dart
3 Meet Flutter
4 Flutter UI: Important Widgets, Theme, and Layout
5 User Interaction: Forms and Gestures
6 Pushing Pixels: Flutter Animations and using the Canvas
7 Flutter Routing In Depth
8 Flutter State Management
9 Async Dart and Flutter (and some scrolling tips)
10 Working with data: HTTP, Firestore, and JSON
11 Testing and Accessibilty
MEAP VERSION 6
A Installation and Tools
Learn Quantum Computing with Python and Q#: A hands-on approach MEAP V02
Learn Quantum Computing with Python and Q#: A hands-on approach MEAP V02

Learn Quantum Computing with Python and Q# demystifies quantum computing. Using Python and the new quantum programming language Q#, you’ll build your own quantum simulator and apply quantum programming techniques to real-world examples including cryptography and chemical analysis.

About this MEAP
Welcome
1 Introducing Quantum Computing
2 Qubits: The Building Blocks
6 Changing the odds: An introduction to Q#
MEAP VERSION 2
A Installing Required Software
Deep Learning for Search
API Security in Action MEAP V01
API Security in Action MEAP V01

A web API is an efficient way to communicate with an application or service. However, this convenience opens your systems to new security risks. API Security in Action gives you the skills to build strong, safe APIs you can confidently expose to the world. Inside, you’ll learn to construct secure and scalable REST APIs, deliver machine-to-machine interaction in a microservices architecture, and provide protection in resource-constrained IoT (Internet of Things) environments.

Copyright 2019 Manning Publications
welcome
brief contents
1 What is API security?
2 Secure API development
3 Securing the Natter API
A Setting up Java and Maven
Secure by Design MEAP V14
Secure by Design MEAP V14

As a developer, you need to build software in a secure way. But you can't spend all your time focusing on security. The answer is to use good design principles, tools, and mindsets that make security an implicit result - it's secure by design. Then secure-by-design becomes a guiding principle in how you build your software, from code to architecture. This begins by understanding designs and patterns that promote security so they become easy to apply in your day-to-day work. This way, you end up with securely-built software that avoids a majority of the most common security vulnerabilities. And best of all, it liberates your mind from security and lets you focus on developing features.

Secure by Design teaches developers how to use design to drive security in software development. This book is full of patterns, best practices, and mindsets that you can directly apply to your real world development. You'll also learn to spot weaknesses in legacy code and how to address them. You'll start by gaining an understanding of security as a vital concern and not simply a feature, and how good design promotes security. A real-life case study shows how shallow design caused a severe loss of money. Then you'll dive into practical ways of designing your code to avoid security flaws. You'll see how to use concrete code constructs that have profound effect on security - for example, immutability, validation, domain primitives, and error handling. Additional topics include how to secure your design through tests, using your delivery pipeline, how to do integration between systems, and how insights from cloud thinking support security. The final part of the book compares different architectures from a security perspective and puts concepts from previous chapters to work. In particular, you'll learn what to do in a legacy codebase, how to handle a monolith, and what to do when building a microservice architecture.

About this MEAP
Welcome
Part 1: Introduction
1 Why design matters for security
2 Intermission: the anti-Hamlet
Part 2: Fundamentals
3 Core concepts of Domain-Driven Design
4 Code constructs promoting security
5 Domain primitives
6 Ensuring integrity of state
7 Reducing complexity of state
8 Leveraging your delivery pipeline for security
9 Handling failures securely
10 Benefits of cloud thinking
11 Intermission: An insurance policy for free
Part 3: Applying the fundamentals
12 Guidance in legacy code
13 Guidance on microservices
14 A final word: Don’t forget about security!
MEAP VERSION 14
Unit Testing: Principles, Practices, and Patterns MEAP V01
Unit Testing: Principles, Practices, and Patterns MEAP V01

Unit Testing: Principles, Patterns and Practices shows you how to refine your existing unit tests by implementing modern best practices. You’ll learn to spot which tests are performing, which need refactoring, and which need to be deleted entirely! Upgrade your testing suite with new testing styles, good patterns, and reliable automated testing.

About this MEAP
Welcome
1 The goal of unit testing
2 What is a unit test?
MEAP VERSION 1
Kafka in Action Review
Kafka in Action Review

In systems that handle big data, streaming data, or fast data, it's important to get your data pipelines right. Apache Kafka is a wicked-fast distributed streaming platform that operates as more than just a persistent log or a flexible message queue. With Kafka, you can build the powerful real-time data processing pipelines required by modern distributed systems. Kafka in Action is a fast-paced introduction to every aspect of working with Kafka you need to really reap its benefits.

About this MEAP
Welcome
1 Introduction to Kafka
2 Getting to know Kafka
3 Designing a Kafka project
4 Producers: Sourcing Data
5 Consumers: Unlocking Data
6 Brokers
7 Topics and Partitions
MEAP VERSION 9
B Installation
Parallel and High Performance Computing MEAP V01
Parallel and High Performance Computing MEAP V01

Complex calculations, like training deep learning models or running large-scale simulations, can take an extremely long time. Efficient parallel programming can save hours—or even days—of computing time. Parallel and High Performance Computing shows you how to deliver faster run-times, greater scalability, and increased energy efficiency to your programs by mastering parallel techniques for multicore processor and GPU hardware.

Copyright 2019 Manning Publications
welcome
brief contents
1 Why parallel computing
2 Planning for parallel
3 Performance limits and profiling
A References
B Solutions to Exercises
C Glossary
The Joy of JavaScript MEAP V02
The Joy of JavaScript MEAP V02

Whether for building interactive browser-based applications or creating server-side applications in Node, JavaScript is the most widely used language for web programming. With new features, language improvements, paradigms, and potential use cases appearing regularly, there’s never been a more exciting time to be a JavaScript developer. In The Joy of JavaScript, author and JavaScript expert Luis Atencio teaches you key design concepts that lead to clean, lean, modular, and easy-to-maintain code.

Copyright 2019 Manning Publications
welcome
brief contents
1 JavaScript Reloaded
2 Prototype-centric object modeling
3 Delegation-based, compositional object models
4 Writing composable, pure code
Cloud Native Patterns: Designing change-tolerant software
Event Streams in Action: Real-time event systems with Kafka and Kinesis
Deep Learning with PyTorch MEAP V09
Deep Learning with PyTorch MEAP V09

Every other day we hear about new ways to put deep learning to good use: improved medical imaging, accurate credit card fraud detection, long range weather forecasting, and more. PyTorch puts these superpowers in your hands, providing a comfortable Python experience that gets you started quickly and then grows with you as you—and your deep learning skills—become more sophisticated. Deep Learning with PyTorch will make that journey engaging and fun.

About this MEAP
Welcome
Part 1: Core PyTorch
1 Introducing Deep Learning and the PyTorch Library
2 Pre-Trained Networks
3 It Starts with a Tensor
4 Real-World Data Representation Using Tensors
5 The Mechanics of Learning
6 Using A Neural Network To Fit Our Data
7 Telling Birds from Airplanes - Learning from Images
8 Using Convolutions To Generalize
Part 2: Learning from Images in the Real-World: Early Detection of Lung Cancer
9 How Can PyTorch Be Used To Fight Cancer?
10 Classifying Suspected Tumors
11 Monitoring Metrics: Precision, Recall, and Pretty Pictures
MEAP VERSION 9
Blockchain in Action MEAP V01
Blockchain in Action MEAP V01

There’s a lot more to the blockchain than mining Bitcoin. This secure system for registering and verifying ownership and identity is perfect for supply chain logistics, health records, and other sensitive data management tasks. Blockchain in Action unlocks the full potential of this revolutionary technology, showing you how to build own decentralized apps for secure applications including digital democracy, private auctions, and electronic record management.

Copyright 2019 Manning Publications
welcome
brief contents
1 Blockchain basics
2 Smart contracts
3 Techniques for trust and integrity
A. UML blockchain design models
Rust in Action MEAP V09
Rust in Action MEAP V09

Rust in Action introduces the Rust programming language by exploring numerous systems programming concepts and techniques.You'll be learning Rust by delving into how computers work under the hood. You'll find yourself playing with persistent storage, memory, networking and even tinkering with CPU instructions. The book takes you through using Rust to extend other applications and teaches you tricks to write blindingly fast code. You'll also discover parallel and concurrent programming. Filled to the brim with real-life use-cases and scenarios, you'll go beyond the Rust syntax and see what Rust has to offer in real-world use cases.

About this MEAP
Welcome
1 Introducing Rust
2 Language Foundations
3 Compound Data Types
4 Lifetimes, Ownership and Borrowing
5 Data in Depth
6 Memory
7 Files & Storage
9 Time and Time Keeping
12 Signals, Interrupts and Exceptions
MEAP VERSION 9
Build Your Career in Data Science MEAP V01
Build Your Career in Data Science MEAP V01

You are going to need more than technical knowledge to succeed as a data scientist. Build Your Career in Data Science teaches you what school leaves out, from how to land your first job, to the lifecycle of a data science project, and even how to become a manager.

Copyright 2019 Manning Publications
welcome
brief contents
1 What is data science?
2 Data science companies
3 Getting the Skills
4 Building a Portfolio
5 The Search: Identifying the Right Job for You
Get Programming with Java MEAP V04 livebook
Graph Databases in Action MEAP V03
Graph Databases in Action MEAP V03

Relationships in data often look far more like a web than an orderly set of rows and columns. Graph databases shine when it comes to revealing valuable insights within complex, interconnected data such as demographics, financial records, or computer networks. In Graph Databases in Action, expert Dave Bechberger illuminates the design and implementation of graph databases in real-world applications. You’ll learn how to choose the right database solutions for your tasks, and how to use your new knowledge to build agile, flexible, and high-performing graph-powered applications!

Copyright 2019 Manning Publications
welcome
brief contents
1 What is a Graph and What Can it Do?
2 Do I Have a Graph Problem?
3 Graph Data Modeling
4 Data Modeling in Practice
A Apache TinkerPop Installation and Overview
C An Introduction to the Graph Ecosystem
The Design of Web APIs MEAP V10
The Design of Web APIs MEAP V10

Web APIs are everywhere, giving developers an efficient way to interact with applications, services, and data. Well-designed APIs are a joy to use; poorly-designed APIs are cumbersome, confusing, and frustrating. The Design of Web APIs is a practical, example packed guide to crafting extraordinary web APIs. Author Arnaud Lauret demonstrates fantastic design principles and techniques you can apply to both public and private web APIs.

About this MEAP
Welcome
1 What is API design?
2 Designing an API for its users
3 Designing a programming interface
4 Describing an API with an API description format
5 Designing a straightforward API
6 Designing a predictable API
7 Designing a concise and well-organized API
8 Designing a secure API
9 Evolving an API design
10 Designing a network-efficient API
11 Designing in context
12 Documenting an API
13 Growing APIs
MEAP VERSION 10
Web Design Playground
Web Design Playground

Web Design Playground takes you step by step from writing your first line of HTML to creating interesting and attractive web pages. In this project-based book, you’ll use a custom online workspace, the book’s companion Playground, to design websites, product pages, photo galleries, and more.

Cover
Titlepage
Dedication
Contents
Index
List of Figures
List of Tables
List of Listings
Copyright
Preface
Acknowledgments
About This Book
About the Author
Part 1: Getting Started with HTML and CSS
Chapter 1: Getting to Know HTML and CSS
Chapter 2: Building Your First Web Page
Chapter 3: Adding Structure to Your Page
Chapter 4: Formatting Your Web Page
Chapter 5: Project: Creating a Personal Home Page
Part 2: Working with Images and Styles
Chapter 6: Adding Images and Other Media
Chapter 7: Learning More About Styles
Chapter 8: Floating and Positioning Elements
Chapter 9: Styling Sizes, Borders, and Margins
Chapter 10: Project: Creating a Landing Page
Part 3: Laying Out a Web Page
Chapter 11: Learning Page Layout Basics
Chapter 12: Creating Page Layouts with Flexbox
Chapter 13: Designing Responsive Web Pages
Chapter 14: Making Your Images and Typography Responsive
Chapter 15: Project: Creating a Photo Gallery
Part 4: Making Your Web Pages Shine
Chapter 16: More HTML Elements for Web Designers
Chapter 17: Adding a Splash of Color to Your Web Designs
Chapter 18: Enhancing Page Text with Typography
Chapter 19: Learning Advanced CSS Selectors
Chapter 20: Project: Creating a Portfolio Page
Appendix: From Playground to Web: Getting Your Pages Online
Fusion in Action: Search, analytics, and big data with Lucidworks Fusion MEAP V03 Livebook
Fusion in Action: Search, analytics, and big data with Lucidworks Fusion MEAP V03 Livebook

Lucidworks Fusion makes short work of large-scale analytics. Blending the powerful capabilities of best-in-class tools like the Apache Solr search engine and the Apache Spark data clustering framework, Fusion provides a lean, mature data search and analytics platform that expertly combines search and AI. In Fusion in Action, expert Guy Sperry shows you how to get the most from your data by building Fusion-based analytics solutions.

Lucidworks is providing all MEAP readers of Fusion in Action with an extended free trial edition of Fusion 4, so you can practice as you learn using the latest version of the software.

Copyright 2018 Manning Publications
welcome
brief contents
1 Meet Fusion
2 Build your first search application
3 Fusion’s Search Features
4 Integrate your data with connectors and pipelines
5 Additional Search Concepts/Features
A Preparing your environment
B Query Pipeline Stages
C Datasource connectors
Phoenix in Action
Get Programming with Clojure MEAP V02
Get Programming with Clojure MEAP V02

Well-written programs are easy to understand, modify, and maintain. Clojure, a functional-first dynamic language for the Java Virtual Machine, helps you write clean code without sacrificing productivity concerns like rapid prototyping and interaction with standard Java libraries. In this thoughtful, hands-on tutorial, Clojure expert Yehonathan Sharvit helps you get programming with Clojure by engaging you in fast, fun exercises, projects, and clearly-written lessons. By the time you finish your final capstone project, you’ll be designing Clojure functions, apps, and libraries like a pro!

Copyright 2019 Manning Publications
welcome
brief contents
Unit 0. Get Programming with Clojure
Lesson 1. The Clojure syntax
Lesson 2. A preview of Clojure key features
Lesson 3. Clojure in the industry
Unit 1. Get familiar with Clojure syntax
Lesson 4. Arithmetic expressions
Lesson 5. Arithmetic comparisons
Lesson 6. Logic operations
Lesson 7. Complex nested expressions
Unit 2. Meet the Clojure REPL
Lesson 8. Interactive development
Lesson 9. documentation, auto completion and history
Lesson 10. Capstone project: Know your REPL
Unit 3. Conditionals and Functions
Lesson 11. Naming stuff with def
Lesson 12. Conditional branching with if and cond
Lesson 13. functions
Lesson 14. Capstone project
Unit 4. Your first Clojure program
Lesson 15. String conversions
Lesson 16. Printing and handling side effects
Lesson 17. Running a program from the command line
Lesson 18. Capstone project: A program - Who drank the most beer?
Quick Start: Your first Clojure program
Grokking Deep Reinforcement Learning MEAP V05
Grokking Deep Reinforcement Learning MEAP V05

We all learn through trial and error. We avoid the things that cause us to experience pain and failure. We embrace and build on the things that give us reward and success. This common pattern is the foundation of deep reinforcement learning: building machine learning systems that explore and learn based on the responses of the environment.

Grokking Deep Reinforcement Learning introduces this powerful machine learning approach, using examples, illustrations, exercises, and crystal-clear teaching. You'll love the perfectly paced teaching and the clever, engaging writing style as you dig into this awesome exploration of reinforcement learning fundamentals, effective deep learning techniques, and practical applications in this emerging field.

Copyright 2019 Manning Publications
brief contents
welcome
1 Introduction to Deep Reinforcement Learning
2 Planning For Sequential Decision-Making Problems
3 Learning to Act Through Interaction
4 More Effective and Efficient Reinforcement Learning
5 Introduction to value-based deep reinforcement learning
6 Stabilizing value-based deep reinforcement learning method
7 Sample-efficient value-based: deep reinforcement learning methods
Getting MEAN with Mongo, Express, Angular, and Node.js 2ED
Getting MEAN with Mongo, Express, Angular, and Node.js 2ED

Getting MEAN, Second Edition teaches you how to develop full-stack web applications using the MEAN stack. This edition was completely revised and updated to cover MongoDB 4, Express 4, Angular 7, Node 11, and the latest mainstream release of JavaScript ES2015.

Data integration differences for various approaches used by Node.js applications
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Praise for the First Edition
Preface
Acknowledgments
About this book
About the authors
About the cover illustration
Part 1. Setting the baseline
Chapter 1. Introducing full-stack development
Chapter 2. Designing a MEAN stack architecture
Part 2. Building a Node web application
Chapter 3. Creating and setting up a MEAN project
Chapter 4. Building a static site with Node and Express
Chapter 5. Building a data model with MongoDB and Mongoose
Chapter 6. Writing a REST API: Exposing the MongoDB database to the application
Chapter 7. Consuming a REST API: Using an API from inside Express
Part 3. Adding a dynamic front end with Angular
Chapter 8. Creating an Angular application with TypeScript
Chapter 9. Building a single-page application with Angular: Foundations
Chapter 10. Building a single-page application with Angular: The next level
Part 4. Managing authentication and user sessions
Chapter 11. Authenticating users, managing sessions, and securing APIs
Chapter 12. Using an authentication API in Angular applications
Appendix A. Installing the stack
Appendix B. Installing and preparing the supporting cast
Appendix C. Dealing with all the views
Appendix D. Reintroducing JavaScript
Deep Learning for Natural Language Processing MEAP V02
Deep Learning for Natural Language Processing MEAP V02

Humans do a great job of reading text, identifying key ideas, summarizing, making connections, and other tasks that require comprehension and context. Recent advances in deep learning make it possible for computer systems to achieve similar results. Deep Learning for Natural Language Processing teaches you to apply deep learning methods to natural language processing (NLP) to interpret and use text effectively. In this insightful book, NLP expert Stephan Raaijmakers distills his extensive knowledge of the latest state-of-the-art developments in this rapidly emerging field. Through detailed instruction and abundant code examples, you’ll explore the most challenging NLP issues and learn how to solve them with deep learning!

About this MEAP
Welcome
1 Deep learning for NLP
2 Deep learning and language: the basics
3 Text embeddings
4 Textual similarity
5 Sequential NLP and memory
MEAP VERSION 2
Quantum Computing for Java Developers MEAP V01
Quantum Computing for Java Developers MEAP V01

Quantum computing is on the horizon, ready to impact everything from scientific research to encryption and security. But you don’t need a physics degree to get started in quantum computing. Quantum Computing for Java Developers shows you how to leverage your existing Java skills into writing your first quantum software so you’re ready for the revolution.

About this MEAP
Welcome
1 Evolution/Revolution/Hype?
2 Hello World, Quantum Computing
3 Qubits and Quantum Gates, the basic units in Quantum Computing
MEAP VERSION 1
A Installing Strange
Deep Reinforcement Learning in Action MEAP V04
Deep Reinforcement Learning in Action MEAP V04

Humans learn best from feedback—we are encouraged to take actions that lead to positive results while deterred by decisions with negative consequences. This reinforcement process can be applied to computer programs allowing them to solve more complex problems that classical programming cannot. Deep Reinforcement Learning in Action teaches you the fundamental concepts and terminology of deep reinforcement learning, along with the practical skills and techniques you’ll need to implement it into your own projects.

Copyright 2019 Manning Publications
welcome
brief contents
1 What is Reinforcement Learning?
2 Modeling Reinforcement Learning Problems: Markov Decision Processes
3 Predicting the Best States and Actions: Deep Q-Networks
4 Learning to Pick the Best Policy: Policy Gradient Methods
5 Tackling more complex problems with Actor-Critic methods
6 Alternative Optimization Methods: Evolutionary Strategies
Hello Swift!: iOS app programming for kids and other beginners
The Joy of Kotlin
Grokking Bitcoin
Grokking Bitcoin

If you think Bitcoin is just an alternative currency for geeks, it's time to think again. Grokking Bitcoin opens up this powerful distributed ledger system, exploring the technology that enables applications both for Bitcoin-based financial transactions and using the blockchain for registering physical property ownership. With this fully illustrated, easy-to-read guide, you'll finally understand how Bitcoin works, how you can use it, and why you can trust the blockchain.

Index
List of Figures
List of Tables
Copyright
Table of Contents
Foreword
Preface
Acknowledgments
About this book
About the author
Chapter 1. Introduction to Bitcoin
Chapter 2. Cryptographic hash functions and digital signatures
Chapter 3. Addresses
Chapter 4. Wallets
Chapter 5. Transactions
Chapter 6. The blockchain
Chapter 7. Proof of work
Chapter 8. Peer-to-peer network
Chapter 9. Transactions revisited
Chapter 10. Segregated witness
Chapter 11. Bitcoin upgrades
Appendix A. Using bitcoin-cli
Appendix B. Answers to exercises
Appendix C. Web resources
RxJava for Android Developers
Istio in Action MEAP V04
Istio in Action MEAP V04

Many enterprise applications intertwine code that defines an app’s behavior with code that defines its network communication and other non-functional concerns. The “service mesh” pattern, implemented by platforms like Istio, helps you push operational issues into the infrastructure so the application code is easier to understand, maintain, and adapt. Istio in Action teaches you how to implement a full-featured Istio-based service mesh to manage a microservices application. With the skills you learn in this comprehensive tutorial, you’ll be able to delegate the complex infrastructure of your cloud-native applications to Istio!

About this MEAP
Welcome
1 Introducing Istio Service Mesh
2 First steps with Istio
3 Meet Envoy proxy: Istio’s data plane
4 The edge: Getting traffic into your cluster
5 Traffic control: Fine-grained traffic routing between your services
7 Observability with Istio: understanding the behavior of your services
MEAP VERSION 3
Programmer's Guide to Apache Thrift
Natural Language Processing in Action: Understanding, analyzing, and generating text with Python
Natural Language Processing in Action: Understanding, analyzing, and generating text with Python

Natural Language Processing in Action is your guide to creating machines that understand human language using the power of Python with its ecosystem of packages dedicated to NLP and AI.

Resources
Glossary
Chatbot Recirculating (Recurrent) Pipeline
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Foreword
Preface
Acknowledgments
About this Book
About the Authors
About the cover Illustration
Part 1. Wordy machines
Chapter 1. Packets of thought (NLP overview)
Chapter 2. Build your vocabulary (word tokenization)
Chapter 3. Math with words (TF-IDF vectors)
Chapter 4. Finding meaning in word counts (semantic analysis)
Part 2. Deeper learning (neural networks)
Chapter 5. Baby steps with neural networks (perceptrons and backpropagation)
Chapter 6. Reasoning with word vectors (Word2vec)
Chapter 7. Getting words in order with convolutional neural networks (CNNs)
Chapter 8. Loopy (recurrent) neural networks (RNNs)
Chapter 9. Improving retention with long short-term memory networks
Chapter 10. Sequence-to-sequence models and attention
Part 3. Getting real (real-world NLP challenges)
Chapter 11. Information extraction (named entity extraction and question answering)
Chapter 12. Getting chatty (dialog engines)
Chapter 13. Scaling up (optimization, parallelization, and batch processing)
Appendix A. Your NLP tools
Appendix B. Playful Python and regular expressions
Appendix C. Vectors and matrices (linear algebra fundamentals)
Appendix D. Machine learning tools and techniques
Appendix E. Setting up your AWS GPU
Appendix F. Locality sensitive hashing
Get Programming with Scala MEAP V04
Get Programming with Scala MEAP V04

Scala is a multi-style programming language for the JVM that supports both object-oriented and functional programming. Master Scala, and you'll be well-equipped to match your programming approach to the type of problem you're dealing with. Packed with examples and exercises, Get Programming with Scala is perfect starting point for developers with some OO knowledge who want to learn Scala and pick up a few FP skills along the way.

Copyright 2019 Manning Publications
welcome
brief contents
Unit 0: Hello Scala!
Lesson 1 Why Scala?
Lesson 2 Scala – The REPL
Lesson 3 SBT – Scala Build Tool
Unit 1: The Basics
Lesson 4 Values and Variables
Lesson 5 Conditional Statements and Loops
Lesson 6 Function as the most fundamental block of code
Lesson 7 Classes and Subclasses to represent the world
Lesson 8 Capstone 1: Let’s build a vending machine!
Unit 2: Object-Oriented Fundamentals
Lesson 9 Import and Create Packages
Lesson 10 Scope your code with Access Modifiers
Lesson 11 Singleton Objects
Lesson 12 Traits as interfaces
Lesson 13 Capstone 2: What time is it?
Unit 3: HTTP Server
Lesson 14 Pattern Matching
Lesson 15 Anonymous Functions
Lesson 16 Partial Functions
Lesson 17 HTTP API with http4s
Lesson 18 Capstone 3: The Time HTTP Server
Unit 4: Immutable Data and Structures
Lesson 19 Case Classes to structure your data
Lesson 20 High Order Functions
Lesson 21 What is Purity?
Lesson 22 Option
Lesson 23 Working with Option: map and flatMap
Lesson 24 Working with Option: for-comprehension
Lesson 25 Tuple and Unapply
Lesson 26 Capstone 4: Rock, Paper, Scissors, Lizard, Spock!
Data Science with Python and Dask MEAP V04
Data Science with Python and Dask MEAP V04

If you’re doing data analysis using Pandas, NumPy, or Scikit, you know about THE WALL. At some point, you need to introduce parallelism to your system to handle larger-scale data or analytics tasks. The problem with THE WALL is that it can require you to rewrite your code, redesign your system, or start all over using an unfamiliar technology like Spark or Flink.

Dask is a native parallel analytics tool designed to integrate seamlessly with the libraries you’re already using, including Pandas, NumPy, and Scikit-Learn. With Dask you can crunch and work with huge datasets, just using the tools you already use. And Data Science with Python and Dask is your guide to using Dask for your data projects without changing the way you work!

Copyright 2019 Manning Publications
welcome
brief contents
1 Why Scalable Computing Matters
2 Introducing Dask
3 Introducing Dask DataFrames
4 Loading Data into DataFrames
5 Cleaning and Transforming DataFrames
6 Summarizing and Analyzing DataFrames
7 Visualizing DataFrames with Seaborn
8 Visualizing Location Data with Datashader
9 Working with Bags and Arrays
10 Machine Learning with Dask-ML
11 Scaling and Deploying Dask
A Software Installation
Modern Fortran: Building efficient parallel applications MEAP V06
Modern Fortran: Building efficient parallel applications MEAP V06

Using Fortran, early and accurate forecasts for hurricanes and other major storms have saved thousands of lives.

Using Fortran, better designs for ships, planes, and automobiles have made travel safer, more efficient, and less expensive than ever before.

Using Fortran, low-level machine learning and deep learning libraries provide incredibly easy, fast, and insightful analysis of massive data for science, business, and industry.

Fortran is an amazingly powerful and flexible programming language that forms the foundation of high performance computing for research, science, and industry. And it's come a long, long way since starting life on IBM mainframes in 1956. Modern Fortran is natively parallel, so it's uniquely suited for efficiently handling problems like complex simulations, long-range predictions, and ultra-precise designs. If you're working on tasks where speed, accuracy, and efficiency matter, it's time to discover—or re-discover—Fortran.

About this MEAP
Welcome
1 Introducing Fortran
2 Getting started: Minimal working app
3 Writing reusable code with procedures and modules
4 Analyzing time series data with arrays
5 Going parallel with Fortran coarrays
6 Working with abstract data using derived types
7 Generic procedures and operators for any data type
8 Overloading operators for derived types
MEAP VERSION 6
A Setting up the Fortran development environment
B From calculus to code
Voice Applications for Alexa and Google Assistant MEAP V07
Voice Applications for Alexa and Google Assistant MEAP V07

There's always someone listening! Voice-controlled devices like Amazon Alexa and Google Assistant are everywhere, and the apps that control them are getting more powerful. Whether you're jamming to Spotify, Googling facts, chatting with friends, or reordering supplies from Amazon, great voice apps change how you interact with the web. Voice Applications for Alexa and Google Assistant teaches you how to design, build, and share voice apps.

About this MEAP
Welcome
1 Introduction to voice first
2 Building a call and response skill on Alexa
3 Designing a voice user interface
4 Using entity resolution and built-in intents to extend an Alexa skill
5 Making a conversational Alexa skill
6 VUI and conversation best practices
7 Using conversation tools to add meaning and usability
8 Directing conversation flow
9 Building for Google Assistant
10 Going multimodal
11 Push interactions
12 Building for actions on Google with the Actions SDK
MEAP VERSION 7
A Adding an AWS IAM Profile
B Connecting DynamoDB to Lambda function
C Glossary
Voice Applications for Alexa and Google Assistant MEAP V07
AI as a Service MEAP V01
AI as a Service MEAP V01

Companies everywhere are moving everyday business processes over to the cloud, and AI is increasingly being given the reins in these tasks. As this massive digital transformation continues, the combination of serverless computing and AI promises to become the de facto standard for business-to-consumer platform development—and developers who can design, develop, implement, and maintain these systems will be in high demand! AI as a Service is a practical handbook to building and implementing serverless AI applications, without bogging you down with a lot of theory. Instead, you’ll find easy-to-digest instruction and two complete hands-on serverless AI builds in this must-have guide!

About this MEAP
Welcome
1 A Tale of Two Technologies
2 Building a Serverless Image Recognition System
3 Build and Secure a Web Application the Serverless Way
4 Adding AI Interfaces to a Web Application
MEAP VERSION 1
A Setting up AWS
Haskell in Depth MEAP V06
Haskell in Depth MEAP V06

Turn the corner from “Haskell student” to “Haskell developer.” Haskell in Depth explores the important language features and programming skills you’ll need to build production-quality software using Haskell. And along the way, you’ll pick up some interesting insights into why Haskell looks and works the way it does. Get ready to go deep!

About this MEAP
Welcome
0 Haskell in Depth: How to work with the source code examples
1 Haskell nowadays
Part 1: Core Haskell
2 Functional programming with types and type classes
3 Processing stock quote data: An example
Part 2: Developing Projects in Haskell
4 Structuring programs with modules and packages
5 Monads as practical functionality providers
6 Structuring programs with monad transformers
7 Exceptions handling and logging
8 Quality assurance
MEAP VERSION 6
React Native in Action
C# in Depth, Fourth Edition
HTTP/2 in Action
HTTP/2 in Action

HTTP/2 in Action is a complete guide to HTTP/2, one of the core protocols of the web. Because HTTP/2 has been designed to be easy to transition to, including keeping it backwards compatible, adoption is rapid and expected to increase over the next few years. Concentrating on practical matters, this interesting book presents key HTTP/2 concepts such as frames, streams, and multiplexing and explores how they affect the performance and behavior of your websites.

Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About this book
About the author
About the cover illustration
Part 1. Moving to HTTP/2
Chapter 1. Web technologies and HTTP
Chapter 2. The road to HTTP/2
Chapter 3. Upgrading to HTTP/2
Part 2. Using HTTP/2
Chapter 4. HTTP/2 protocol basics
Chapter 5. Implementing HTTP/2 push
Chapter 6. Optimizing for HTTP/2
Part 3. Advanced HTTP/2
Chapter 7. Advanced HTTP/2 concepts
Chapter 8. HPACK header compression
Part 4. The future of HTTP
Chapter 9. TCP, QUIC, and HTTP/3
Chapter 10. Where HTTP goes from here
Appendix. Upgrading common web servers to HTTP/2
Dependency Injection
Reactive Applications with Akka .NET
The Well-Grounded Rubyist, Third Edition
Classic Computer Science Problems in Python
Classic Computer Science Problems in Python

Classic Computer Science Problems in Python deepens your knowledge of problem solving techniques from the realm of computer science by challenging you with time-tested scenarios, exercises, and algorithms. As you work through examples in search, clustering, graphs, and more, you'll remember important things you've forgotten and discover classic solutions to your "new" problems!

Introduction
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Acknowledgments
About this book
About the author
About the cover illustration
Chapter 1. Small problems
Chapter 2. Search problems
Chapter 3. Constraint-satisfaction problems
Chapter 4. Graph problems
Chapter 5. Genetic algorithms
Chapter 6. K-means clustering
Chapter 7. Fairly simple neural networks
Chapter 8. Adversarial search
Chapter 9. Miscellaneous problems
Appendix A. Glossary
Appendix B. More resources
Appendix C. A brief introduction to type hints
Building Ethereum Dapps: Decentralized applications on the Ethereum blockchain
Get Programming with Node.js
Get Programming with Node.js

Get Programming with Node.js Get Programming with Node.js teaches you to write server-side code in JavaScript using Node.js. In 37 fast-paced, fun, and practical lessons, you'll discover how to extend your existing JavaScript skills to write back-end code for your web applications.

Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Foreword
Preface
Acknowledgments
About this book
About the author
Unit 0. Getting set up
Lesson 0. Setting up Node.js and the JavaScript engine
Lesson 1. Configuring your environment
Lesson 2. Running a Node.js application
Unit 1. Getting started with Node.js
Lesson 3. Creating a Node.js module
Lesson 4. Building a simple web server in Node.js
Lesson 5. Handling incoming data
Lesson 6. Writing better routes and serving external files
Lesson 7. Capstone: Creating your first web application
Unit 2. Easier web development with Express.js
Lesson 8. Setting up an app with Express.js
Lesson 9. Routing in Express.js
Lesson 10. Connecting views with templates
Lesson 11. Configurations and error handling
Lesson 12. Capstone: Enhancing the Confetti Cuisine site with Express.js
Unit 3. Connecting to a database
Lesson 13. Setting up a MongoDB Database
Lesson 14. Building models with Mongoose
Lesson 15. Connecting Controllers and Models
Lesson 16. Capstone: Saving user subscriptions
Unit 4. Building a user model
Lesson 17. Improving Your Data Models
Lesson 18. Building the user model
Lesson 19. Creating and reading your models
Lesson 20. Updating and Deleting your Models
Lesson 21. Capstone: Adding CRUD Models to Confetti Cuisine
Unit 5. Authenticating user accounts
Lesson 22. Adding sessions and flash messages
Lesson 23. Building a user login and hashing passwords
Lesson 24. Adding User Authentication
Lesson 25. Capstone: Adding User Authentication to Confetti Cuisine
Unit 6. Building an API
Lesson 26. Adding an API to Your Application
Lesson 27. Accessing Your API from Your Application
Lesson 28. Adding API Security
Lesson 29. Capstone: Implementing an API
Unit 7. Adding chat functionality
Lesson 30. Working with Socket.Io
Lesson 31. Saving Chat Messages
Lesson 32. Adding a Chat Notification Indicator
Lesson 33. Capstone: Adding a Chat Feature to Confetti Cuisinex
Unit 8. Deploying and managing code in production
Lesson 34. Deploying your application
Lesson 35. Managing in production
Lesson 36. Testing your application
Lesson 37. Capstone: Deploying Confetti Cuisine
Appendix A. JavaScript syntax introduced in ES6
Appendix B. Logging and using Node.js global objects
Docker in Practice, Second Edition
Docker in Practice, Second Edition

Docker in Practice, Second Edition presents over 100 practical techniques, hand-picked to help you get the most out of Docker. Following a Problem/Solution/Discussion format, you'll walk through specific examples that you can use immediately, and you'll get expert guidance on techniques that you can apply to a whole range of scenarios.

Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Praise for the First Edition
Preface
Acknowledgments
About this book
About the cover illustration
Part 1. Docker fundamentals
Chapter 1. Discovering Docker
Chapter 2. Understanding Docker: Inside the engine room
Part 2. Docker and development
Chapter 3. Using Docker as a lightweight virtual machine
Chapter 4. Building images
Chapter 5. Running containers
Chapter 6. Day-to-day Docker
Chapter 7. Configuration management: Getting your house in order
Part 3. Docker and DevOps
Chapter 8. Continuous integration: Speeding up your development pipeline
Chapter 9. Continuous delivery: A perfect fit for Docker principles
Chapter 10. Network simulation: Realistic environment testing without the pain
Part 4. Orchestration from a single machine to the cloud
Chapter 11. A primer on container orchestration
Chapter 12. The data center as an OS with Docker
Chapter 13. Docker platforms
Part 5. Docker in production
Chapter 14. Docker and security
Chapter 15. Plain sailing: Running Docker in production
Chapter 16. Docker in production: Dealing with challenges
Appendix A. Installing and using Docker
Appendix B. Docker configuration
Appendix C. Vagrant
Serverless Applications with Node.js
Serverless Applications with Node.js

Serverless Applications with Node.js walks you through building serverless apps on AWS using JavaScript. Inside, you'll discover what Claudia.js brings to the table as you build and deploy a scalable event-based serverless application, based around a pizzeria that’s fully integrated with AWS services, including Lambda and API Gateway. Each chapter is filled with exercises, examples, tips, and more to make sure you’re ready to bring what you’ve learned into your own work.

Cover
Titlepage
Index
List of Figures
List of Tables
List of Listings
Copyright
preface
acknowledgments
about this book
about the authors
about the cover illustration
Part 1: Serverless pizzeria
Chapter 1: Introduction to serverless with Claudia
Chapter 2: Building your first serverless API
Chapter 3: Asynchronous work is easy, we Promise()
Chapter 4: Pizza delivery: Connecting an external service
Chapter 5: Houston, we have a problem!
Chapter 6: Level up your API
Chapter 7: Working with files
Part 2: Let’s talk
Chapter 8: When pizza is one message away: Chatbots
Chapter 9: Typing... Async and delayed responses
Chapter 10: Jarvis, I mean Alexa, order me a pizza
Part 3: Next steps
Chapter 11: Testing, Testing, 1, 2, 3
Chapter 12: Paying for pizza
Chapter 13: Migrating your existing Express.js app to AWS Lambda
Chapter 14: Migrating to serverless
Chapter 15: Real-world case studies
Appendix A: Installation and configuration
Appendix B: Facebook Messenger, Twilio, and Alexa configuration
Appendix C: Stripe and MongoDB setup
Appendix D: The pizza recipe
Grokking Deep Learning
Grokking Deep Learning

Grokking Deep Learning teaches you to build deep learning neural networks from scratch! In his engaging style, seasoned deep learning expert Andrew Trask shows you the science under the hood, so you grok for yourself every detail of training neural networks.

Index
Copyright
Table of Contents
Preface
Acknowledgments
About this book
About the author
Chapter 1. Introducing deep learning: why you should learn it
Chapter 2. Fundamental concepts: how do machines learn?
Chapter 3. Introduction to neural prediction: forward propagation
Chapter 4. Introduction to neural learning: gradient descent
Chapter 5. Learning multiple weights at a time: generalizing gradient descent
Chapter 6. Building your first deep neural network: introduction to backpropagation
Chapter 7. How to picture neural networks: in your head and on paper
Chapter 8. Learning signal and ignoring noise: introduction to regularization and batching
Chapter 9. Modeling probabilities and nonlinearities: activation functions
Chapter 10. Neural learning about edges and corners: intro to convolutional neural networks
Chapter 11. Neural networks that understand language: king – man + woman == ?
Chapter 12. Neural networks that write like Shakespeare: recurrent layers for variable-length data
Chapter 13. Introducing automatic optimization: let’s build a deep learning framework
Chapter 14. Learning to write like Shakespeare: long short-term memory
Chapter 15. Deep learning on unseen data: introducing federated learning
Chapter 16. Where to go from here: a brief guide
Practical Recommender Systems
Practical Recommender Systems

Online recommender systems help users find movies, jobs, restaurants—even romance! There’s an art in combining statistics, demographics, and query terms to achieve results that will delight them. Learn to build a recommender system the right way: it can make or break your application!

Practical Recommender Systems explains how recommender systems work and shows how to create and apply them for your site. After covering the basics, you’ll see how to collect user data and produce personalized recommendations. You’ll learn how to use the most popular recommendation algorithms and see examples of them in action on sites like Amazon and Netflix. Finally, the book covers scaling problems and other issues you’ll encounter as your site grows.

Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About this book
About the author
About the cover illustration
Part 1. Getting ready for recommender systems
Chapter 1. What is a recommender?
Chapter 2. User behavior and how to collect it
Chapter 3. Monitoring the system
Chapter 4. Ratings and how to calculate them
Chapter 5. Non-personalized recommendations
Chapter 6. The user (and content) who came in from the cold
Part 2. Recommender algorithms
Chapter 7. Finding similarities among users and among content
Chapter 8. Collaborative filtering in the neighborhood
Chapter 9. Evaluating and testing your recommender
Chapter 10. Content-based filtering
Chapter 11. Finding hidden genres with matrix factorization
Chapter 12. Taking the best of all algorithms: Implementing hybrid recommenders
Chapter 13. Ranking and learning to rank
Chapter 14. Future of recommender systems
Deep Learning and the Game of Go
Deep Learning and the Game of Go

Deep Learning and the Game of Go teaches you how to apply the power of deep learning to complex reasoning tasks by building a Go-playing AI. After exposing you to the foundations of machine and deep learning, you'll use Python to build a bot and then teach it the rules of the game.

Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Foreword
Preface
Acknowledgments
About this book
About the authors
About the cover illustration
Part 1. Foundations
Chapter 1. Toward deep learning: a machine-learning introduction
Chapter 2. Go as a machine-learning problem
Chapter 3. Implementing your first Go bot
Part 2. Machine learning and game AI
Chapter 4. Playing games with tree search
Chapter 5. Getting started with neural networks
Chapter 6. Designing a neural network for Go data
Chapter 7. Learning from data: a deep-learning bot
Chapter 8. Deploying bots in the wild
Chapter 9. Learning by practice: reinforcement learning
Chapter 10. Reinforcement learning with policy gradients
Chapter 11. Reinforcement learning with value methods
Chapter 12. Reinforcement learning with actor-critic methods
Part 3. Greater than the sum of its parts
Chapter 13. AlphaGo: Bringing it all together
Chapter 14. AlphaGo Zero: Integrating tree search with reinforcement learning
Appendix A. Mathematical foundations
Appendix B. The backpropagation algorithm
Appendix C. Go programs and servers
Appendix D. Training and deploying bots by using Amazon Web Services
Appendix E. Submitting a bot to the Online Go Server
Exploring Python Basics
Exploring Python Basics

Let's face it. The only way to learn computer programming is to do it. Whether you want to skill up for your next job interview or just get a few pet projects done, programming can be an amazing tool. Python is an especially great tool for beginners, and it's also a language that grows with you. You can use Python for everything from web development to data science by taking advantage of its huge array of frameworks and toolkits. Know the basics of Python, and you can go (nearly) anywhere in the programming world!

Exploring Python Basics is a collection of chapters from several different Manning books, blended together to give you a tour of everything Python. Hand-picked by Naomi Ceder, the founder of the Python Education Summit, these chapters will get you covering the basics of programming and the quirks and syntax of Python, coding with a Raspberry Pi, and even using Python to model your data to create accurate predictions! After you're finished, you'll have a real appreciation for Python, ready to continue your journey into this ever-useful language.

Exploring Python – the basics
Promo
Copyright 2018 Manning Publications
about
brief contents
Part 1. Learning how to program
Chapter 1. Basic principles of learning a programming language
Chapter 2. Introducing Python: a programming language
Chapter 3. Variables and expressions: giving names and values to things
Chapter 4. Object types and statements of code
Chapter 5. Capstone project: your first Python program—convert hours to minutes
Part 2. Meet Raspberry Pi
Chapter 6. Meet Raspberry Pi
Chapter 7. Blinky Pi
Part 3. Python—Absolute Basics
Chapter 8. The absolute basics
Chapter 9. Lists, tuples, and sets
Part 4. Modeling and prediction
Chapter 10. Modeling and prediction
Elixir in Action
Testing Microservices with Mountebank
Beyond Spreadsheets with R
Swift in Depth
Testing Vue.js Applications
Data Wrangling with JavaScript
Angular Development with Typescript, Second Edition
Serverless Architectures on AWS, Second Edition MEAP V02
Serverless Architectures on AWS, Second Edition MEAP V02

Serverless Architectures on AWS, Second Edition teaches you how to design, secure and manage serverless backends that can power the most demanding web and mobile apps! This new edition has been fully-updated to include new chapters on current best practices and innovative use-cases, along with full coverage of the latest changes to AWS.

Copyright 2018 Manning Publications
brief contents
welcome
1 Going serverless
3 Building a serverless application
4 Setting up your cloud
12 Blackbelt Lambda
B Installation and setup
Testing Angular Applications
Functional Programming in C++
Microservices Patterns
Spring in Action, Fifth Edition
Microservices in Action
Electron in Action
Graph-Powered Machine Learning MEAP V01
Graph-Powered Machine Learning MEAP V01

At its core, machine learning is about efficiently identifying patterns and relationships in data. Many tasks, such as finding associations among terms so you can make accurate search recommendations or locating individuals within a social network who have similar interests, are naturally expressed as graphs. Graph-Powered Machine Learning teaches you how to use graph-based algorithms and data organization strategies to develop superior machine learning applications.

Copyright 2018 Manning Publications
welcome
brief contents
1 Machine Learning and Graph: An introduction
2 Graph Data Engineering
3 Graphs in Machine Learning Application
Enterprise Java Microservices
Modern Java in Action: Lambdas, streams, reactive and functional programming
Modern Java in Action: Lambdas, streams, reactive and functional programming

Manning's bestselling Java 8 book has been revised for Java 9 and 10! In Modern Java in Action, you'll build on your existing Java language skills with the newest features and techniques.

Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Praise for the previous edition, Java 8 in Action, by Raoul-Gabriel Urma, Mario Fusco, and Alan Mycroft.
Preface
Acknowledgments
About this book
About the authors
About the cover illustration
Part 1. Fundamentals
Chapter 1. Java 8, 9, 10, and 11: what’s happening?
Chapter 2. Passing code with behavior parameterization
Chapter 3. Lambda expressions
Part 2. Functional-style data processing with streams
Chapter 4. Introducing streams
Chapter 5. Working with streams
Chapter 6. Collecting data with streams
Chapter 7. Parallel data processing and performance
Part 3. Effective programming with streams and lambdas
Chapter 8. Collection API enhancements
Chapter 9. Refactoring, testing, and debugging
Chapter 10. Domain-specific languages using lambdas
Part 4. Everyday Java
Chapter 11. Using Optional as a better alternative to null
Chapter 12. New Date and Time API
Chapter 13. Default methods
Chapter 14. The Java Module System
Part 5. Enhanced Java concurrency
Chapter 15. Concepts behind CompletableFuture and reactive programming
Chapter 16. CompletableFuture: composable asynchronous programming
Chapter 17. Reactive programming
Part 6. Functional programming and future Java evolution
Chapter 18. Thinking functionally
Chapter 19. Functional programming techniques
Chapter 20. Blending OOP and FP: Comparing Java and Scala
Chapter 21. Conclusions and where next for Java
Appendix A. Miscellaneous language updates
Appendix B. Miscellaneous library updates
Appendix C. Performing multiple operations in parallel on a stream
Appendix D. Lambdas and JVM bytecode
Amazon Web Services in Action, Second Edition
Amazon Web Services in Action, Second Edition

Amazon Web Services in Action, Second Edition is a comprehensive introduction to computing, storing, and networking in the AWS cloud. You'll find clear, relevant coverage of all the essential AWS services you to know, emphasizing best practices for security, high availability and scalability.

Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Praise for the First Edition
Foreword
Preface
Acknowledgments
About this book
About the authors
About the cover illustration
Part 1. Getting started
Chapter 1. What is Amazon Web Services?
Chapter 2. A simple example: WordPress in five minutes
Part 2. Building virtual infrastructure consisting of computers and networking
Chapter 3. Using virtual machines: EC2
Chapter 4. Programming your infrastructure: The command-line, SDKs, and CloudFormation
Chapter 5. Automating deployment: CloudFormation, Elastic Beanstalk, and OpsWorks
Chapter 6. Securing your system: IAM, security groups, and VPC
Chapter 7. Automating operational tasks with Lambda
Part 3. Storing data in the cloud
Chapter 8. Storing your objects: S3 and Glacier
Chapter 9. Storing data on hard drives: EBS and instance store
Chapter 10. Sharing data volumes between machines: EFS
Chapter 11. Using a relational database service: RDS
Chapter 12. Caching data in memory: Amazon ElastiCache
Chapter 13. Programming for the NoSQL database service: DynamoDB
Part 4. Architecting on AWS
Chapter 14. Achieving high availability: availability zones, auto-scaling, and CloudWatch
Chapter 15. Decoupling your infrastructure: Elastic Load Balancing and Simple Queue Service
Chapter 16. Designing for fault tolerance
Chapter 17. Scaling up and down: auto-scaling and CloudWatch
Vue.js in Action
Get Programming with Go
Get Programming with Go

Get Programming with Go introduces you to the powerful Go language without confusing jargon or high-level theory. By working through 32 quick-fire lessons, you'll quickly pick up the basics of the innovative Go programming language!

Conclusion. Where to Go from here
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About this book
About the authors
Unit 0. Getting started
Lesson 1. Get ready, get set, Go
Unit 1. Imperative programming
Lesson 2. A glorified calculator
Lesson 3. Loops and branches
Lesson 4. Variable scope
Lesson 5. Capstone: Ticket to Mars
Unit 2. Types
Lesson 6. Real numbers
Lesson 7. Whole numbers
Lesson 8. Big numbers
Lesson 9. Multilingual text
Lesson 10. Converting between types
Lesson 11. Capstone: The Vigenère cipher
Unit 3. Building blocks
Lesson 12. Functions
Lesson 13. Methods
Lesson 14. First-class functions
Lesson 15. Capstone: Temperature tables
Unit 4. Collections
Lesson 16. Arrayed in splendor
Lesson 17. Slices: windows into arrays
Lesson 18. A bigger slice
Lesson 19. The ever-versatile map
Lesson 20. Capstone: A slice of life
Unit 5. State and behavior
Lesson 21. A little structure
Lesson 22. Go’s got no class
Lesson 23. Composition and forwarding
Lesson 24. Interfaces
Lesson 25. Capstone: Martian animal sanctuary
Unit 6. Down the gopher hole
Lesson 26. A few pointers
Lesson 27. Much ado about nil
Lesson 28. To err is human
Lesson 29. Capstone: Sudoku rules
Unit 7. Concurrent programming
Lesson 30. Goroutines and concurrency
Lesson 31. Concurrent state
Lesson 32. Capstone: Life on Mars
Appendix. Solutions
Kafka Streams in Action: Real-time apps and microservices with the Kafka Streams API
Linux in Action
Linux in Action

Linux in Action is a task-based tutorial that will give you the skills and deep understanding you need to administer a Linux-based system. This hands-on book guides you through 12 real-world projects so you can practice as you learn. Each chapter ends with a review of best practices, new terms, and exercises.

Conclusion
Linux in Action topics
Networking troubleshooting workflow
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About this book
About the author
About the cover illustration
Chapter 1. Welcome to Linux
Chapter 2. Linux virtualization: Building a Linux working environment
Chapter 3. Remote connectivity: Safely accessing networked machines
Chapter 4. Archive management: Backing up or copying entire file systems
Chapter 5. Automated administration: Configuring automated offsite backups
Chapter 6. Emergency tools: Building a system recovery device
Chapter 7. Web servers: Building a MediaWiki server
Chapter 8. Networked file sharing: Building a Nextcloud file-sharing server
Chapter 9. Securing your web server
Chapter 10. Securing network connections: Creating a VPN or DMZ
Chapter 11. System monitoring: Working with log files
Chapter 12. Sharing data over a private network
Chapter 13. Troubleshooting system performance issues
Chapter 14. Troubleshooting network issues
Chapter 15. Troubleshooting peripheral devices
Chapter 16. DevOps tools: Deploying a scripted server environment using Ansible
Appendix. A chapter-by-chapter, command-line review
Securing DevOps
Google Cloud Platform in Action
Google Cloud Platform in Action

Google Cloud Platform in Action teaches you to build and launch applications that scale, leveraging the many services on GCP to move faster than ever. You'll learn how to choose exactly the services that best suit your needs, and you’ll be able to build applications that run on Google Cloud Platform and start more quickly, suffer fewer disasters, and require less maintenance.

Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Foreword
Preface
Acknowledgments
About this book
About the cover illustration
Part 1. Getting started
Chapter 1. What is “cloud”?
Chapter 2. Trying it out: deploying WordPress on Google Cloud
Chapter 3. The cloud data center
Part 2. Storage
Chapter 4. Cloud SQL: managed relational storage
Chapter 5. Cloud Datastore: document storage
Chapter 6. Cloud Spanner: large-scale SQL
Chapter 7. Cloud Bigtable: large-scale structured data
Chapter 8. Cloud Storage: object storage
Part 3. Computing
Chapter 9. Compute Engine: virtual machines
Chapter 10. Kubernetes Engine: managed Kubernetes clusters
Chapter 11. App Engine: fully managed applications
Chapter 12. Cloud Functions: serverless applications
Chapter 13. Cloud DNS: managed DNS hosting
Part 4. Machine learning
Chapter 14. Cloud Vision: image recognition
Chapter 15. Cloud Natural Language: text analysis
Chapter 16. Cloud Speech: audio-to-text conversion
Chapter 17. Cloud Translation: multilanguage machine translation
Chapter 18. Cloud Machine Learning Engine: managed machine learning
Part 5. Data processing and analytics
Chapter 19. BigQuery: highly scalable data warehouse
Chapter 20. Cloud Dataflow: large-scale data processing
Chapter 21. Cloud Pub/Sub: managed event publishing
Learn Azure in a Month of Lunches
Testing Java Microservices: Using Arquillian, Hoverfly, AssertJ, JUnit, Selenium, and Mockito
Exploring Swift
Exploring Swift

Swift is more than just a modern replacement for Objective-C. Ever since going open source in 2015, Swift has evolved into a language that is powerful, modern, and expressive. It' used everywhere from web development to server-side development and cloud-based services! There's a rich, deep world of Swift skills for delivering cleaner, faster code. All you have to do is find out how to use it.

Exploring Swift distils the knowledge of three expert Manning authors, introducing you to how Swift can handle a wide array of unique problems. Hand-picked by iOS developer, Manning author, and mentor Craig Grummitt, this quick-start guide has you exploring objects, modeling data with enums, and solving graph issues, all with just Swift, giving you an understanding of the language in the worlds of data and beyond. When you finish, you'll have a better idea of what you can use Swift for, whether you're building the next big iOS app, taking it to the server, or even writing serverless functions!

Introduction
Copyright 2018 Manning Publications
about
brief contents
Part 1. Swift objects
Chapter 1. Swift objects
Part 2. Modeling data with enums
Chapter 2. Modeling data with enums
Part 3. Graph problems
Chapter 3. Graph problems
Usability Matters: Mobile-first UX for developers and other accidental designers
Aurelia in Action
Entity Framework Core in Action
.NET Core in Action
C++ Concurrency in Action, Second Edition MEAP V07
C++ Concurrency in Action, Second Edition MEAP V07

This bestseller has been updated and revised to cover all the latest changes to C++ 14 and 17! C++ Concurrency in Action, Second Edition teaches you everything you need to write robust and elegant multithreaded applications in C++17. You'll discover the basics of starting new threads, how to synchronize operations between threads, designing multithreaded algorithms and data structures, and more. Along the way, you'll learn how to navigate the trickier bits of programming for concurrency while avoiding the common pitfalls.

Copyright 2018 Manning Publications
welcome
brief contents
1 Hello, world of concurrency in C++!
2 Managing threads
3 Sharing data between threads
4 Synchronizing concurrent operations
5 The C++ memory model and operations on atomic types
6 Designing lock-based concurrent data structures
7 Designing lock-free concurrent data structures
8 Designing concurrent code
9 Advanced thread management
10 Parallel algorithms
11 Testing and debugging multithreaded applications
A Brief reference for some C++11 language features
B Brief comparison of concurrency libraries
C A message-passing framework and complete ATM example
D C++ Thread Library reference
Building Chatbots with Microsoft Bot Framework and Node.js MEAP V04
Building Chatbots with Microsoft Bot Framework and Node.js MEAP V04

Welcome to the chatbot revolution! Nowadays, chatbots are talking you through your taxes, recommending suitable places to eat out, and even helping diagnose medical conditions. Chatbots can be interesting, fun, and challenging beasts to develop, and Building Chatbots with Microsoft Bot Framework and Node.js is your guide to the latest ideas and technologies for making virtual conversational companions that get the job done.

Copyright 2018 Manning Publications
welcome
brief contents
1 Introduction to Chatbots
2 Conversational Design
3 Recognizing Intent from the User Query
4 Recognizing Entities
5 Managing Conversational Flow with Dialog Management
6 Managing State Data
Concurrency in .NET
Concurrency in .NET

Concurrency in .NET teaches you how to build concurrent and scalable programs in .NET using the functional paradigm. This intermediate-level guide is aimed at developers, architects, and passionate computer programmers who are interested in writing code with improved speed and effectiveness by adopting a declarative and pain-free programming style.

Cover
Titlepage
Dedication
Index
preface
Acknowledgments
About This Book
About the Author
About the Cover Illustration
Part 1 : Benefits of functional programming applicable to concurrent programs
Chapter 1: Functional concurrency foundations
Chapter 2: Functional programming techniques for concurrency
Chapter 3: Functional data structures and immutability
Part 2: How to approach the different parts of a concurrent program
Chapter 4: The basics of processing big data: data parallelism, part 1
Chapter 5: PLINQ and MapReduce: data parallelism, part 2
Chapter 6: Real-time event streams: functional reactive programming
Chapter 7: Task-based functional parallelism
Chapter 8: Task asynchronicity for the win
Chapter 9: Asynchronous functional programming in F#
Chapter 10: Functional combinators for fluent concurrent programming
Chapter 11: Applying reactive programming everywhere with agents
Chapter 12: Parallel workflow and agent programming with TPL Dataflow
Part 3: Modern patterns of concurrent programming applied
Chapter 13: Recipes and design patterns for successful concurrent programming
Chapter 14: Building a scalable mobile app with concurrent functional programming
Appendix A: Functional programming
Appendix B: F# overview
Appendix C: Interoperability between an F# asynchronous workflow and .NET Task
ASP.NET Core in Action
ASP.NET Core in Action

ASP.NET Core in Action is for C# developers without any web development experience who want to get started and productive fast using ASP.NET Core 2.0 to build web applications.

Useful .NET CLI (dotnet) commands. Use --help to see all the optional arguments
Overview of an MVC request using ASP.NET Core
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About this book
About the author
About the cover illustration
Part 1. Getting started with MVC
Chapter 1. Getting started with ASP.NET Core
Chapter 2. Your first application
Chapter 3. Handling requests with the middleware pipeline
Chapter 4. Creating web pages with MVC controllers
Chapter 5. Mapping URLs to methods using conventional routing
Chapter 6. The binding model: retrieving and validating user input
Chapter 7. Rendering HTML using Razor views
Chapter 8. Building forms with Tag Helpers
Chapter 9. Creating a Web API for mobile and client applications using MVC
Part 2. Building complete applications
Chapter 10. Service configuration with dependency injection
Chapter 11. Configuring an ASP.NET Core application
Chapter 12. Saving data with Entity Framework Core
Chapter 13. The MVC filter pipeline
Chapter 14. Authentication: adding users to your application with Identity
Chapter 15. Authorization: securing your application
Chapter 16. Publishing and deploying your application
Part 3. Extending your applications
Chapter 17. Monitoring and troubleshooting errors with logging
Chapter 18. Improving your application’s security
Chapter 19. Building custom components
Chapter 20. Testing your application
Appendix A. Getting to grips with .NET Core and .NET Standard
Appendix B. Useful references
Isomorphic Web Applications: Universal Development with React
Reactive Application Development
React in Action
Machine Learning Systems: Designs that scale
Exploring Data With Python
Exploring Data With Python

Python has become a required skill for data science, and it's easy to see why. It's powerful, easy to learn, and includes the libraries like Pandas, Numpy, and Scikit that help you slice, scrub, munge, and wrangle your data. Even with a great language and fantastic tools though, there's plenty to learn!

Exploring Data with Python is a collection of chapters from three Manning books, hand-picked by Naomi Ceder, the chair of the Python Software Foundation. This free eBook starts building your foundation in data science processes with practical Python tips and techniques for working and aspiring data scientists. In it, you'll get a clear introduction to the data science process. Then, you'll practice using Python for processing, cleaning, and exploring interesting datasets. Finally, you'll get a practical demonstration of modelling and prediction with classification and regression. When you finish, you'll have a good overview of Python in data science and a well-lit path to continue your learning.

introduction
The data science process
Processing data files
Exploring data
Modeling andprediction
Copyright 2018 Manning Publications
about
brief contents
about the authors
Part 1. The data science process
Part 2. Processing data files
Part 3. Exploring data
Part 4. Modeling and prediction
Redux in Action
The Quick Python Book, Third Edition
The Quick Python Book, Third Edition

GET MORE WITH MANNING

An eBook copy of the previous edition, The Quick Python Book, Second Edition, is included at no additional cost. It will be automatically added to your Manning Bookshelf within 24 hours of purchase.


This third revision of Manning's popular The Quick Python Book offers a clear, crisp updated introduction to the elegant Python programming language and its famously easy-to-read syntax. Written for programmers new to Python, this latest edition includes new exercises throughout. It covers features common to other languages concisely, while introducing Python's comprehensive standard functions library and unique features in detail.

Case study
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Praise for the second edition
Foreword
Preface
Acknowledgments
About this book
About the cover illustration
Part 1. Starting out
Chapter 1. About Python
Chapter 2. Getting started
Chapter 3. The Quick Python overview
Part 2. The essentials
Chapter 4. The absolute basics
Chapter 5. Lists, tuples, and sets
Chapter 6. Strings
Chapter 7. Dictionaries
Chapter 8. Control flow
Chapter 9. Functions
Chapter 10. Modules and scoping rules
Chapter 11. Python programs
Chapter 12. Using the filesystem
Chapter 13. Reading and writing files
Chapter 14. Exceptions
Part 3. Advanced language features
Chapter 15. Classes and object-oriented programming
Chapter 16. Regular expressions
Chapter 17. Data types as objects
Chapter 18. Packages
Chapter 19. Using Python libraries
Part 4. Working with data
Chapter 20. Basic file wrangling
Chapter 21. Processing data files
Chapter 22. Data over the network
Chapter 23. Saving data
Chapter 24. Exploring data
Appendix A. A guide to Python’s documentation
Appendix B. Exercise answers
The Java Module System MEAP V10
The Java Module System MEAP V10

Java's much-awaited "Project Jigsaw" is finally here! Java 9 will include a built-in modularity framework, and The Java Module System is your guide to discovering it. In this new book, you'll learn how the module system improves reliability and maintainability and can be used to reduce tight coupling of system components. You'll then discover how to build, compile, and run your own fully modular applications with best practices and expert techniques. Along the way, you'll also explore Java 9's compatibility challenges and how to migrate your application to the module system.

About this MEAP
Welcome
Part 1: Hello, Modules
1 First piece of the puzzle
2 Anatomy of a modular application
3 Defining modules and their properties
4 Building modules from source to JAR
5 Running and debugging modular applications
Part 2: Adapting Real-World Projects
6 Compatibility challenges when moving to Java 9
7 Recurring challenges when running on Java 9
8 Incremental modularization of existing projects
9 Migration and modularization strategies
Part 3: Advanced Module System Features
10 Using services to decouple modules
11 Refining dependencies and APIs
12 Reflection in a modular world
13 Module versions—what’s possible and what’s not
14 Customizing runtime images with jlink
15 Putting the pieces together
Appendixes
MEAP VERSION 10
Front matter
A Class path recap
B High-level introduction to the reflection API
C Observing the JVM with unified logging
D Analyzing a project’s dependencies with JDeps
E Targeting multiple Java versions with multi-release JARs
OpenShift in Action
Get Programming with JavaScript Next: New features of ECMAScript 2015, 2016, and beyond
Get Programming with JavaScript Next: New features of ECMAScript 2015, 2016, and beyond

Get Programming with JavaScript Next introduces the modern age of JavaScript programming with ES6 and ES7 without dragging you through confusing jargon and abstract examples you'll never use. In just 34 quick-fire sessions, you'll quickly be coding with the latest features and functions of ES6 and ES7!

Here’s a preview of some of the new syntaxes you’ll learn in unit 2
Here’s a preview of using promises and async functions from unit 7
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About this book
About the author
Lesson 1. ECMAScript specification and the proposal process
Lesson 2. Transpiling with Babel
Lesson 3. Bundling modules with Browserify
Unit 1. Variables and strings
Lesson 4. Declaring variables with let
Lesson 5. Declaring constants with const
Lesson 6. New string methods
Lesson 7. Template literals
Lesson 8. Capstone: Building a domain-specific language
Unit 2. Objects and arrays
Lesson 9. New array methods
Lesson 10. Object.assign
Lesson 11. Destructuring
Lesson 12. New object literal syntax
Lesson 13. Symbol—a new primitive
Lesson 14. Capstone: Simulating a lock and key
Unit 3. Functions
Lesson 15. Default parameters and rest
Lesson 16. Destructuring parameters
Lesson 17. Arrow functions
Lesson 18. Generator functions
Lesson 19. Capstone: The prisoner’s dilemma
Unit 4. Modules
Lesson 20. Creating modules
Lesson 21. Using modules
Lesson 22. Capstone: Hangman game
Unit 5. Iterables
Lesson 23. Iterables
Lesson 24. Sets
Lesson 25. Maps
Lesson 26. Capstone: Blackjack
Unit 6. Classes
Lesson 27. Classes
Lesson 28. Extending classes
Lesson 29. Capstone: Comets
Unit 7. Working asynchronously
Lesson 30. Promises
Lesson 31. Advanced promises
Lesson 32. Async functions
Lesson 33. Observables
Lesson 34. Capstone: Canvas image gallery
Appendix. Exercise answers
Exploring requirements with Specification by Example
Exploring requirements with Specification by Example

Great software starts with a meaningful description of its users and intent. Exploring requirements with Specification by Example is a collection of hand-picked chapters selected from three novel and insightful books. We hope they'll give you a glimpse at how to write clear specifications in a collaborative, purpose-driven way.

In Exploring requirements with Specification by Example you'll get an overlook of key process patterns essential for using a specification by example approach. Next, you'll go on a whirlwind tour of behavior-driven development and how to implement the basics into your pipeline. Finally, you'll learn how to pick great scenario outlines to use in your documentation. Altogether, you'll have the right frame of mind for writing specifications that improve the quality and usefulness of your software!

What is Specification by Example?

The clearest way to communicate a software specification is to provide examples of how it should work. Specification by Example is a collaborative method for specifying requirements and tests by collecting and documenting use cases. The method brings four great benefits to your team: it produces living, reliable documentation anyone can read; it defines expectations clearly and makes validation efficient; it reduces rework; and, above all, it lets everyone know that the end product is built exactly for its purpose!

This powerful technique is fully documented in Specification by Example by Gojko Adzic.

Introduction
Promo
Copyright 2017 Manning Publications
about
brief contents
Part 1. Key process patterns
Chapter 1. Key process patterns
Part 2. BDD—the whirlwind tour
Chapter 2. BDD—the whirlwind tour
Part 3. Choosing examples for scenario outlines
Chapter 3. Choosing examples for scenario outlines
The Art of Data Usability MEAP V06
The Art of Data Usability MEAP V06

Data is only valuable if it's useful. If you're responsible for making meaningful data available to business stakeholders, researchers, or even the general public, you need a predictable process for discerning the users' needs and delivering the right data in the right way. So how do you establish the correct priorities and measures of relevance? How do you continuously improve your data projects? This is the essential art of data usability.

About this MEAP
Welcome
1 Learning from the past
2 Creating the perfect world
3 The structure of a data project
4 Knowing what people want
5 Applying continuous quality control
6 Setting up your workflow
7 Maintaining quality controls after project end
8 The reference period
9 Utilizing Warnings in Monitoring Solutions
10 Recurring attributes
11 The KISS of quality
12 Combining smaller controls into a meta-control
13 Improving an attribute with another attribute
14 Checking what doesn’t exist
15 Hooking monitoring into a feedback process
16 Using the data you expect
MEAP VERSION 6
A Docker
B Installing and using Python
C Data formats
Unity in Action
Get Programming: Learn to code with Python
Get Programming: Learn to code with Python

Get Programming: Learn to code with Python introduces you to the world of writing computer programs without drowning you in confusing jargon or theory that make getting started harder than it should be. Filled with practical examples and step-by-step lessons using the easy-on-the-brain Python language, this book will get you programming in no time!

Thinking like a programmer: big ideas
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About this Book
About the author
Unit 0. Learning how to program
Lesson 1. Why should you learn how to program?
Lesson 2. Basic principles of learning a programming language
Unit 1. Variables, types, expressions, and statements
Lesson 3. Introducing Python: a programming language
Lesson 4. Variables and expressions: giving names and values to things
Lesson 5. Object types and statements of code
Lesson 6. Capstone project: your first Python program—convert hours to minutes
Unit 2. Strings, tuples, and interacting with the user
Lesson 7. Introducing string objects: sequences of characters
Lesson 8. Advanced string operations
Lesson 9. Simple error messages
Lesson 10. Tuple objects: sequences of any kind of object
Lesson 11. Interacting with the user
Lesson 12. Capstone project: name mashup
Unit 3. Making decisions in your programs
Lesson 13. Introducing decisions in programs
Lesson 14. Making more-complicated decisions
Lesson 15. Capstone project: choose your own adventure
Unit 4. Repeating tasks
Lesson 16. Repeating tasks with loops
Lesson 17. Customizing loops
Lesson 18. Repeating tasks while conditions hold
Lesson 19. Capstone project: Scrabble, Art Edition
Unit 5. Organizing your code into reusable blocks
Lesson 20. Building programs to last
Lesson 21. Achieving modularity and abstraction with functions
Lesson 22. Advanced operations with functions
Lesson 23. Capstone project: analyze your friends
Unit 6. Working with mutable data types
Lesson 24. Mutable and immutable objects
Lesson 25. Working with lists
Lesson 26. Advanced operations with lists
Lesson 27. Dictionaries as maps between objects
Lesson 28. Aliasing and copying lists and dictionaries
Lesson 29. Capstone project: document similarity
Unit 7. Making your own object types by using object-oriented programming
Lesson 30. Making your own object types
Lesson 31. Creating a class for an object type
Lesson 32. Working with your own object types
Lesson 33. Customizing classes
Lesson 34. Capstone project: card game
Unit 8. Using libraries to enhance your programs
Lesson 35. Useful libraries
Lesson 36. Testing and debugging your programs
Lesson 37. A library for graphical user interfaces
Lesson 38. Capstone project: game of tag
Appendix A. Answers to lesson exercises
Appendix B. Python cheat sheet
Appendix C. Interesting Python libraries
Classic Computer Science Problems in Swift: Essential techniques for practicing programmers
Classic Computer Science Problems in Swift: Essential techniques for practicing programmers

Classic Computer Science Problems in Swift deepens your Swift language skills by exploring foundational coding techniques and algorithms. As you work through examples in search, clustering, graphs, and more, you'll remember important things you've forgotten and discover classic solutions to your "new" problems. All examples are written in Swift 4.1.

Introduction
Index
List of Figures
List of Tables
Copyright
Table of Contents
Acknowledgments
About this Book
Chapter 1. Small problems
Chapter 2. Search problems
Chapter 3. Constraint-satisfaction problems
Chapter 4. Graph problems
Chapter 5. Genetic algorithms
Chapter 6. K-means clustering
Chapter 7. Fairly simple neural networks
Chapter 8. Miscellaneous problems
Appendix A. Glossary
Appendix B. More resources
Appendix C. A brief history of Swift
CSS in Depth
Get Programming with Haskell
Get Programming with Haskell

Get Programming with Haskell introduces you to the Haskell language without drowning you in academic jargon and heavy functional programming theory. By working through 42 easy-to-follow lessons, you'll learn Haskell the best possible way—by doing Haskell!

Afterword. What’s next?
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About this book
About the author
Lesson 1. Getting started with Haskell
Unit 1. Foundations of functional programming
Lesson 2. Functions and functional programming
Lesson 3. Lambda functions and lexical scope
Lesson 4. First-class functions
Lesson 5. Closures and partial application
Lesson 6. Lists
Lesson 7. Rules for recursion and pattern matching
Lesson 8. Writing recursive functions
Lesson 9. Higher-order functions
Lesson 10. Capstone: Functional object-oriented programming with robots!
Unit 2. Introducing types
Lesson 11. Type basics
Lesson 12. Creating your own types
Lesson 13. Type classes
Lesson 14. Using type classes
Lesson 15. Capstone: Secret messages!
Unit 3. Programming in types
Lesson 16. Creating types with “and” and “or”
Lesson 17. Design by composition—Semigroups and Monoids
Lesson 18. Parameterized types
Lesson 19. The Maybe type: dealing with missing values
Lesson 20. Capstone: Time series
Unit 4. IO in Haskell
Lesson 21. Hello World!—introducing IO types
Lesson 22. Interacting with the command line and lazy I/O
Lesson 23. Working with text and Unicode
Lesson 24. Working with files
Lesson 25. Working with binary data
Lesson 26. Capstone: Processing binary files and book data
Unit 5. Working with type in a context
Lesson 27. The Functor type class
Lesson 28. A peek at the Applicative type class: using functions in a context
Lesson 29. Lists as context: a deeper look at the Applicative type class
Lesson 30. Introducing the Monad type class
Lesson 31. Making Monads easier with do-notation
Lesson 32. The list monad and list comprehensions
Lesson 33. Capstone: SQL-like queries in Haskell
Unit 6. Organizing code and building projects
Lesson 34. Organizing Haskell code with modules
Lesson 35. Building projects with stack
Lesson 36. Property testing with QuickCheck
Lesson 37. Capstone: Building a prime-number library
Unit 7. Practical Haskell
Lesson 38. Errors in Haskell and the Either type
Lesson 39. Making HTTP requests in Haskell
Lesson 40. Working with JSON data by using Aeson
Lesson 41. Using databases in Haskell
Lesson 42. Efficient, stateful arrays in Haskell
Appendix. Answers to end-of-lesson exercises
JavaScript on Things: Hacking hardware for web developers
Angular in Action
Get Programming with F#: A guide for .NET developers
Get Programming with F#: A guide for .NET developers

Get Programming with F#: A guide for .NET Developers shows you how to upgrade your .NET development skills by adding a touch of functional programming in F#. In just 43 bite-sized chunks, you'll learn how to use F# to tackle the most common .NET programming tasks.Examples use the familiar Visual Studio environment, so you'll be instantly comfortable. Packed with enlightening examples, real-world use cases, and plenty of easy-to-digest code, this easy-to-follow tutorial will make you wonder why you didn't pick up F# years ago!

Basic F# syntax, types, and functions
Discriminated unions, pattern matching, and lists
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Foreword
Preface
Acknowledgments
About this book
About the author
Welcome to Get Programming with F#!
Unit 1. F# and Visual Studio
Lesson 1. The Visual Studio experience
Lesson 2. Creating your first F# program
Lesson 3. The REPL—changing how we develop
Unit 2. Hello F#
Lesson 4. Saying a little, doing a lot
Lesson 5. Trusting the compiler
Lesson 6. Working with immutable data
Lesson 7. Expressions and statements
Lesson 8. Capstone 1
Unit 3. Types and functions
Lesson 9. Shaping data with tuples
Lesson 10. Shaping data with records
Lesson 11. Building composable functions
Lesson 12. Organizing code without classes
Lesson 13. Achieving code reuse in F#
Lesson 14. Capstone 2
Unit 4. Collections in F#
Lesson 15. Working with collections in F#
Lesson 16. Useful collection functions
Lesson 17. Maps, dictionaries, and sets
Lesson 18. Folding your way to success
Lesson 19. Capstone 3
Unit 5. The pit of success with the F# type system
Lesson 20. Program flow in F#
Lesson 21. Modeling relationships in F#
Lesson 22. Fixing the billion-dollar mistake
Lesson 23. Business rules as code
Lesson 24. Capstone 4
Unit 6. Living on the .NET platform
Lesson 25. Consuming C# from F#
Lesson 26. Working with NuGet packages
Lesson 27. Exposing F# types and functions to C#
Lesson 28. Architecting hybrid language applications
Lesson 29. Capstone 5
Unit 7. Working with data
Lesson 30. Introducing type providers
Lesson 31. Building schemas from live data
Lesson 32. Working with SQL
Lesson 33. Creating type provider-backed APIs
Lesson 34. Using type providers in the real world
Lesson 35. Capstone 6
Unit 8. Web programming
Lesson 36. Asynchronous workflows
Lesson 37. Exposing data over HTTP
Lesson 38. Consuming HTTP data
Lesson 39. Capstone 7
Unit 9. Unit testing
Lesson 40. Unit testing in F#
Lesson 41. Property-based testing in F#
Lesson 42. Web testing
Lesson 43. Capstone 8
Unit 10. Where next?
Appendix A. The F# community
Appendix B. F# in my organization
Appendix C. Must-visit F# resources
Appendix D. Must-have F# libraries
Appendix E. Other F# language features
Exploring Microservice Development
Exploring Microservice Development

Get into the microservices mindset without drowning in the details. Before you start writing code, you need to understand when a microservice architecture makes sense, what has to change in your team organization, and how this approach affects your build, test, and deploy process. There's plenty to learn when you get down to the nuts-and-bolts of building microservices; starting with the big picture makes the details a lot easier to grok.

Exploring Microservice Development is a collection of chapters from three Manning books. Hand-picked by senior cloud engineer John Carnell, this quick-start guide introduces the big picture of microservice design along with a high-level taste of operational concerns like debugging and testing. In it, you'll get a quick overview of decomposition strategies, a look into distributed tracing with Spring Cloud Sleuth and Zipkin for more efficient debugging, and over-the-wire service mocking using Mountebank. When you finish, you'll have a better idea of whether microservices are for you and what you need to get started.

Introduction
1. Chapter 1: Decomposition strategies
2. Chapter 9: Distributed tracing with Spring Cloud Sleuth and Zipkin
3. Chapter 3: Testing Using Canned Responses
Promo
Copyright 2018 Manning Publications
about
brief contents
Part 1: Decomposition strategies
Part 2: Distributed tracing with Spring Cloud Sleuth and Zipkin
Part 3: Testing Using Canned Responses
Camel in Action
Camel in Action

GET MORE WITH MANNING

An eBook copy of the previous edition, Camel in Action (First Edition), is included at no additional cost. It will be automatically added to your Manning Bookshelf within 24 hours of purchase.

Camel in Action, Second Edition is the most complete Camel book on the market. Written by core developers of Camel and the authors of the highly acclaimed first edition, this book distills their experience and practical insights so that you can tackle integration tasks like a pro.

Cover
Camel in Action
Dedication
Index
Praise for the First Edition
Copyright
Foreword
Foreword
Foreword to the First Edition
Preface
Acknowledgments
About This Book
About the Authors
About the Cover Illustration
Part 1: First steps
Chapter 1: Meeting Camel
Chapter 2: Routing with Camel
Part 2: Core Camel
Chapter 3: Transforming data with Camel
Chapter 4: Using beans with Camel
Chapter 5: Enterprise integration patterns
Chapter 6: Using components
Part 3: Developing and testing
Chapter 7: Microservices
Chapter 8: Developing Camel projects
Chapter 9: Testing
Chapter 10: RESTful web services
Part 4: Going further with Camel
Chapter 11: Error handling
Chapter 12: Transactions and idempotency
Chapter 13: Parallel processing
Chapter 14: Securing Camel
Part 5 : Running and managing Camel
Chapter 15: Running and deploying Camel
Chapter 16: Management and monitoring
Part 6: Out in the wild
Chapter 17: Clustering
Chapter 18: Microservices with Docker and Kubernetes
Chapter 19: Camel tooling
Chapter 20: Reactive Camel
Chapter 21: Camel and the IoT
Appendix A: Simple, the expression language
Appendix B: The Camel community
Machine Learning with TensorFlow
RavenDB in Action MEAP v10
RavenDB in Action MEAP v10

Manning will not be releasing RavenDB in Action as a finished book. However, we're pleased to offer the complete manuscript to you FREE. It's still a great way to learn RavenDB; it just lacks our usual finishing touches. Just add the free eBook to your cart and check out. We'll add it to your Manning account. You can also read the complete manuscript in liveBook.

Copyright 2017 Manning Publications
foreword
brief contents
1 A second-generation document database
2 Your first RavenDB application
3 RavenDB indexes
4 Working with indexes
5 Document-oriented Data Modeling
6 Full-text, geo-spatial and reporting queries
7 Scaling out
8 Extending RavenDB
9 Advanced capabilities
10 Getting ready for production
The Transparent Web: Functional, Reactive, Isomorphic MEAP V10
The Transparent Web: Functional, Reactive, Isomorphic MEAP V10

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.

About this MEAP
Welcome
1 Advancing The Web
2 Transparent Client-Server Programming With Opa
3 Unify the Server With MirageOS
4 Unify the Client With WebAssembly
5 Understanding Static Typing
6 Writing Functional Code
7 A Type Safe Web App in Haskell
8 Writing Reactive GUIs With Elm
MEAP VERSION 10
Deep Learning with R
Kubernetes in Action
Kubernetes in Action

Kubernetes in Action is a comprehensive guide to effectively developing and running applications in a Kubernetes environment. Before diving into Kubernetes, the book gives an overview of container technologies like Docker, including how to build containers, so that even readers who haven't used these technologies before can get up and running.

Kubernetes resources covered in the book
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About This Book
About the Author
About the Cover Illustration
Part 1. Overview
Chapter 1. Introducing Kubernetes
Chapter 2. First steps with Docker and Kubernetes
Part 2. Core concepts
Chapter 3. Pods: running containers in Kubernetes
Chapter 4. Replication and other controllers: deploying managed pods
Chapter 5. Services: enabling clients to discover and talk to pods
Chapter 6. Volumes: attaching disk storage to containers
Chapter 7. ConfigMaps and Secrets: configuring applications
Chapter 8. Accessing pod metadata and other resources from applications
Chapter 9. Deployments: updating applications declaratively
Chapter 10. StatefulSets: deploying replicated stateful applications
Part 3. Beyond the basics
Chapter 11. Understanding Kubernetes internals
Chapter 12. Securing the Kubernetes API server
Chapter 13. Securing cluster nodes and the network
Chapter 14. Managing pods’ computational resources
Chapter 15. Automatic scaling of pods and cluster nodes
Chapter 16. Advanced scheduling
Chapter 17. Best practices for developing apps
Chapter 18. Extending Kubernetes
Appendix A. Using kubectl with multiple clusters
Appendix B. Setting up a multi-node cluster with kubeadm
Appendix C. Using other container runtimes
Appendix D. Cluster Federation
The Tao of Microservices
Progressive Web Apps
Deep Learning with Python
D3.js in Action, Second Edition: Data visualization with JavaScript
iOS Development with Swift
Hello Scratch!: Learn to program by making arcade games
Learn PowerShell Scripting in a Month of Lunches
Learn PowerShell Scripting in a Month of Lunches

Discover how scripting is different from command-line PowerShell, as you explore concrete hands-on examples in this handy guide. The book includes and expands on many of the techniques presented in Learn PowerShell Toolmaking in a Month of Lunches.

Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About this Book
About the Authors
Part 1. Introduction to scripting
Chapter 1. Before you begin
Chapter 2. Setting up your scripting environment
Chapter 3. WWPD: what would PowerShell do?
Chapter 4. Review: parameter binding and the PowerShell pipeline
Chapter 5. Scripting language crash course
Chapter 6. The many forms of scripting (and which to use)
Chapter 7. Scripts and security
Part 2. Building a PowerShell script
Chapter 8. Always design first
Chapter 9. Avoiding bugs: start with a command
Chapter 10. Building a basic function and script module
Chapter 11. Going advanced with your function
Chapter 12. Objects: the best kind of output
Chapter 13. Using all the pipelines
Chapter 14. Simple help: making a comment
Chapter 15. Dealing with errors
Chapter 16. Filling out a manifest
Part 3. Grown-up scripting
Chapter 17. Changing your brain when it comes to scripting
Chapter 18. Professional-grade scripting
Chapter 19. An introduction to source control with git
Chapter 20. Pestering your script
Chapter 21. Signing your script
Chapter 22. Publishing your script
Part 4. Advanced techniques
Chapter 23. Squashing bugs
Chapter 24. Making script output prettier
Chapter 25. Wrapping up the .NET Framework
Chapter 26. Storing data—not in Excel!
Chapter 27. Never the end
Appendix. Toolmaking Best Practices Checklist
Writing Great Specifications: Using Specification by Example and Gherkin
Exploring .NET Core with Microservices, ASP.NET Core, and Entity Framework Core
Exploring .NET Core with Microservices, ASP.NET Core, and Entity Framework Core

Windows developers have always enjoyed the productivity boost you get with the .NET platform, tools like Entity Framework and ASP.NET, and the amazingly-powerful C# language. Now, .NET Core extends those same benefits to Linux-based systems, offering a true cross-platform solution for enterprise application development. The .NET Core tools, including Entity Framework Core and ASP.NET Core, are lightweight and modular, and they offer similar performance to native Linux and JVM-based frameworks without requiring you to learn a new toolset or rebuild your applications. In a world where platform lock-in is an unpardonable sin, .NET Core offers a perfect pathway to the cloud-based, distributed environments that rule the day.

Exploring .NET Core with Microservices, ASP.NET Core, and Entity Framework Core is a collection of five hand-picked chapters introducing you to the art of applying modern development practices and patterns to your .NET Core projects. In it, you'll get a quick overview of what ASP.NET Core and Entity Framework Core offer, along with an introduction to microservices and web applications using .NET Core tooling. You'll also get some tips on working with legacy code in this new environment. In short, this free eBook will get your feet wet and show you real-world examples that illustrate what's possible.

Introduction
Promo
Copyright 2017 Manning Publications
about
brief contents
Part 1. Refactoring
Chapter 1. Refactoring
Part 2. Identifying and scoping microservices
Chapter 2. Identifying and scoping microservices
Part 3. Creating and Communicating with Web Services
Chapter 3. Creating a Microservice
Part 4. Creating web pages with MVC Controllers
Chapter 4. Creating web pages with MVC Controllers
Part 5. Querying the database
Chapter 5. Querying the database
RabbitMQ in Depth
RabbitMQ in Depth

RabbitMQ in Depth is a practical guide to building and maintaining message-based applications. This book provides detailed coverage of RabbitMQ with an emphasis on why it works the way it does. You'll find examples and detailed explanations based in real-world systems ranging from simple networked services to complex distributed designs. You'll also find the insights you need to make core architectural choices and develop procedures for effective operational management.

Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About This Book
Part 1. RabbitMQ and application architecture
Chapter 1. Foundational RabbitMQ
Chapter 2. How to speak Rabbit: the AMQ Protocol
Chapter 3. An in-depth tour of message properties
Chapter 4. Performance trade-offs in publishing
Chapter 5. Don’t get messages; consume them
Chapter 6. Message patterns via exchange routing
Part 2. Managing RabbitMQ in the data center or the cloud
Chapter 7. Scaling RabbitMQ with clusters
Chapter 8. Cross-cluster message distribution
Part 3. Integrations and customization
Chapter 9. Using alternative protocols
Chapter 10. Database integrations
Appendix. Getting set up
Secrets of the JavaScript Ninja, Second Edition
Secrets of the JavaScript Ninja, Second Edition

GET MORE WITH MANNING An eBook copy of the previous edition, Secrets of the JavaScript Ninja (First Edition), is included at no additional cost. It will be automatically added to your Manning account within 24 hours of purchase.


More than ever, the web is a universal platform for all types of applications, and JavaScript is the language of the web. If you're serious about web development, it's not enough to be a decent JavaScript coder. You need to be ninja-stealthy, efficient, and ready for anything. This book shows you how.

ES6 cheat sheet
Author’s Introduction
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Praise for the First Edition
Acknowledgments
About this Book
About the Cover Illustration
Part 1. Warming up
Chapter 1. JavaScript is everywhere
Chapter 2. Building the page at runtime
Part 2. Understanding functions
Chapter 3. First-class functions for the novice: definitions and arguments
Chapter 4. Functions for the journeyman: understanding function invocation
Chapter 5. Functions for the master: closures and scopes
Chapter 6. Functions for the future: generators and promises
Part 3. Digging into objects and fortifying your code
Chapter 7. Object orientation with prototypes
Chapter 8. Controlling access to objects
Chapter 9. Dealing with collections
Chapter 10. Wrangling regular expressions
Chapter 11. Code modularization techniques
Part 4. Browser reconnaissance
Chapter 12. Working the DOM
Chapter 13. Surviving events
Chapter 14. Developing cross-browser strategies
Appendix A. Additional ES6 features
Appendix B. Arming with testing and debugging
Appendix C. Exercise answers
The Art of Unit Testing, Second Edition: with examples in C#
The Art of Unit Testing, Second Edition: with examples in C#

An eBook copy of the previous edition, The Art of Unit Testing (First Edition), is included at no additional cost. It will be automatically added to your Manning Bookshelf within 24 hours of purchase.


The Art of Unit Testing, Second Edition guides you step by step from writing your first simple tests to developing robust test sets that are maintainable, readable, and trustworthy. You'll master the foundational ideas and quickly move to high-value subjects like mocks, stubs, and isolation, including frameworks such as Moq, FakeItEasy and Typemock Isolator. You'll explore test patterns and organization, working with legacy code, and even "untestable" code. Along the way, you'll learn about integration testing and techniques and tools for testing databases and other technologies.

Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Foreword to the Second Edition
Foreword to the First Edition
Preface
Acknowledgments
About this Book
About the Cover Illustration
Part 1. Getting started
Chapter 1. The basics of unit testing
Chapter 2. A first unit test
Part 2. Core techniques
Chapter 3. Using stubs to break dependencies
Chapter 4. Interaction testing using mock objects
Chapter 5. Isolation (mocking) frameworks
Chapter 6. Digging deeper into isolation frameworks
Part 3. The test code
Chapter 7. Test hierarchies and organization
Chapter 8. The pillars of good unit tests
Part 4. Design and process
Chapter 9. Integrating unit testing into the organization
Chapter 10. Working with legacy code
Chapter 11. Design and testability
Appendix. Tools and frameworks
Windows PowerShell in Action, Third Edition
Functional Programming in C#: How to write better C# code
React Quickly: Painless web apps with React, JSX, Redux, and GraphQL
React Quickly: Painless web apps with React, JSX, Redux, and GraphQL

React Quickly is for anyone who wants to learn React.js fast. This hands-on book teaches you the concepts you need with lots of examples, tutorials, and a large main project that gets built throughout the book.

React Cheatsheet
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Praise for React Quickly
Foreword
Preface
Acknowledgments
About This Book
About the Author
About the Cover
Part 1. React foundation
Chapter 1. Meeting React
Chapter 2. Baby steps with React
Chapter 3. Introduction to JSX
Chapter 4. Making React interactive with states
Chapter 5. React component lifecycle events
Chapter 6. Handling events in React
Chapter 7. Working with forms in React
Chapter 8. Scaling React components
Chapter 9. Project: Menu component
Chapter 10. Project: Tooltip component
Chapter 11. Project: Timer component
Part 2. React architecture
Chapter 12. The Webpack build tool
Chapter 13. React routing
Chapter 14. Working with data using Redux
Chapter 15. Working with data using GraphQL
Chapter 16. Unit testing React with Jest
Chapter 17. React on Node and Universal JavaScript
Chapter 18. Project: Building a bookstore with React Router
Chapter 19. Project: Checking passwords with Jest
Chapter 20. Project: Implementing autocomplete with Jest, Express, and MongoDB
Appendix A. Installing applications used in this book
Appendix B. React cheatsheet
Appendix C. Express.js cheatsheet
Appendix D. MongoDB and Mongoose cheatsheet
Appendix E. ES6 for success
Learn Amazon Web Services in a Month of Lunches
Learn Amazon Web Services in a Month of Lunches

Learn Amazon Web Services in a Month of Lunches guides you through the process of building a robust and secure web application using the core AWS services you really need to know. You'll be amazed by how much you can accomplish with AWS!

Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About This Book
Chapter 1. Before you begin
Part 1. The core AWS tools
Chapter 2. The 10-minute EC2 web server
Chapter 3. Provisioning a more robust EC2 website
Chapter 4. Databases on AWS
Chapter 5. DNS: what’s in a name?
Chapter 6. S3: cheap, fast file storage
Chapter 7. S3: cheap, fast system backups
Chapter 8. AWS security: working with IAM users, groups, and roles
Chapter 9. Managing growth
Chapter 10. Pushing back against the chaos: using resource tags
Chapter 11. CloudWatch: monitoring AWS resources for fun and profit
Chapter 12. Another way to play: the command-line interface
Part 2. The AWS power user: optimizing your infrastructure
Chapter 13. Keeping ahead of user demand
Chapter 14. High availability: working with AWS networking tools
Chapter 15. High availability: load balancing
Chapter 16. High availability: auto scaling
Chapter 17. High availability: content-delivery networks
Part 3. Food for thought: what else can AWS do for you?
Chapter 18. Building hybrid infrastructure
Chapter 19. Cloud automation: working with Elastic Beanstalk, Docker, and Lambda
Chapter 20. Everything else (nearly)
Chapter 21. Never the end
Appendix. Connecting to your EC2 instance
Appendix
Appendix
Node.js in Action, Second Edition
R in Action, Second Edition: Data analysis and graphics with R
R in Action, Second Edition: Data analysis and graphics with R

GET MORE WITH MANNING

An eBook copy of the previous edition, R in Action (First Edition), is included at no additional cost. It will be automatically added to your Manning account within 24 hours of purchase.


R in Action, Second Edition presents both the R language and the examples that make it so useful for business developers. Focusing on practical solutions, the book offers a crash course in statistics and covers elegant methods for dealing with messy and incomplete data that are difficult to analyze using traditional methods. You'll also master R's extensive graphical capabilities for exploring and presenting data visually. And this expanded second edition includes new chapters on time series analysis, cluster analysis, and classification methodologies, including decision trees, random forests, and support vector machines.

Afterword Into the rabbit hole
References
Bonus Chapter 23. Advanced graphics with the lattice package
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Praise for the First Edition
Preface
Acknowledgments
About this Book
About the Cover Illustration
Part 1. Getting started
Chapter 1. Introduction to R
Chapter 2. Creating a dataset
Chapter 3. Getting started with graphs
Chapter 4. Basic data management
Chapter 5. Advanced data management
Part 2. Basic methods
Chapter 6. Basic graphs
Chapter 7. Basic statistics
Part 3. Intermediate methods
Chapter 8. Regression
Chapter 9. Analysis of variance
Chapter 10. Power analysis
Chapter 11. Intermediate graphs
Chapter 12. Resampling statistics and bootstrapping
Part 4. Advanced methods
Chapter 13. Generalized linear models
Chapter 14. Principal components and factor analysis
Chapter 15. Time series
Chapter 16. Cluster analysis
Chapter 17. Classification
Chapter 18. Advanced methods for missing data
Part 5. Expanding your skills
Chapter 19. Advanced graphics with ggplot2
Chapter 20. Advanced programming
Chapter 21. Creating a package
Chapter 22. Creating dynamic reports
Appendix A. Graphical user interfaces
Appendix B. Customizing the startup environment
Appendix C. Exporting data from R
Appendix D. Matrix algebra in R
Appendix E. Packages used in this book
Appendix F. Working with large datasets
Appendix G. Updating an R installation
RxJS in Action
Exploring Microservices
Exploring Microservices

In the last few years, microservice-based architecture has become one of the hottest innovations in software and web development. By breaking down your applications into smaller microservices that work together, you can experience a more efficient workflow, enable easier communication between team members, and create a robust, scalable application that is easier to modify and that can handle points of failure without causing the whole app to collapse on itself.

Exploring Microservices is a collection of hand-picked chapters that introduce the concept of microservices, detail what it means to build a microservice-structured application, and provide insights you need to start building your own. Christian Horsdal Gammelgaard, author of Microservices in .NET Core, has selected hands-on topics to show you where to begin in the world of microservices. You'll get an overview of microservices and how they collaborate through commands, queries, and events, and then you'll see what it takes to build your first Akka.NET application made with continuous delivery and microservices in mind. Other chapters delve into deployment and working with Docker containers, so you'll always be prepared for the best launch possible. Plus, you'll get a sample of some other Manning books you may want to add to your library.

introduction
promo
Copyright 2018 Manning Publications
about
brief contents
Part 1. Microservice Collaboration
Chapter 1. Microservice collaboration
Part 2. Your First Akka.Net Application
Chapter 2. Your First Akka.Net Application
Part 3. Deployment
Chapter 3. Deployment
Part 4. Running Software in Containers
Chapter 4. Running software in containers
The Quick Python Book
Nim in Action
Express in Action: Writing, building, and testing Node.js applications
Express in Action: Writing, building, and testing Node.js applications

Express in Action teaches you how to build web applications using Node and Express. It starts by introducing Node's powerful traits and shows you how they map to the features of Express. You'll explore key development techniques, meet the rich ecosystem of companion tools and libraries, and get a glimpse into its inner workings. By the end of the book, you'll be able to use Express to build a Node app and know how to test it, hook it up to a database, and automate the dev process.

Copyright
Table of Contents
Preface
Acknowledgments
About this Book
About the Cover Illustration
Part 1. Intro
Chapter 1. What is Express?
Chapter 2. The basics of Node.js
Chapter 3. Foundations of Express
Part 2. Core
Chapter 4. Middleware
Chapter 5. Routing
Chapter 6. Building APIs
Chapter 7. Views and templates: Pug and EJS
Part 3. Express in Context
Chapter 8. Persisting your data with MongoDB
Chapter 9. Testing Express applications
Chapter 10. Security
Chapter 11. Deployment: assets and Heroku
Chapter 12. Best practices
Appendix. Other helpful modules
Index
List of Figures
List of Listings
Exploring the Data JungleFinding, Preparing, and Using Real-World Data
Exploring the Data JungleFinding, Preparing, and Using Real-World Data

Some people like to believe that all data is ready to be used immediately. Not so! Data in the wild is hard to track and harder to understand, and the first job of data scientists to identify and prepare data so it can be used. To find your way through the data jungle successfully, you need the right perspective and guidance. (There's no point hacking at overgrowth with a spoon after all!) Identify and prepare your data well, and you'll be well set to create insight from chaos and discover important analytic patterns - to set your business on the right track.

Exploring the Data Jungle: Finding, Preparing, and Using Real-World Data is a collection of three hand-picked chapters introducing you to the often-overlooked art of putting unfamiliar data to good use. Brian Godsey, author of Think Like a Data Scientist, has selected these chapters to help you navigate data in the wild, identify and prepare raw data for analysis, modeling, machine learning, or visualization. As you explore the data jungle you'll discover real-world examples in Python, R, and other languages suitable for data science.

Introduction
Promo
Copyright 2017 Manning Publications
about
brief contents
Part 1. Data All Around Us: The Virtual Wilderness
Chapter 1. Data All Around Us: The Virtual Wilderness
Part 2. Exploring Data
Chapter 2. Exploring Data
Part 3. Real-world Data
Chapter 3. Real-world Data
NativeScript in Action MEAP V14
NativeScript in Action MEAP V14

Using JavaScript and CSS to write true native-quality mobile applications is an appealing, but elusive, goal. The NativeScript mobile framework provides a uniquely-powerful solution that simplifies the web-to- mobile divide without compromising features, performance, or design. With NativeScript, you write your apps in standard JavaScript and CSS. However, rather than translating JavaScript into lookalike elements, NativeScript directly calls the native platform components, so that your apps look exactly as iOS and Android intended. You can directly manipulate the native APIs with your JavaScript code, and it's a snap to write custom plug-ins to extend the NativeScript feature set.

NativeScript in Action teaches readers who know JavaScript and CSS how to create native iOS and Android apps using NativeScript. You'll begin learning how mobile applications differ from web applications, and discover how NativeScript bridges the gap. Then, by following progressively more complex and interesting examples, you'll develop apps in JavaScript that will run natively on your mobile platforms. Along the way, you'll learn everything you need to know about the iOS and Android SDKs to write beautiful native apps, master mobile dev best practices, and learn countless NativeScript tips and techniques that will make you instantly more productive.

Copyright 2017 Manning Publications
welcome
brief contents
1 Why NativeScript
2 Your first app
3 Anatomy of a NativeScript app
4 Pages and navigation
5 Understanding the basics of app layouts
6 Using advanced layouts
7 Styling NativeScript apps
8 Working with data
9 Native hardware
10 Creating professional UIs with themes
11 Refining user experience
12 Deploying an Android app
13 Preparing an iOS app for distribution
14 iOS security and building your app with Xcode
15 Creating a NativeScript App with Angular
16 Using Angular components and routing
17 Angular databinding and services
A Android emulator tips
B NativeScript CLI quick reference
C NativeScript conventions
D Creating custom UI controls
Oculus Rift in Action MEAP v11
Streaming Data: Understanding the real-time pipeline
Streaming Data: Understanding the real-time pipeline

Streaming Data is an idea-rich tutorial that teaches you to think about efficiently interacting with fast-flowing data. Through relevant examples and illustrated use cases, you'll explore designs for applications that read, analyze, share, and store streaming data. Along the way, you'll discover the roles of key technologies like Spark, Storm, Kafka, Flink, RabbitMQ, and more. This book offers the perfect balance between big-picture thinking and implementation details.

Copyright
Table of Contents
Preface
Acknowledgments
About this Book
Part 1. A new holistic approach
Chapter 1. Introducing streaming data
Chapter 2. Getting data from clients: data ingestion
Chapter 3. Transporting the data from collection tier: decoupling the data pipeline
Chapter 4. Analyzing streaming data
Chapter 5. Algorithms for data analysis
Chapter 6. Storing the analyzed or collected data
Chapter 7. Making the data available
Chapter 8. Consumer device capabilities and limitations accessing the data
Part 2. Taking it real world
Chapter 9. Analyzing Meetup RSVPs in real time
Appendix. The streaming data architectural blueprint
Index
List of Figures
List of Tables
List of Listings
Spring Microservices in Action
Effective Business Process Management with JBoss BPM MEAP V07
Effective Business Process Management with JBoss BPM MEAP V07

Effective Business Process Management with JBoss BPM is an understandable and easy-to-follow guide to mastering JBoss BPM. You'll begin with an introduction to BPM concepts and a walk through of the JBoss BPM Suite, followed by hands-on steps for setting up JBoss BPM tools to get started on your first project. You'll move on to practical and important topics like data modeling, business rules and processes, form design, and testing. After you've mastered the nuts and bolts, you'll learn advanced topics like business activity modeling, Rest API, demo collection, and expert tips and tricks. After reading this book, you'll know how to leverage JBoss BPM to tackle your organization's challenges with process solutions that keep your business agile and able to execute on the goals that matter to you most.

Copyright 2017 Manning Publications
welcome
brief contents
Part 1: Getting started
1 What’s in a process
2 Tour a real project
3 Processing first steps
Part 2: The Foundations
4 Modeling process data
5 Starting with business rules
6 Creating complex business rules
Part 3: Process and more
7 Designing business processes
CoreOS in Action: Running Applications on Container Linux
Cross-Platform Desktop Applications: Using Node, Electron, and NW.js
Learn Cisco Network Administration in a Month of Lunches
Learn Cisco Network Administration in a Month of Lunches

Learn Cisco Network Administration in a Month of Lunches is a tutorial designed for beginners who want to learn how to administer Cisco switches and routers. Just set aside one hour a day (lunchtime would be perfect) for a month, and you'll start learning practical Cisco Network administration skills faster than you ever thought possible.

Learn Cisco Network Administration in a Month of Lunches
Common show commands
Index
List of Figures
List of Tables
Copyright
Table of Contents
Preface
Acknowledgments
About this Book
About the Author
Chapter 1. Before you begin
Chapter 2. What is a Cisco network?
Chapter 3. A crash course on Cisco’s Internetwork Operating System
Chapter 4. Managing switch ports
Chapter 5. Securing ports by using the Port Security feature
Chapter 6. Managing virtual LANs (VLANs)
Chapter 7. Breaking the VLAN barrier by using switched virtual interfaces
Chapter 8. IP address assignment by using Dynamic Host Configuration Protocol
Chapter 9. Securing the network by using IP access control lists
Chapter 10. Connecting switches using trunk links
Chapter 11. Automatically configuring VLANs using the VLAN Trunking Protocol
Chapter 12. Protecting against bridging loops by using the Spanning Tree Protocol
Chapter 13. Optimizing network performance by using port channels
Chapter 14. Making the network scalable by connecting routers and switches together
Chapter 15. Manually directing traffic using the IP routing table
Chapter 16. A dynamic routing protocols crash course
Chapter 17. Tracking down devices
Chapter 18. Securing Cisco devices
Chapter 19. Facilitating troubleshooting using logging and debugging
Chapter 20. Recovering from disaster
Chapter 21. Performance and health checklist
Chapter 22. Next steps
Agile Development for Serverless Platforms
Agile Development for Serverless Platforms

You need more than great dev tools to release great software; you need an efficient pipeline that takes advantage of modern Agile development practices. Serverless platforms like AWS offer the basic building blocks you need to run code, store data, or process streaming information so you can focus on the features you want to provide, not get bogged down with the infrastructure. Combined with an agile process, serverless architectures help create a quick feedback loop between developers, end users, and businesses, allowing for the quick prototyping and easy production roll-out you need to innovate and react on the fly.

Agile Development for Serverless Platforms helps you start thinking about how to apply Agile practices in fully serverless architectures. This book brings together excerpts from four Manning books selected by Danilo Poccia, the author of AWS Lambda in Action. These chapters are a fantastic way to lay the foundations for understanding the world of agile development on serverless architecture. With concepts from working with APIs, serverless development patterns, designing an authentication system, and more, you'll see just how to tackle this new way to develop efficiently and effectively.

introduction
Copyright 2018 Manning Publications
about
brief contents
Part 1. Are You Ready for Agile?
Chapter 1. Are you ready for agile?
Part 2. Working with Web APIs
Chapter 2. Working with web APIs
Part 3. Architectures and Patterns
Chapter 3. Architectures and patterns
Part 4. Designing an Authentication Service
Chapter 4. Designing an authentication service
Part 5. Automating Deployment: CloudFormation, Elastic Beanstalk, and OpsWorks
Chapter 5. Automating deployment: CloudFormation, Elastic Beanstalk, and OpsWorks
Type-Driven Development with Idris
Type-Driven Development with Idris

Type-Driven Development with Idris, written by the creator of Idris, teaches you how to improve the performance and accuracy of your programs by taking advantage of a state-of-the-art type system. This book teaches you with Idris, a language designed to support type-driven development.

Type-Driven Development with Idris
Index
List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About this Book
About the Author
About the Cover Illustration
Part 1. Introduction
Chapter 1. Overview
Chapter 2. Getting started with Idris
Part 2. Core Idris
Chapter 3. Interactive development with types
Chapter 4. User-defined data types
Chapter 5. Interactive programs: input and output processing
Chapter 6. Programming with first-class types
Chapter 7. Interfaces: using constrained generic types
Chapter 8. Equality: expressing relationships between data
Chapter 9. Predicates: expressing assumptions and contracts in types
Chapter 10. Views: extending pattern matching
Part 3. Idris and the real world
Chapter 11. Streams and processes: working with infinite data
Chapter 12. Writing programs with state
Chapter 13. State machines: verifying protocols in types
Chapter 14. Dependent state machines: handling feedback and errors
Chapter 15. Type-safe concurrent programming
Appendix A. Installing Idris and editor modes
Appendix B. Interactive editing commands
Appendix C. REPL commands
Appendix D. Further reading
Appendix E.
Appendix F.
Reactive Design Patterns
Understanding API Security
Understanding API Security

Gone are the days when it was acceptable for a piece of software to live in its own little silo, disconnected from the outside world. Today, services are expected to be available for programming, mixing, and building into new applications. The web-based Application Programming Interface, or API, is how services make themselves available in this dynamic world. By exposing an API, a service can find new life and utility far beyond what its core functionality was designed to be. But these APIs need to be secured and protected in order to be truly useful. An API that's simply left open to everyone, with no security controls, cannot be used to protect personalized or sensitive information, which severely limits its usefulness.

The OAuth delegation and authorization protocol is one of the most popular standards for API security today. Understanding API Security is a selection of chapters from several Manning books that give you some context for how API security works in the real world by showing how APIs are put together and how the OAuth protocol can be used to protect them.

Introduction
Promo
Copyright 2016 Manning Publications
about
brief contents
Part 1. The OAuth Dance
Chapter 1. The OAuth Dance
Part 2. Working with Web APIs
Chapter 2. Working with Web APIs
Part 3. Communicating with the Server
Chapter 3. Communicating with the Server
Part 4. Sharing and Securing Web Things
Chapter 4. Share: Securing and sharing web Things
Part 5. What Is Amazon Web Services?
Chapter 5. What Is Amazon Web Services?
Part 6. Implementing Security as a Service
Chapter 6. Implementing Security as a Service
Exploring Cloud Computing
Exploring Cloud Computing

Cloud Computing is enabling many trends in IT today: microservices, pay-as-you-go pricing, and serverless architectures, to name three. The biggest player in the market's Amazon, who offers the most mature cloud systems through their Amazon Web Services (AWS). Other companies are gaining traction as well: Google invests into their Google Cloud Platform, and Microsoft entered the game with Azure.

Exploring Cloud Computing is a collection of hand-picked chapters introduction to the two most popular cloud providers, Amazon and Google, and insights to help you get started. Michael and Andreas Wittig, authors of Amazon Web Services in Action, selected hands-on topics to show you where to begin with cloud computing. You'll get an overview of what cloud services have to offer. Then you'll discover Google Cloud Platform. Other chapters explore AWS, serverless computing, and AWS Lambda that lets you run code in the cloud without managing the underlying operating systems and execution platforms. You upload your code and it's executed in the cloud and pay only for the time the function executes. Plus, you'll get a sample of some other Manning books you may want to add to your library.

Introduction
The Cloud at Your Service
What is cloud computing?
Amazon Web Services in Action
What is Amazon Web Services?
Google Cloud Platform in Action
Trying it out: Deploying Wordpress on Google Cloud
Serverless Architectures on AWS
Going serverless
AWS Lambda in Action
Running functions in the cloud
Books
Copyright 2017 Manning Publications
about
brief contents
Kotlin in Action
Microservices in .NET Core: with examples in Nancy
Learn Windows PowerShell in a Month of Lunches, Third Edition
Learn Windows PowerShell in a Month of Lunches, Third Edition

GET MORE WITH MANNING

An eBook copy of the previous edition, Learn Windows PowerShell in a Month of Lunches, Second Edition, is included at no additional cost. It will be automatically added to your Manning Bookshelf within 24 hours of purchase.


Learn Windows PowerShell in a Month of Lunches, Third Edition is an innovative tutorial designed for busy IT professionals. This updated edition covers PowerShell features that run on Windows 7, Windows Server 2008 R2 and later, PowerShell v3 and later, and includes v5 features like PowerShellGet.

List of Figures
List of Tables
List of Listings
Copyright
Table of Contents
Preface
Acknowledgments
About this Book
About the Authors
Chapter 1. Before you begin
Chapter 2. Meet PowerShell
Chapter 3. Using the help system
Chapter 4. Running commands
Chapter 5. Working with providers
Chapter 6. The pipeline: connecting commands
Chapter 7. Adding commands
Chapter 8. Objects: data by another name
Chapter 9. The pipeline, deeper
Chapter 10. Formatting—and why it’s done on the right
Chapter 11. Filtering and comparisons
Chapter 12. A practical interlude
Chapter 13. Remote control: one-to-one, and one-to-many
Chapter 14. Using Windows Management Instrumentation and CIM
Chapter 15. Multitasking with background jobs
Chapter 16. Working with many objects, one at a time
Chapter 17. Security alert!
Chapter 18. Variables: a place to store your stuff
Chapter 19. Input and output
Chapter 20. Sessions: remote control with less work
Chapter 21. You call this scripting?
Chapter 22. Improving your parameterized script
Chapter 23. Advanced remoting configuration
Chapter 24. Using regular expressions to parse text files
Chapter 25. Additional random tips, tricks, and techniques
Chapter 26. Using someone else’s script
Chapter 27. Never the end
Chapter 28. PowerShell cheat sheet
Appendix. appendix: Review labs
hapi.js in Action
Angular 2 Development with TypeScript
AWS Lambda in Action: Event-driven serverless applications
Exploring PowerShell Automation
Exploring PowerShell Automation

During the decade that PowerShell has been around, a significant and increasing percentage of Windows administrators have discovered that PowerShell allows them to be more productive. They've realized that PowerShell enables them to perform administrative tasks across a wide range of technologies from Microsoft and third party vendors. The time it takes to develop PowerShell scripts is paid back multiple times by automating repetitive tasks and reducing errors with repeatable, reliable processes.

Exploring PowerShell Automation is a selection of chapters that gives you an overview of using PowerShell to administer your environment. Richard Siddaway has been involved in the production of all of these chapters either as an author or an editor, and has chosen them specifically to represent the breadth of possibilities for administering your systems through PowerShell. The first two chapters provide an overview of PowerShell and PowerShell remoting. The remaining three chapters give you examples of using PowerShell to administer SQL Server, IIS and Active Directory; three components that you'll find in practically any Windows environment.

Introduction
Promo
Copyright 2016 Manning Publications
about
brief contents
Part 1. Introduction to PowerShell
Chapter 1. Welcome to PowerShell
Part 2. PowerShell Remoting
Chapter 2. PowerShell Remoting
Part 3. PowerShell and SQL Server
Chapter 3. PowerShell and the SQL Server provider
Part 4. IIS Administration
Chapter 4. Provisioning IIS web servers and sites with PowerShell
Part 5. AD Administration
Chapter 5. User accounts
Spark in Action
The Little Elixir & OTP Guidebook
The Little Elixir & OTP Guidebook

The Little Elixir & OTP Guidebook gets you started programming applications with Elixir and OTP. You begin with a quick overview of the Elixir language syntax, along with just enough functional programming to use it effectively. Then, you'll dive straight into OTP and learn how it helps you build scalable, fault-tolerant and distributed applications through several fun examples.

Index
List of Figures