liveBook · Manning

Signal

A signal is an observable value, event, or pattern that conveys information about a condition, state, or phenomenon.

How 10 Manning books explain it

Outlier Detection in Python

Signal is variation in data regarded as meaningful or relevant within a particular context.

How it is used
Distinguishes contextually meaningful variation from noise when deciding which unusual records deserve investigation.
How deep it goes
Explains how engineered features expose candidate signal, but provides no standalone mathematical definition or universal signal test.
Examples
Uses missing-value indicators, baseball ratios, account posting summaries, and temporal features to reveal different kinds of variation.
What you can do after
Evaluate/understand it by choosing contextual features and checking whether flagged differences are informative rather than chance outliers.

Read how Outlier Detection in Python explains signal →

Graph Neural Networks in Action

Information associated with an individual graph node, including attributes that can contribute to its learned representation.

How it is used
Uses node-specific information as input to GNN embeddings and as tabular features for non-graph baselines.
How deep it goes
Works through feature tensors, message passing, and distribution checks, but defers the review features’ detailed derivations.
Examples
Compares random and Node2Vec features in classification, and inspects normalized behavioral and textual features in a review graph.
What you can do after
Apply it via PyTorch Geometric by supplying node features with graph edges and inspecting feature distributions before training.

Read how Graph Neural Networks in Action explains signal →

Logs and Telemetry

A signal is an observability event category encompassing logs, metrics, and traces.

How it is used
Groups logs, metrics, and traces for capture and distribution in an event-driven observability pipeline.
How deep it goes
Defines each signal and explains trace spans, nesting, baggage, and distributed relationships without detailing signal schemas.
Examples
Configures three OpenTelemetry inputs for logs, raw traces, and metrics, routing all matched events to standard output.
What you can do after
Operate/configure it through separate OpenTelemetry inputs that receive logs, traces, and metrics on designated ports.

Read how Logs and Telemetry explains signal →

Pro Angular 16

An Angular signal is a reactive value abstraction that represents data and tracks relationships so dependent values can update efficiently when the data changes.

How it is used
Describes relationships between application state and derived values so Angular can update affected HTML efficiently.
How deep it goes
Works through creation, reads, mutation, computed values, effects, and read-only sharing; defers deeper explanation of signal behavior.
Examples
Uses product-category filtering, a computed cart summary, repository state, and a route-driven product count.
What you can do after
Build it from scratch: create writable and computed signals, expose read-only state, and connect signal values to a template.

Read how Pro Angular 16 explains signal →

Financial AI in Practice

A signal is an output from an analytical model that conveys information for a subsequent financial decision or action.

How it is used
Positions model outputs between financial data analysis and governed decisions in trading, credit, fraud, and application workflows.
How deep it goes
Works through out-of-sample trading evaluation and structured news extraction, while deferring execution frictions before claims of trading profitability.
Examples
Uses ETF market-direction predictions and a uranium-news JSON record with sentiment, supply-risk, and policy-tone scores.
What you can do after
Build it from scratch using RAG-backed retrieval and structured JSON to produce auditable news features for a hybrid strategy.

Read how Financial AI in Practice explains signal →

Functional Design and Architecture: Examples in Haskell

A signal is a time-varying value in a functional reactive system whose changes can drive dependent computations.

How it is used
Frames time-dependent application state whose changes trigger reactions in functional reactive programming.
How deep it goes
Defines signals through time variation, dependency updates, event mapping, and bound actions without detailing an implementation.
Examples
Uses GUIs and complex business logic as applications for reactive networks of signals and actions.
What you can do after
Evaluate/understand signals as time-dependent values that automatically propagate changes to dependent computations.

Read how Functional Design and Architecture: Examples in Haskell explains signal →

Cloud Observability in Action

A signal is information about a system that can be observed externally.

How it is used
Uses externally observable information to understand systems and make operational decisions.
How deep it goes
Defines signal types, ownership, selection criteria, retention, baselines, labeling, and cost trade-offs without detailing signal implementations.
Examples
Demonstrates logs, metrics, and traces with a Go echo service, Grafana, Prometheus, Jaeger, curl, and load testing.
What you can do after
Evaluate and select signals by task relevance, actionability, retention needs, baseline value, and operational cost.

Read how Cloud Observability in Action explains signal →

Collaborative Software Design: How to facilitate domain modeling decisions

A signal is an observable piece of information, activity, behavior, or event that indicates a change affecting a session, outcome, or result.

How it is used
Guides facilitators in recognizing when a group should shift between opposing poles during collaborative modeling.
How deep it goes
Defines strong and weak signals, explains pattern recognition, and links observations to actions without prescribing universal thresholds.
Examples
Uses watch-checking, confused participants, software architecture decisions, dissatisfaction, jokes, and possible team departure as signal examples.
What you can do after
Apply signals to observe group dynamics, detect emerging patterns, and choose actions that restore movement between polarity poles.

Read how Collaborative Software Design: How to facilitate domain modeling decisions explains signal →

Optimization Algorithms: AI techniques for design, planning, and control problems

A node feature is a value or vector associated with a graph node that describes its attributes for computation or learning.

How it is used
Defines graph-learning problems through node features and an adjacency matrix before embedding and solution prediction.
How deep it goes
Places node features before GNN or GCN embedding but does not detail how to construct or encode them.
Examples
Uses TSP as the graph-learning task and names VRP, SAT, MaxCut, and MIS as related optimization problems.
What you can do after
Understand how node features enter a graph-learning pipeline for predicting combinatorial optimization solutions.

Read how Optimization Algorithms: AI techniques for design, planning, and control problems explains signal →

Delivering Machine Learning Projects: From design to deployment

A feature is an input variable or measurable attribute supplied to a machine learning model.

How it is used
Turns assembled raw data into consistent, informative model inputs before modeling.
How deep it goes
Explains preprocessing risks and feature representations, but stops short of detailed algorithms or implementation steps.
Examples
Uses year-end dates, directional values, and temperature plotted by day of year or distance from midsummer.
What you can do after
Apply feature engineering by planning and reviewing transformations, implementing a pipeline, and adding data augmentation.

Read how Delivering Machine Learning Projects: From design to deployment explains signal →

Related concepts

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.