liveBookmanning.com

What you will learn in The Art of Code

The surprising power of beauty in software development

by Sandrine Banas

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• functional, stateless philosophyA programming style that combines function-oriented composition with declarations of desired results rather than procedural commands.
• failureFailure is a program outcome in which an operation cannot complete its intended contract or produces an unsuccessful result.
• fallbackA fallback is an alternative behavior or result selected when the preferred operation is unavailable or unsuccessful.
• pure functionA pure function is a function that produces the same result for the same inputs without observable side effects or dependence on external mutable state.
• pipelineA pipeline is a composable sequence of data-processing stages in which intermediate operations define transformations and a terminal operation executes them.
• cognitive complexityCognitive complexity is a code-complexity metric that estimates the mental effort required to understand control flow, especially when flow-breaking structures and nesting are present.
• narrative codeNarrative code is a code genre that expresses computational logic through the clarity and structure of storytelling.
• carbon footprintA carbon footprint is the total amount of greenhouse gases produced by an activity, product, person, or system, usually expressed as carbon-dioxide equivalent.
• circuit breaker patternA circuit breaker is a fault-tolerance pattern that temporarily stops calls to an failing dependency after repeated failures and later permits limited recovery attempts.
• exceptionAn exception is a runtime event representing an abnormal condition that interrupts ordinary program execution and can be propagated or handled.
• domain-specific exceptionA domain-specific exception is an exception type representing a failure condition defined by an application's business domain.
• expressive powerThe degree to which a programming language enables ideas to be expressed clearly and concisely without unnecessary syntactic or logical manipulation.
• monitoringLogging is the recording of application events, errors, and contextual information for diagnosis, monitoring, and auditing.
• agent skillAn AI skill is a reusable prompt or instruction set that guides an AI system through a specific task.
• retryRetry is a failure-recovery technique that repeats an unsuccessful operation in the hope that a transient problem has cleared.
• streamingStreaming is a processing technique that handles data incrementally as it becomes available instead of retaining the entire result in memory.
• imperative programmingImperative style structures computation as explicit commands and control-flow statements that change or inspect state.
• pattern matchingPattern matching is a language mechanism that tests an object's structure and can extract its components when the structure matches.
• flawed error handlingFlawed error handling is an error-handling antipattern in which failure responses are incorrect, incomplete, or harmful to software behavior.
• Java recordA Java record is a concise Java class declaration for immutable data-oriented objects with automatically derived members.
• empty catch blockAn empty catch block is an exception handler whose body performs no operation or explanation when an exception is caught.
• exception chainingException chaining is the preservation of an underlying exception as the cause of a newly raised exception.
• user-defined exceptionA custom exception is an application-defined exception type whose name and structure represent a specific failure condition.
• cognitive loadCognitive load is the mental effort required to understand, navigate, or reason about information or code.
• sustainable softwareSustainable software is software designed and developed to minimize unnecessary computational, material, and environmental resource consumption.
• refactoringRefactoring is the restructuring of existing code to improve its design or clarity without changing its externally observable behavior.
• encapsulationEncapsulation is a design principle that restricts direct access to internal state and exposes controlled operations for maintaining object invariants.
• green coding patternA green design pattern is a high-level programming design pattern that reduces software-related environmental resource consumption through a general solution to a recurring sustainability problem.
• memory usageMemory footprint is the amount of system memory occupied by a program and its in-memory data during execution.
• cachingA cache is a storage layer that retains recently or frequently used results for faster retrieval and reduced dependency load.
• root causeA root cause is the underlying condition or defect that initiates or substantially contributes to an observed failure.
• narrative levelA narrative level is a hierarchical unit for organizing code or a story from individual actions to an overall sequence of chapters.
• composite keyA composite key is a key formed from multiple values that together identify an item or entry.
• extract method refactoringMethod extraction is a refactoring technique that moves a coherent subset of operations into a separately named method.
• clarity of intentClarity of intent is the degree to which code makes its purpose and expected behavior readily apparent.
• contractA public API is an externally accessible software interface whose operations and behavior are exposed for use by other systems or clients.
• performanceA monitoring metric is a measured numeric signal describing the state, activity, or performance of a running system.
• energy consumptionEnergy consumption is the amount of electrical or other energy required to operate software and its supporting computing systems.
• data-oriented programmingA programming paradigm that models data as simple immutable structures and expresses behavior through standalone functions operating on that data.
• declarative programmingDeclarative style expresses the desired result or transformation while minimizing explicit control-flow instructions for how to produce it.
• code readabilityReadability is the ease with which source code can be understood by its readers.
• problem solvingProblem-solving is the process of analyzing a problem and devising an effective solution.
• lean communicationLean communication is a software pattern that minimizes unnecessary data transmitted between system components.
• constraintA limitation that restricts the available choices or implementation of a software solution.
• stack traceA stack dump is a diagnostic snapshot showing the call stacks of threads or goroutines in a running or failed process.
• functionA function is a callable program construct that accepts inputs and produces a result or effect according to its definition.
• creativityCreative thinking is the capacity to form novel connections among knowledge and generate innovative solutions.
• sustainabilitySustainability in code is the quality of supporting its continued maintenance and evolution without imposing excessive long-term cost.
• missing valueIn Java, null is the literal value denoting that a reference does not refer to an object.
• AI agentAn AI agent is a software system that performs tasks with some autonomy, typically by reasoning over inputs and invoking available tools or actions.
• separation of concernsSeparation of concerns is a design technique that divides software into parts responsible for distinct concerns so that each can change more independently.
• lambdaA lambda is an anonymous function value that can be passed, stored, returned, or invoked as data.
• efficiencyCode efficiency is the degree to which code performs its required work while minimizing execution time and computing-resource consumption.
• data modelA data model is a representation of the information, structure, relationships, and constraints that a software system manipulates.
• parameter objectThe parameter object pattern groups related method parameters into a single object that represents their combined input.
• record deconstructionRecord deconstruction is a pattern-matching feature that extracts a record's components directly within a pattern.
• complexitySoftware complexity is the degree of difficulty involved in understanding, changing, and maintaining a software system.
• abstractionAbstraction is the representation of essential behavior or properties while concealing implementation details that are not necessary to a given user or level of reasoning.
• compositionFunction composition is the construction of a function by chaining functions so that one function's output becomes the next function's input.
• durabilityDurability in code is the capacity to remain understandable, useful, and resilient as the surrounding system changes over time.
• resilienceResilience is the ability of a software system to continue providing acceptable behavior during disruptions and recover from failures.
• testA test is an executable evaluation that checks software behavior against expected outcomes.
• functional frugalityFrugality is a design pattern that avoids unnecessary features, technologies, and complexity in favor of solutions that provide real value.
• cold explorationCold exploration is an investigative technique that reconstructs an unreproducible failure from residual evidence such as logs, metrics, and traces.
• hot explorationHot exploration is an investigative technique that follows a reproducible failure while it is occurring, from its first observable error toward its root cause.
• cyclomatic complexityCyclomatic complexity is a software metric that counts the independent execution paths through a program's control flow based on its decision points.
• filteringData filtering is the selection or removal of records according to specified validity, quality, or uniqueness criteria.
• intermediate operationAn intermediate operation is a pipeline operation that describes a further transformation and normally defers its execution until a terminal operation.
• terminal operationA terminal operation ends a pipeline, triggers its deferred processing, and produces or materializes a final result.
• memory efficiencyMemory efficiency is a software design pattern that limits retained data and releases unneeded resources to reduce an application's memory footprint.
• carbon-aware patternThe carbon-aware pattern is a green design pattern that schedules computation according to electricity carbon intensity and adjusts its location or scale accordingly.
• carbon intensityThe amount of carbon dioxide emissions associated with producing a unit of electricity in a particular region and time period.
• action-level methodAn action-level method is a narrowly scoped method that represents a low-level operation in a narrative code hierarchy.
• chapter-level methodA chapter-level method is a top-level method that organizes scene-level operations into the main flow of a larger behavior.
• narrative code skillThe Narrative Code skill is a reusable instruction set that guides an AI agent in restructuring existing code according to narrative-code rules.
• scene-level methodA scene-level method is a method that groups related action-level operations into a coherent higher-level operation.
• resource cleanupResource cleanup is the release or closure of acquired computing resources after an operation finishes or fails.
• rule-based organization patternA rule-based organization pattern structures a process around explicit rules that define classification, transformation, auditing, and reporting steps.
• cohesionHigh cohesion is a software-design condition in which a component's parts are closely related and focused on one responsibility.
• couplingCoupling is the degree of interaction or dependency between software components, modules, layers, or classes.
• single responsibility principleThe Single Responsibility Principle is an object-oriented design principle stating that a class should have only one reason to change.
• problem reproductionProblem reproduction is the act of reliably triggering an observed failure under known conditions so it can be observed and analyzed.
• heap dumpA heap dump is a snapshot of the objects and memory state of a managed runtime heap at a particular time.
• backward compatibilityBackward compatibility is the ability of a changed software component or interface to continue working with existing clients and dependent systems.
• embodied carbon emissionsEmbodied carbon emissions are the greenhouse-gas emissions generated by a device's manufacturing, transportation, and end-of-life processing rather than its use.
• lean storageLean storage is a software pattern that minimizes unnecessary retained data and storage consumption.
• higher-order functionA higher-order function is a function or method that accepts functions as arguments, returns a function, or both.
• credential stuffingCredential stuffing is an automated attack that tests leaked username and password pairs against other services.
• logging modulePython's logging module is a standard-library facility for creating, filtering, formatting, and routing log records.
• mapped diagnostic contextMapped Diagnostic Context is a per-execution logging context that automatically associates key-value information with log records.
• password sprayingPassword spraying is a brute-force attack that tries a small set of commonly used passwords across many accounts.
• severityA log severity level classifies the importance or urgency of a log record for filtering and routing.
• standard outputConsole output is text written to an interactive terminal or standard output and displayed directly to a user or developer.
• storytellingStorytelling in code is the quality of arranging operations so that the program's intent reads as a coherent narrative.
• actionAn action is a lowest-level narrative-code unit representing a small, individual operation or event.
• chapterA chapter is a high-level narrative-code unit that coordinates multiple scenes around a coherent larger goal.
• Manim sceneA scene is a self-contained narrative-code unit that groups several actions into a focused step with a single outcome.
• batchingBatching is the technique of dividing work into groups that are processed as units rather than all at once.
• bindingA variable is a named storage location or binding whose associated value can be read or changed during program execution.
• element nestingNesting is the hierarchical placement of one control-flow or code structure inside another structure.
• flow-breaking structureA flow-breaking structure is a control-flow construct that interrupts straightforward sequential execution and requires reasoning about alternate execution paths.
• builder patternThe builder pattern separates the construction of a complex object from its representation through a dedicated stepwise construction interface.
• enhanced switchAn enhanced switch is a Java switch construct that supports modern branch selection features including pattern-based cases and guards.
• simplicitySimplicity is the quality of expressing software behavior with minimal unnecessary complexity while preserving its essential structure.
• GraphQLA query language and runtime for APIs that lets clients specify the fields they need.
• local-first approachA software design pattern that prioritizes local operation and synchronizes locally recorded data with remote services when possible.
• payloadThe application data carried by a network request or response apart from its communication metadata.
• pollingA communication technique in which a program repeatedly requests an endpoint to check for changes.
• push-based updateA communication technique in which a server sends update data to clients when relevant changes occur.
• business logicA business logic error is a failure caused by incorrect implementation of the application's domain rules or intended behavior.
• beautiful codeCode whose quality combines aesthetic judgment with practical properties such as readability, maintainability, reliability, and durability.
• transformationTransformation is a narrative plot for business logic that centers on converting data or state from one form into another.
• programmer errorA programming error is a defect originating in code that causes an operation to behave incorrectly or fail and requires correction in the code.
• lean packagingLean packaging is a software pattern that minimizes the size and unnecessary contents of deployable packages.
• adapterA compatibility adapter is an intermediary component that translates between an older interface or data format and a newer one.
• architecture review skillThe Architecture Review skill is a structured review procedure that explores a codebase, asks for missing context, evaluates selected architectural concerns, and reports findings.
• method extensionMethod extension is an API evolution technique that expands an existing method to support additional behavior while retaining its earlier use.
• semantic versioningSemantic versioning is a version-numbering convention in which major, minor, and patch components communicate compatibility and change significance.
• versioningVersioning is the practice of identifying successive revisions of an interface or artifact so clients can distinguish and manage compatibility between them.
• text chunkChunking is the grouping of detailed operations into meaningful higher-level units that can be understood as a whole.
• Sustainability skillSustainability skill is a reusable AI instruction set for reviewing software against sustainability patterns and reporting findings.
• benchmarkA microbenchmark is a controlled performance measurement of a small code operation or component.
• CreedengoCreedengo is an open-source static-analysis tool that identifies resource-wasting coding patterns across multiple programming languages and platforms.
• dynamic analysisDynamic analysis is the examination of software by observing its behavior during execution.
• profilerA performance profiler measures and attributes software execution time or resource consumption to program operations.
• Five WhysThe 5 Whys is an iterative problem-solving method that identifies an issue's root cause by repeatedly asking why.
• incubationCreative incubation is a stage in which unconscious or subconscious mental processing continues developing ideas while conscious attention is paused.
• mind mapMind mapping is a visual organization technique that arranges a central topic and its associated subtopics in a branching structure.
• sketchstormingSketchstorming is a visual ideation technique that develops and connects ideas through freely drawn sketches and annotations.
• table of contents methodA table of contents method is a high-level method whose named calls summarize the sequence of operations performed by its implementation.
• dependencyA dependency is a software component or relationship that another component relies on to function.
• environmental impactAn environmental effect is the impact that software operation has on the natural environment through resource use and associated emissions or waste.
• agentic developmentA software-development approach in which AI agents perform or assist with programming tasks across one or more steps.
• design patternA design pattern is a named, reusable solution structure for a recurring software design problem whose implementation can vary across languages and frameworks.
• dataclassA Python dataclass is a Python class decorated to generate common methods for storing and representing data.
• null handlingA null check is a conditional test that determines whether a reference or value is absent before it is accessed.
• conditional logicA conditional is a control-flow construct that selects whether or which instructions execute according to a Boolean condition.
• KotlinA statically typed programming language that runs on the JVM and provides explicit nullability in its type system.
• obsolescenceTechnological obsolescence is the condition in which functioning hardware becomes unusable because its supporting software is unavailable or its capabilities are insufficient for current software.
• code reviewCode review is the practice of examining proposed source-code changes to identify defects, design problems, convention violations, and readability issues before integration.
• commit messageA commit message is text attached to a version-control commit that summarizes the intent and reasoning of a change.
• documentationTechnical documentation is written information that explains a software system’s purpose, usage, design, operation, or maintenance.
• living documentationLiving documentation is documentation automatically generated or maintained through the development process so that it reflects the current state of a system.
• invariantAn invariant is a condition that must remain true for a value or data structure to be valid.
• data carrierA data carrier is a small structure whose purpose is to hold and communicate a defined set of values.
• enumAn enum is a language construct that defines a finite set of named constants as a distinct type.
• fatal errorA fatal error is an unrecoverable software failure that can terminate a process or leave its execution state corrupted or unreliable.
• boilerplate codeBoilerplate code is repetitive supporting code required by a language, framework, or implementation pattern rather than by distinctive application behavior.
• interfaceAn interface is a contract that specifies operations a component provides without prescribing their implementation.
• functional interfaceA functional interface is a Java interface with one abstract method that can serve as the target type for a lambda expression or method reference.
• referential transparencyReferential transparency is the property that an expression can be replaced by its value without changing the program's behavior.
• technical debtTechnical debt is the future cost of maintenance and change created by expedient technical choices or unresolved implementation deficiencies.
• LombokLombok is a Java library that generates boilerplate source constructs through annotations during compilation.
• object instantiationObject instantiation is the creation of a runtime object from a class or object definition.
• telescoping constructorA telescoping constructor is a construction pattern that provides multiple overloaded constructors for different subsets or combinations of optional parameters.
• table of contentsA table of contents is a top-level narrative structure that orders major chapters to present the scope of a complete story or workflow.
• native executableNative execution runs compiled program code directly for a target operating-system and processor platform without an intermediate virtual-machine execution layer.
• race to haltRace to halt is an energy-efficiency technique that completes work quickly so a computing system can return sooner to an idle or low-power state.
• declarative iterationDeclarative iteration is an iteration style that specifies what sequence transformation or processing should produce rather than explicitly describing control flow.
• side effectA side effect is an observable change or interaction produced by a computation beyond returning its direct result.
• precisionNumerical precision is the degree of exactness with which a numeric value is represented or calculated.
• specialized terminologyDomain-specific vocabulary is the terminology established by a problem domain for naming its entities and concepts.
• scopeScope is the region of a program in which a name or binding is accessible.
• data typeA type is a specification of the values a program entity can represent and the operations permitted on those values.
• variable namingVariable naming is the practice of choosing identifiers that accurately and consistently communicate the purpose of stored values.
• failure pathA failure path is a sequence of execution possibilities through which an operation encounters an unsuccessful or exceptional outcome.
• code coverageTest coverage is a measure of how much software code or behavior is exercised by automated tests.
• confirmation biasConfirmation bias is the tendency to seek, notice, and remember evidence that supports existing beliefs while disregarding contrary evidence.
• edge caseAn edge case is an input or operating condition at an unusual or boundary value where software behavior may differ from the typical case.
• JUnitJUnit is a Java framework for writing and running automated tests.
• comprehension debtThe accumulated difficulty of explaining, trusting, and safely evolving code that works without being fully understood.
• technical frugalityTechnical frugality is the practice of choosing technologies and architectures that appropriately satisfy a project's actual needs without unnecessary complexity.
• closeness of mappingCloseness to the problem is the degree to which code mirrors the structure and concepts of the problem it represents.
• safetyA safety guarantee is an assurance that specified invalid or unsafe program conditions are prevented or detected.

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.