Topics
- Core
- Core Application Framework
- Choosing an Application Design
- Writing Small Applications with Functions
- Building Event-Driven Applications
- Building Procedural Applications
- Building Command-Style Applications
- Building an Application from Parts
- Designing Application Parts
- Running Application Parts Independently
- Creating Services and Foreground Daemons
- Adding Git Version Information to Your App
- Memory
- Working with Bits and Bytes
- Reading a Stream of Bits
- Working with Predefined Byte-Spans
- Working with Fixed Byte Arrays
- Working with Byte Blocks
- Byte Integer Formats Explained
- Using Byte Buffers
- Using Byte Ring Buffers
- Reading and Parsing Byte Streams
- Writing Byte Streams
- Encoding Text in Binary Byte Streams
- Compressing Data
- Designing Custom Copy-on-Write Containers
- Marking Unsafe Memory Access in Code
- Compiled Resources
- Security Topics
- Cryptology
- Text
- Text in Erbsland Core
- Using Strings as Everyday Values
- Understanding String Attributes
- Transforming Read-only Strings
- Editing One Working Value in Place
- Managing StringEditor Storage
- Finding Text Positions
- Slicing and Splitting Strings
- Accessing Characters and Writing Parsers
- Converting Text and Scalar Values
- Comparing Whole and Partial Text
- Normalizing Unicode Strings
- Working with Character Sets
- Building Strings Efficiently
- Formatting Structured Text
- Describing Values with Named Format Specifications
- Maintaining Compact Compatibility Specifications
- Recognizing Small Text Patterns
- Converting Strings and Encoded Data
- Encoding Internationalized Names
- Using Strings
- String Attributes
- Transforming Strings
- Editing Strings in Place
- Managing StringEditor Storage
- Finding Text Positions
- Slicing and Splitting Strings
- Character Access and Parsing of Strings
- Start with the Way Your Algorithm Reads Text
- Understand the Coordinate Systems
- Keep Parser State in
StringCharReader - Walk Through Every Decoded Character
- Read Sequentially Without Parser State
- Use Indexed Access When a Position Already Matters
- Why UTF-32 Changes the Cost of Indexed Access
- Choose the Simplest Access Pattern That Fits
- Converting Text and Scalar Values
- Comparing Whole and Partial Strings
- Normalizing Unicode Strings
- Working with Character Sets
- Know What One Set Element Represents
- Validate the Encoding Before the Character Policy
- Build Expensive Policies Once and Reuse Them
- Compose Larger Policies from Smaller Sets
- Ask Whether Text Satisfies a Character Policy
- Trim a Policy from the Edges
- Remove Unwanted Characters Throughout the Text
- Transform the Characters Selected by a Set
- Building Strings
- Formatting Text Patterns
- Format Specifications
- Compatibility Format Specifications
- Recognizing Text Patterns
- Converting Strings
- Encoding Internationalized Names
- Text in Erbsland Core
- Command Line Options System
- Exceptions, Errors and Diagnostics
- Filesystem Access and Manipulation
- Random and Secrets
- Regular Expressions
- Event System
- Logging
- Logging Overview
- Choosing a Logging Setup
- Writing Log Messages
- Configuring Logging in Code
- Formatting Log Lines
- Place the Line Format in the Logging Configuration
- Arrange Fields With a Pattern
- Choose UTC or Local Timestamps
- Choose Compact or Descriptive Level Names
- Show the Useful Part of a Stream Name
- Bound Left-Truncated Stream Names
- Keep Multiline Messages or Only Their First Line
- Limit the Message by Character Count
- Limit the Complete Rendered Line
- Choose a Clear Truncation Mark
- Keep Producer Byte Limits Separate
- Configuring Log Manager Limits
- Install the Options With the Complete Configuration
- Bound the Number of Waiting Entries
- Bound the Storage Retained by the Queue
- Protect Entry Slots for Warnings and Errors
- Protect Queue Storage for Warnings and Errors
- Bound Each Message Before It Reaches the Queue
- Give the Worker Time to Finish During Shutdown
- Read Statistics as a Point-in-Time Snapshot
- Using Trace Sections
- Understand What a Trace Section Controls
- Design Sections Around Investigations
- Attach a Stable Section When Creating the Stream
- Enable the Section and a Matching Destination
- Guard Preparation That Exists Only for Tracing
- Keep the Trace Policy Stable After Startup
- Understand What Runtime Replacement Would Do
- Using Log Writers
- Understand the Writer’s Place in the Log System
- Add a Writer to the Configuration
- Route the Right Entries to Each Writer
- Choose a Writer for Each Audience
- Show Immediate Feedback on the Console
- Keep Durable Operational History in a File
- Send Service Events to a Syslog Collector
- Recent Errors on Application Exit
- Introduce a Custom Destination Only When Necessary
- Writing Logs to the Console
- Writing Logs to Files
- Add a File Writer to a Log Configuration
- Create the Options With the Active Path
- Choose Append or Overwrite for the First Open
- Select When the File Rotates
- Set the Byte Threshold for Size Rotation
- Limit the Number of Retained Archives
- Cooperate With External File Replacement
- Understand Failures and Recovery
- Sending Logs to Syslog
- Add a Syslog Writer to the Configuration
- Create and Pass the Options Object
- Choose UDP, TCP, or TLS Transport
- Select the Collector Endpoint
- Choose the RFC Facility
- Identify the Producing Host
- Name the Application
- Identify the Process Instance
- Classify the Message Family
- Understand the Resulting RFC Header
- Select the TLS Configuration Label
- Bound Pending Network Data
- Plan for Collector and Network Failures
- Loading Logging Configuration
- Writing an ELCL Logging Configuration
- Start With One Useful Destination
- Make Operational Choices Explicit
- Shape Every Log Line
- Give the Manager a Clear Resource Budget
- Enable the Trace Detail You Need
- Connect Entries to Their Destinations
- Keep Terminal Output Comfortable to Read
- Preserve an Operational History in Files
- Send Service Logs to a Syslog Collector
- Streams
- Working with Streams
- Creating Streams and Managing Ownership
- Byte Input and Output
- Text Input, Output, and Encoding
- Choose the Text Operation That Matches the Task
- Process Unicode Without Splitting Encoded Characters
- Read Lines Without Losing Their Structure
- Produce Text as Complete Atomic Requests
- Capture Reusable Text Output in Memory
- Match the Encoding and BOM Policy to the Format
- Choose Deliberately How Malformed Text Is Handled
- Standard Streams
- Overview: Follow the Stable Proxy Model
- Choose Concise Helpers for Everyday Output
- Keep Results and Diagnostics on Separate Channels
- Make Standard Input Deterministic with Scoped Redirection
- Protect Native Standard-Input Buffers
- Capture Output Without Changing the Producer
- Compose Redirections in Strictly Nested Scopes
- Treat Redirects as Shared Process State
- Readiness and Timeouts
- Buffering and Back Pressure
- Stream Lifecycle
- Temporary Streams
- Positioning Streams
- Stream Errors and Diagnostics
- Coroutine Streams
- Writing Custom Streams
- Network
- Color Terminal