The ACCU Overload journals

• Overload 158 ePub
• Overload 158 PDF
• RE:Purpose FWD:Thinking
• The Global Lockdown of Locks
• C++20: A Simple Math Module
• A Thorough Introduction to Apache Kafka
• An Example Confined User Shell
• Agile Manchester 2020: Testers Edition
• Afterwood

• Overload 157 ePub
• Overload 157 PDF
• Rainclouds and Olive Branches
• Comment Only What The Code Cannot Say
• Refocusing Amdahl’s Law
• Some Objects Are More Equal Than Others
• Afterwood

• Overload 156 ePub
• Overload 156 PDF
• R.E.S.P.E.C.T.
• Pass the Parcel
• Quick Modular Calculations (Part 3)
• Deconstructing Inheritance
• Using Compile Time Maps for Sorting
• Profiting from the Folly of Others
• It’s About Time
• A Day in the Life of a Full-Stack Developer

• Overload 155 ePub
• Overload 155 PDF
• Members and Remembrances
• A line-to-line conversion from Node.js to Node.cpp
• The Path of Least Resistance
• Quick Modular Calculations(Part 2)
• A Secure Environment for Running Apps?
• Afterwood

• Overload 154 ePub
• Overload 154 PDF
• Inside-Out
• Trip Reports: Meeting C++ 2019 and Embedded C++ 2019
• Non-Recursive Compile Time Sort
• we they do better? Cassio Neri shows they can.">Quick Modular Calculations (Part 1)
• Afterwood

• Overload 153 ePub
• Overload 153 PDF
• Predictions and Predilections
• Scenarios Using Custom DSLs
• OOP Is not Essential
• I Come Here Not to Bury Delphi, But to Praise It
• C++ Pipes
• Afterwood

• Overload 152 ePub
• Overload 152 PDF
• Reactive or Proactive
• A Low-Latency Logging Framework
• Empty Scoped Enums as Strong Aliases for Integral Types
• C++ Reflection for Python Binding
• Trip Report: Italian C++ 2019
• Afterwood

• Overload 151 ePub
• Overload 151 PDF
• How Hard Can It Be?
• Do Repeat Yourself
• On IT and... CO₂ Footprints
• Use UTF-16 Interfaces to Ship Windows Code
• ACCU Conference 2019: Reports
• Afterwood

• Overload 150 ePub
• Overload 150 PDF
• This means war!
• NullableAttribute and C# 8
• lvalues, rvalues, glvalues, prvalues, xvalues, help!
• Modern SAT solvers: fast, neat and underused (part 1 of N)
• The Duality…
• Blockchain-Structured Programming

• Overload 149 ePub
• Overload 149 PDF
• Rip It Up and Start Again
• 5 Big Fat Reasons Why Mutexes Suck Big Time
• A Small Universe
• A Small Universe Part II
• QM Bites: Understand Windows Operating-System Identification Preprocessor Macros
• A Thorough Introduction to Distributed Systems
• Don’t Use std::endl
• Afterwood

• Overload 148 ePub
• Overload 148 PDF
• Revolution, Restoration and Revival
• Diseconomies of Scale
• Flip Model: A Design Pattern
• Memory Management Patterns in Business-Level Programs
• Compile-time Data Structures in C++17: Part 3, Map of Values
• Algol 68 – A Retrospective
• Measuring Throughput and the Impact of Cache-line Awareness
• Afterwood

• Overload 147 ePub
• Overload 147 PDF
• Are we nearly there yet?
• How to Write a Programming Language: Part 3, The Evaluator
• P1063 vs Coroutines TS: Consensus on High-Level Semantics
• Implementing the Spaceship Operator for Optional
• Compile-time Data Structures in C++17: Part 2, Map of Types

• Overload 146 ePub
• Overload 146 PDF
• Should I Lead by Example?
• Cache-Line Aware Data Structures
• miso: Micro Signal/Slot Implementation
• (Re)Actor Allocation at 15 CPU Cycles
• How to Write a Programming Language: Part 2, The Parser
• Compile-time Data Structures in C++17: Part 1, Set of Types
• Afterwood

• Overload 145 ePub
• Overload 145 PDF
• Automate all the things
• How to Write a Programming Language: Part 1, The Lexer
• Type-agnostic Tracing Using {fmt}
• A Short Overview of Object Oriented Software Design
• Afterwood

• Overload 144 ePub
• Overload 144 PDF
• Deeds not words
• No News is Good News
• Monitoring: Turning Noise into Signal
• The Interface to Component Pattern and DynaMix
• 5 Reasons NOT to Use std::ostream for Human-Readable Output
• Practical Cryptographical Theory for Programmers
• Ex Hackina

• Overload 143 ePub
• Overload 143 PDF
• Hapaxes, Singletons and Anomalies
• A Wider Vision of Software Development
• An MWSR Queue with Minimalist Locking
• Testing: Choose the Right Level
• CTAD – What Is This New Acronym All About?
• C++ with Meta-classes?
• Practical Scale Testing
• Functional Error-Handling with Optional and Expected
• Afterwood

• Overload 142 ePub
• Overload 142 PDF
• Too Fast! Too slow! Too right!!
• CAS (Re)Actor for Non-Blocking Multithreaded Primitives
• A Design Example
• The Last Word in Patterns
• Implementing Type-Classes as OCaml Modules
• Evolutionary Computing Frameworks for Optimisation
• Afterwood

• Overload 141 ePub
• Overload 141 PDF
• This way up!
• Letters to the Editor
• Marking Benches
• The Historical Context of Technology
• ‘Speedy Gonzales’ Serializing (Re)Actors via Allocators
• Polymorphism in C++ – A Type Compatibility View
• Open Source – And Still Deceiving Programmers
• C++11 (and beyond) Exception Support
• Afterwood

• Overload 140 ePub
• Overload 140 PDF
• Gnomes and Misnomers
• The Path of the Programmer
• A Usable C++ Dialect that is Safe Against Memory Corruption
• Metaclasses: Thoughts on Generative C++
• A C++ Developer Sees Rustlang for the First Time
• Portable Console I/O via iostreams
• A Functional Alternative to Dependency Injection in C++
• About the C++ Core Guidelines
• Afterwood

• Overload 139 ePub
• Overload 139 PDF
• I am not a number
• Allocator for (Re)Actors with Optional Kinda-Safety and Relocation
• Initialization in C++ is Bonkers
• Vulkan and you – Khronos’ successor to OpenGL
• Kotlin for C++ Developers
• Getting Tuple Elements with a Runtime Index
• Afterwood

• Overload 138 ePub
• Overload 138 PDF
• Breadth First, Depth First, Test First
• Space invaders in Elm
• Single Module Builds – The Fastest Heresy in Town
• An Interview: Emyr Williams
• (Not Really So) New Niche for C++: Browser!?
• Contractual Loopholes
• All About the Base

• Overload 137 ePub
• Overload 137 PDF
• Editorial: The Uncertainty Guidelines
• Mean Properties
• The Importance of Back-of-Envelope Estimates
• Multiprocessing and Clusters in Python
• doctest – the Lightest C++ Unit Testing Framewor
• Correct Integer Operations with Minimal Runtime Penalties
• Afterwood

• Overload 136 ePub
• Overload 136 PDF
• Editorial: The Font of Wisdom
• The MirAL Story
• Overloading with Concepts
• Ultra-fast Serialization of C++ Objects
• Modern C++ Features: User-Defined Literals
• Python Streams vs Unix Pipes
• Letter
• Hello World in Go
• Afterwood

• Overload 135 ePub
• Overload 135 PDF
• Editorial: Ain’t that the truth?!
• Determinism: Requirements vs Features
• Eight Rooty Pieces
• Polymorphic Comparisons
• C++ Synchronous Continuation Passing Style
• Attacking Licensing Problems with C++
• Afterwood

• Overload 134 ePub
• Overload 134 PDF
• Editorial: Just a minute
• Some Big-Os are Bigger Than Others
• Kill the Clones
• Implementing SNAAAKE
• C++ Antipatterns
• Testing Propositions
• Afterwood

• Overload 133 ePub
• Overload 133 PDF
• Editorial: Metrics and Imperialism
• Dogen: The Package Management Saga
• QM Bites – Order Your Includes (Twice Over)
• A Lifetime In Python
• Deterministic Components for Distributed Systems
• Programming Your Own Language in C++
• Concepts Lite in Practice
• Afterwood

• Overload 132 ePub
• Overload 132 PDF
• Editorial: Where Does All The Time Go?
• The Tao of Scratch
• Knowledge-Sharing Architects As An Alternative to Coding Architects
• QM Bites: Understand Windows OS Identification Preprocessor Macros
• Why Collaboration is Key for QA Teams in an Agile World
• How to Diffuse Your Way Out of a Paper Bag
• Stufftar
• QM Bites: looping for-ever
• Using Enum Classes as Bitfields
• 9.7 Things Every Programmer Really, Really Should Know

• Overload 131 ePub
• Overload 131 PDF
• Editorial: Be lucky
• Defining Concepts
• On Zero-Side-Effect Interactive Programming, Actors, and FSMs
• Template Programming Compile Time Combinations & Sieves
• Classdesc: A Reflection System for C++11
• QM Bites : Maximising Discoverability of Virtual Methods
• So Why is Spock Such a Big Deal?

• Overload 130 PDF
• Editorial: Reduce, reuse, recycle
• Once Again on TCP vs UDP
• Type Mosaicing with Consultables and Delegates
• The Universality and Expressiveness of std::accumulate
• QM Bites – The two sides of Boolean Parameters
• Identify your Errors better with char[]
• CPU Clocks and Clock Interrupts, and Their Effects on Schedulers

• Overload 129 PDF
• Failure is an option
• Introducing Concepts
• Building and Running Software on an Ubuntu Phone
• Password Hashing: Why and How
• An Inline-variant-visitor with C++ Concepts

• Overload 128 PDF
• Semi-automatic Weapons
• Multi-threading at Business-logic Level is Considered Harmful
• Two Daemons
• Don’t Design for Performance Until It’s Too Late
• Template Programming Compile Time String Functions
• Numbers in JavaScript

• Overload 127 PDF
• Editorial: A little more conversation, a little less action
• Meet the Social Side of Your Codebase
• Mocks are Bad, Layers are Bad
• Non-Superfluous People: Architects
• Terse Exception Messages
• Get Debugging Better!
• Make and Forward Consultables and Delegates

• Overload 126 PDF
• Editorial: Where was I?
• Non-Superfluous People: UX Specialists
• Alternatives to Singletons and Global Variables
• Resource Management with Explicit Template Specializations
• Variadic and Variable Templates
• iterator_pair – A Simple and Useful Iterator Adapter
• Seeing the Wood for the Trees

• Overload 125 PDF
• Editorial: FUD – Fear, uncertainty and doubt
• Best Practices vs Witch Hunts
• Making a Tool of Deception
• Modern C++ Testing
• I Like Whitespace
• Faking C Function with fff.h
• How to Write an Article
• Letter to the Editor

• Overload 124 PDF
• Ruminations on Self Employment and Running a Business
• Non-Superfluous People: Testers
• Designing Observers in C++11
• Editorial: Finding your muse
• Order Notation in Practice
• People of the .Doc
• Testing Drives the Need for Flexible Configuration

• Overload 123 PDF
• Editorial: Peer Reviewed
• Debug Complexity: How Assertions Affect Debugging Time
• Alternative Overloads
• Everyone Hates build.xml
• Defining Visitors Inline in Modern C++
• A Scheduling Technique for Small Software Projects and Teams
• Paper Bag Escapology Using Particle Swarm Optimisation
• Feeding Back

• Overload 122 PDF
• Editorial: Shop ’til you Drop
• Does Test-Driven Development Harm Clarity?
• Musings on Python – by a C++ Developer
• Activatable Object
• KISSing SOLID Goodbye
• TDD Discussions and Disagreements

• Overload 121 PDF
• Editorial: Very small or very far away:A sense of perspective
• Branching Strategies
• Beauty in Code
• The Code Is Not the Most Important Thing
• Stop the Constant Shouting
• Minimal Overhead for Multiple Interfaces

• Overload 120 PDF
• Your Life in Their Hands
• Size Matters
• Enforcing the Rule of Zero
• Quality Matters #8: Exceptions for Recoverable Conditions
• Static – A Force for Good and Evil
• Search with CppCheck
• Windows 64-bit Calling Conventions
• Teenage Hex

• Overload 119 PDF
• Editorial: Random (non)sense
• Static Polymorphic Named Parameters in C++
• Integrating the Catch Test Framework into Visual Studio
• Anatomy of a Java Decompiler
• Optimizing Big Number Arithmetic Without SSE
• Capturing lvalue References in C++11 Lambdas

• Overload 118 PDF
• Editorial: Not So Much a Program, More a Way of Life
• On the Other Side of the Barricade: Job Interviewer Do’s and Don’ts
• How to Program Your Way Out of a Paper Bag Using Genetic Algorithms
• Object-Environment Collision Detection using Onion BSPs
• Migrating from Visual SourceSafe to Git

• Overload 117 PDF
• Editorial: Decisions, Decisions
• Code as a Crime Scene
• Lies, Damn Lies and Estimates
• YAGNI-C as a Practical Application of YAGNI
• Has the Singleton Not Suffered Enough
• Automatic Navigation Mesh Generation in Configuration Space
• C++ Range and Elevation

• Overload 116 PDF
• Editorial: Learning Fantasy Languages
• Hard Upper Limit on Memory Latency
• Simple Instrumentation
• Portable String Literals in C++
• Dynamic C++ (Part 2)
• Auto – a necessary evil? (Part 2)

• Overload 115 PDF
• Editorial: Fantasy Languages
• Auto – A Necessary Evil?
• TCP/IP Explained. A Bit
• Demons May Fly Out Of Your Nose
• Wallpaper Rotation on Ubuntu using Ruby and Flickr
• Dynamic C++, Part 1
• The Uncertainty Principle

• Overload 114 PDF
• Editorial: Knitting Needles and Keyboards
• A Model for Debug Complexity
• Valgrind Part 6 – Helgrind and DRD
• Quality Matters #7 Exceptions: the story so far
• Causality – Relating Distributed Diagnostic Contexts
• Executable Documentation Doesn’t Have To Slow You Down
• Why Dysfunctional Programming Matters

• Overload 113 PDF
• Editorial: The Good, The Bad and The Discordant
• ‘No Bugs’ Top Five C++ Cooking Recipes
• Utilising More Than 4GB of Memory in 32-bit Windows Process
• The Signs of Trouble: On Patterns, Humbleness and Lisp
• The Open–Closed Principle (OCP)
• Secrets of Testing WCF Services
• Letter to the Editor

• Overload 112 PDF
• Editorial: Originally, Overload Didn’t Have an Editorial
• Web Annotation with Modified-Yarowsky and Other Algorithms
• Complex Logic in the Member Initialiser List
• -640K- 2^256 Bytes of Memory is More than Anyone Would Ever -Need- Get
• Footprint on Modify
• Valgrind Part 5 – Massif

• Overload 111 PDF
• Editorial: Too Much Information
• Valgrind Part 4: Cachegrind and Callgrind
• Universal References in C++11
• A DSEL for Addressing the Problems Posed by Parallel Architectures
• Keep It Simple, Singleton!
• Software Developer Business Patterns

• Overload 110 PDF
• Editorial: Allow Me To Introduce Myself
• Valgrind Part 3: Advanced memcheck
• Black-Scholes in Hardware
• Replace User, Strike Any Key?
• Simple Mock Objects for C++11
• Large Objects and Iterator Blocks

• Overload 109 PDF
• Editorial: It’s Not What You Know, It’s Who You Know
• Programming Darwinism
• What’s a Good Date?
• Tail Call Optimisation in C++
• All About XOR
• Curiously Recursive Template Problems with Aspect Oriented Programming
• Valgrind Part 2 – Basic memcheck

• Overload 108 PDF
• Editorial: The Computing Revolution Will Be Televised (Again)
• Why Automatic Differentiation Won’t Cure Your Calculus Blues
• Back to School
• Valgrind Part 1 – Introduction
• Mutation Testing
• Unit Testing Compilation Failure
• Refactoring Towards Seams in C++
• Compiling a Static Web Site Using the C Preprocessor
• A Position on Running Interference in Languages

• Overload 107 PDF
• Memory Leaks and Memory Leaks
• Editorial: Many Hands Make Light Work
• Many Slices of Ï€
• Why Computer Algebra Won’t Cure Your Calculus Blues
• The Eternal Battle Against Redundancies, Part 2
• A Practical Introduction to Erlang

• Editorial: Patently Ridiculous!
• Overload 106 PDF
• Moving with the Times
• The Eternal Battle Against Redundancies, Part I
• From the Age of Power to the Age of Magic and beyond...
• RAII is not Garbage
• Why Polynomial Approximation Won't Cure Your Calculus Blues
• Concurrent Programming with Go

• Overload 105 PDF
• Editorial: A Journey Through History
• Why Finite Differences Won’t Cure Your Calculus Blues
• Outsource Your Self-Discipline
• Picking Patterns for Parallel Programs (Part 1)
• Intellectual Property – a Crash Course for Developers

• Overload 104 PDF
• Editoral: Rise of the Machines
• Over-Generic Use of Abstractons as a Major Cause of Wasting Resources
• Integrating Testers Into An Agile Team
• Thread-Safe Access Guards
• An Introduction to Test Driven Development
• Why [Insert Algorithm Here] Won’t Cure Your Calculus Blues

• Overload 103 PDF
• Editorial: Can you keep a secret?
• Some Objects Are More Equal Than Others
• The Guy We’re All Working For
• Exception Specifications in C++ 2011
• Why Interval Arithmetic Won’t Cure Your Floating Point Blues
• Systems Thinking Software Development
• The ACCU 2011 Crypto Challenge

• Overload 102 PDF
• Editorial: This Year’s Model
• Benefits of Well Known Interfaces in Closed Source Code
• Why Computer Algebra Won’t Cure Your Floating Point Blues
• The Agile Spectrum
• On CMM, Formalism and Creativity
• Refactoring and Software Complexity Variability
• Despair Programming

• Overload 101 PDF
• Editorial: Ah! The fog is lifting!
• Queue with Position Reservation
• Why Rationals Won’t Cure Your Floating Point Blues
• Overused Code Reuse
• The Agile 10 Steps Model
• Rise of the Machines

• Numbers and The Appliance of Science
• Bug Hunting and the Scientific Method
• From Occam's Razor to No Bugs' Axe
• The Quartermaster's Store
• Why Fixed Point Won't Cure Your Floating Point Blues
• Interface Versioning in C++
• Quality Matters Christmas Intermezzo
• Overload 100 PDF

• Overload 99 PDF
• Lies, Damn Lies, and Statistics
• You're Going To Have To Think!
• What motivates software developers: a workshop report
• To DLL or Not To DLL
• Making String ReTRIEval Fast
• Quality Matters #6: Exceptions for Practically-Unrecoverable Conditions

• A Little Learning Is A Dangerous Thing
• "I'm a Business Analyst - Get Me Out Of Here"
• The Model Student: The ACCU 2010 Crypto Challenge
• Renovating a Legacy C++ Project
• Single-Threading: Back to the Future? (Part 2)
• Debugging Run Time Memory Problems
• Quality Matters: The Worst Form of 'Error' Handling Except For All The Others
• Overload 98 PDF

• The Art of the Possible
• Scalable Graph Coverage
• Socially Responsible Recruitment
• Single-Threading: Back to the Future?
• The Model Student: A Game of Six Integers (Part 3)
• The Functional Student: A Game of Six Integers
• Overload 97 PDF

• Dealing with Growing Pains
• The Model Student: A Game of Six Integers (Part 2)
• Using Design Patterns to Manage Complexity
• Bug Elimination - Defensive Agile Ruses
• A Practical, Reasoned and Inciteful Lemma for Overworked and Overlooked Loners
• Overload 96 PDF

• Overload 95 PDF
• Back To The Future
• One Approach to Using Hardware Registers in C++
• The Model Student: A Game of Six Integers (Part 1)
• Simplifying the C++/Angelscript Binding Process
• Quality Matters: Diagnostic Measures
• Quality Matters: Diagnostic Measures (Listings)

• A Crack in Time
• Shadow Data Types
• Creating a Framework for the iPhone
• The Model Student: A Primal Skyline (Part 3)
• Project-Specific Language Dialects
• Quality Matters: A Case Study in Quality
• Overload 94 PDF

• All together now.
• The Model Student: A Primal Skyline (Part 2)
• Multi-threading in C++0x
• Quality Matters: Correctness, Robustness and Reliability
• The Generation, Management and Handling of Errors (Part 2)
• Overload 93 PDF

• Moments in History
• I Think I'll Parse
• Quality Matters: Introductions, and Nomenclature
• Code Rot
• The Model Student: A Primal Skyline (Part 1)
• The Generation, Management and Handling of Errors (Part 1)
• No 'Concepts' in C++0x
• Overload 92 PDF

• A Good Craftsman Knows His Tools
• Floating Point Fun and Frolics
• On Management: The Business Analyst's Role
• Complexity, Requirement and Modules
• An Introduction to FastFormat (Part 3): Solving Real Problems, Quickly
• The Model Student: The Enigma Challenge
• Boiler Plating Database Resource Cleanup (Part 2)
• ACCU 2009
• Overload 91 PDF

• Back to School
• Software Development in the 21st Century
• Testing State Machines
• If You Can't See Me, I Can't See You
• The Model Student: A Rube-ish Square (Part 2)
• On Management: Product Managers
• An Introduction to FastFormat (Part 2): Custom Argument and Sink Types
• WRESTLE: Aggressive and Unprincipled Agile Development in the Small
• Overload 90 PDF

• Watt's going on?
• Measurable Value with Agile
• Through The Looking Glass
• Orderly Termination of Programs
• On Management: Caveat Emptor
• The Model Student: A Rube-ish Square (Part 1)
• An Introduction to Fast Format (Part 1): The State of the Art
• Overload 89 PDF

• The Sweet Smell of Success
• The Model Student: Can Chance Make Fine Things? (Part 2)
• Model View Controller with Java Swing
• On Management: Understanding Who Creates Software
• The Legion's Revolting!
• Iterators and Memberspaces
• Generics without Templates - Revisited
• Overload 88 PDF

• The Invisible Hand
• Seeing Things Differently
• DynamicAny (Part 2)
• On Management: Focus, Quality, Time-boxes and Ducks
• The Model Student: Can Chance Make Fine Things? (Part 1)
• Performitis (Part 3)
• Overload 87 PDF

• It's good to talk...
• DynamicAny, Part I
• Performitis - Part 2
• Globals, Singletons and Parameters
• Exceptions Make for Elegant Code
• Divide and Conquer: Partition Trees and Their Uses
• On Management
• Overload 86 PDF

• Plus ça change
• Performitis
• The Model Student: A Knotty Problem, Part 2
• Overload 85 PDF
• RSA Made Simple
• Quality Manifesto

• After Four Years
• Watersheds and Waterfalls (Part 2)
• The Model Student: A Knotty Problem, Part 1
• The Way of the Consultant
• Overload 84 PDF

• When Things Go Wrong
• Letter to the Editor
• Watersheds and Waterfalls
• The PfA Papers: Deglobalisation
• The Regular Travelling Salesman, Part 2
• Testing Visiting Files and Directories in C#
• Generics Without Templates
• Future Workers (Prototype)
• Overload 83 PDF

• Overload 82 PDF
• The Essence of Success
• The PfA Papers: Context Matters
• The Model Student
• Functional Programming Using C++ Templates (Part 2)
• Java Protocol Handlers
• Upgrading Legacy Software in Data Communications Systems
• Creating Awareness

• Overload 81 PDF
• While the Cat's Away...
• The PfA Papers: The Clean Dozen
• Blue-White-Red, an Example Agile Process
• Functional Programming Using C++ Templates (Part 1)
• auto_value: Transfer Semantics for Value Types

• Consensus
• Letter to the Editor
• He Sells Shell Scripts to Intersect Sets
• The PfA Papers: From the Top
• Release Mode Debugging
• auto_value: Transfer Semantics for Value Types
• Guidelines for Contributors
• Overload 80 PDF

• Overload 79 PDF
• Rip It Up and Start Again
• The Policy Bridge Design Pattern
• Live and Learn with Retrospectives
• Continuous Integration with CruiseControl.Net
• Working with GNU Export Maps
• auto_value: Transfer Semantics for Value Types

• New Tricks for an Old Dog
• Letters to the Editor
• Software Product Line Engineering with Feature Models
• A Perspective on Use of Conditional Statements versus Assertions
• Implementing Synchronization Primitives for Boost on Windows Platforms
• Design in Test-Driven Development
• C++ Unit Test Frameworks
• A Practical Form of OO Layering
• Overload 78 PDF

• Overload 77 PDF
• The Power of Inertia
• Managing Technical Debt
• Programming - Abstraction by Design
• Exceptional Design
• C++ Trivial Logger
• FRUCTOSE - a C++ Unit Test Framework
• Letter to the Editor

• Overload 76 PDF
• How Overload Comes to You
• Pooled Lists
• The Singleton in C++ - A force for good?
• C++ Interface Classes - Strengthening Encapsulation
• A Drop in Standards?

• Overload 75 PDF
• Life in the Fast Lane
• Letters
• Up Against the Barrier
• Inventing a Mutex
• C++ Unit Testing Easier: CUTE
• From CVS to Subversion

• Overload 74 PDF
• Take a Step Forward
• Comments Considered Good
• Introducing CODEF/CML
• Fine Tuning for lexical_cast
• C# Generics - Beyond Containers of T
• The Kohonen Neural Network Library
• The Documentation Myth

• Overload 73 PDF
• Editorial
• Pair Programming Explained
• Comments Considered Evil
• How Do Those Funky Placeholders Work?
• Implementing drop-down menus in pure CSS (no JavaScript)
• The Rise and Fall of Singleton Threaded
• The Case Against TODO
• Objects for States

• Overload 72 PDF
• Editorial: Doing What You Can
• Multithreading 101
• To Grin Again
• A Fistful Of Idioms
• C++ Best Practice – Designing Header Files
• Visiting Alice

• Overload 71 PDF
• Editorial: Keeping Up Standards
• Soft Documentation
• Dead Code
• How to Shoot Yourself in the Foot. In an Agile Way.
• Friend or Foe!
• Recursive Make Considered Harmful

• Overload 70 PDF
• Editorial: The "Safe C++ Standard Library"
• Two-thirds of a Pimpl and a Grin
• The Curate's Wobbly Desk
• Letter to the Editor
• How to Quantify Quality: Finding Scales of Measure
• "Here be Dragons"
• Better Encapsulation for the Curiously Recurring Template Pattern

• Overload 69 PDF
• Editorial: Can We Change For The Better?
• With Spirit
• Vorsprung Durch Testing
• Polynomial Classes
• Incremental Design: A Case Study of a Compiler
• A Framework for Generating Numerical Test Data

• Overload 68 PDF
• Editorial: Size Does Matter
• Software Project Management: Adding Stakeholder Metrics to Agile Projects
• Investigating Java Class Loading
• C-side Re-sort
• C++ Interface Classes - Noise Reduction
• A Technique for Register Access in C++

• Overload 67 PDF
• Editorial: Does all this help make better software?
• The Trial of the Reckless Coder
• "The C++ Community" - Are We Divided by a Common Language?
• Taming Complexity: A Class Hierarchy Tale
• Microsoft Symbol Engine
• Letters to the Editor
• Grain Storage MIS: A Failure of Communications (27 March 1998)
• Can C++ Learn from Generics in Ada?

• Overload 66 PDF
• Editorial: Need to Unlearn
• Sheep Farming for Software Development Managers
• Separating Interface and Implementation in C++
• Overload Resolution - Selecting the Function
• Metaprogramming is Your Friend
• Letter to the Editor
• Digging a Ditch

• Overload 65 PDF
• Editorial: "They" Have Their Reasons
• The Developer's New Work
• Stable Intermediate Forms
• Multiple Streams Going Nowhere
• Letters: Encapsulate Context
• Confirmit. Confirmit is a web-based application which enables organizations to gather, analyze and report key business information across a broad range of commercial applications.
  ">From Waterfall to EVO in a Medium Size Norwegian Software House
• C++ Properties - a Library Solution
• C Abuse
• A Pair Programming Experience

• Overload 64 PDF
• Editorial: A Glimpse Behind the Scenes
• Yet Another Hierarchical State Machine
• Mini-project to Decode A Mini-language - Part Two
• Evolution of the Observer Pattern
• An Experience Report on Implementing a Custom Agile Methodology on a C++/Python Project

• Overload 63 PDF
• Editorial: The Buzzword Adoption Pattern?
• The Encapsulate Context Pattern
• Microsoft Visual C++ and Win32 Structured Exception Handling
• Garbage Collection and Object Lifetime
• C++ Lookup Mysteries
• A Mini-project to Decode a Mini-language - Part One

• Overload 62 PDF
• Editorial: The Value of What You Know
• The Curious Case of the Compile-Time Function
• ACCU Mentored Developers XML Project
• Letters to the Editor
• Handling Exceptions in finally
• From Mechanism to Method: The Safe Stacking of Cats
• C++ Interface Classes - An Introduction
• A Template Programmer's Struggles Revisited

• Overload 61 PDF
• Editorial: New Things Under the Sun
• Letters: Software’s No Different...
• Where Egos Dare
• When is a "Pattern" not a "Pattern"?
• The Tale of a Struggling Template Programmer
• Lvalues and Rvalues
• Efficient Exceptions?
• Letters: The Invisibility of Software Design
• Letters: Software Project Management Classics?
• A Template Programmer’s Struggles Resolved

• Overload 60 PDF
• Editorial
• Transforming XML with XSLT
• Letters to the Editor(s)
• Letters to the Editor(s)
• From Mechanism to Method: Generic Decoupling
• All Heap No Leaks
• Achieving FitNesse in C++
• A Little Detail

• Overload 59 PDF
• Editorial
• Why do requirements change?
• More is Less
• Letters to the Editor(s)
• Heretical Java #1
• From Mechanism to Method:
• C++ as a Safer C

• Overload 58 PDF
• Editorial
• From Mechanism to Method:
• Choosing Template Parameters
• CheckedInt: A Policy-Based Range-Checked Integer
• An Alternative View of design (and planning)
• A Standard Individual: A Licensed Engineer
• A More Flexible Container
• Letter to the Editor(s)

• Overload 57 PDF
• Statically Checking Exception Specifications
• Editorial
• Software As Read
• Single Exit
• SINGLETON - the anti-pattern!
• Letters to the Editor(s)
• Letters to the Editor(s)
• Letters to the Editor(s)
• Is IT worth it?
• Error and Exception Handling
• Chaos Theory
• A Policy-Driven CORBA Template Library to Facilitate the Rapid Development of DOC Middleware

• Overload 56 PDF
• Editorial
• Three Phantastic Tales
• Stream-Based Parsing in C++
• Reshaping an Old Piece of Design
• EuroPLoP 2003 Conference Report
• A Unified Singleton Framework

• Overload 55 PDF
• Editorial
• Ruminations on Knowledge in Software Development
• How To Write A Loop
• From Mechanism to Method
• Embedded Scripting Languages
• A bin Manipulator For IOStreams

• Overload 54 PDF
• Editorial
• The Nature and Aesthetics of Design
• Software development and the learning organisation
• Observer Pattern Implementation
• Labouring: An Analogy
• Implementing the Bridge pattern using templates with Microsoft Visual C++ 6.0
• Exported Templates
• EXPR_TYPE - An Implementation of typeof Using Current Standard C++
• Addendum to "Tiny Template Tidbit"
• A C++ Petri Net Framework For Multithreaded Programming

• Overload 53 PDF
• Editorial
• Implementing the Observer Pattern in C++ - Part 2
• From Mechanism to Method ­Total Ellipse
• Build Systems
• Indexing STL lists with maps
• A Return Type That Doesn’t Like Being Ignored
• C++rossword
• C++ Standards Library Report
• C++ Templates

• Overload 52 PDF
• Organising Source Code
• Letters to the Editor
• Implementing the Observer Pattern in C++ - Part 1
• From Mechanism to Method - Good Qualifications
• File Format Conversion Using Templates and Type Collections
• Editorial - On Writing
• Developing a C++ Unit Testing Framework

• Overload 51 PDF
• STL-style Circular Buffers By Example, Part Two
• Patterns Collaborations: Observer and Composite
• Pairing Off Iterators
• Mutate? or Create?
• Extendable Software and the Bigger Picture
• Exception Handling in C#
• Editorial - Software Quality
• Applied Reading - Taming Shared Memory

• Overload 50 PDF
• The Philosophy of Extensible Software
• Template Metaprogramming: Shifting Down a Gear
• STL-style Circular Buffers By Example
• Execute Around Method and Proxy Goulash
• Even More Java Exceptions
• Editorial
• Alternatives for Partial Template Function Specialisation

• Overload 49 PDF
• Writing Extendable Software
• The scoping problem
• Programming with Interfaces in C++
• More Exceptional Java
• Letter To The Editor
• Editorial
• Building Java Applications
• An Overview of C#.NET

• Overload 48 PDF
• Thinking about "reuse"
• The C++ Template Argument Deduction
• Template Titbit - A Different Perspective
• From Mechanism to Method - Function Follows Form
• Exceptional Java
• Editorial
• C++ Exceptions and Linux Dynamic Libraries

• Overload 47 PDF
• What is Boost?
• Tiny Template Tidbit
• Of Minimalism, Constructivism and Program Code
• minimalism
• Editorial: Product Definition
• Minimalist Constructive Criticism
• Introduction to WOC:
• How about a Turner Prize for software?

• Editorial - Coming Home
• Template Metaprogramming
• Techniques for Debugging in C++
• Modelling and Software Development
• Metaclasses and Reflection in C++ - Part 2

• Porting part 3 :
• minimalism
• Editorial
• Metaclasses and Reflection in C++
• Introduction to C++ Templates

• Using Version Control
• String Tokenization - A Programmer's Odyssey
• Porting (part 2) - Addressing the Differences
• Flexible Functors and Binders
• Editorial
• Designing C++ Interfaces - Templates
• Are You Afraid of The Dark Too? Making More Sense of the STL

• Editorial
• Where to begin: Porting
• Introduction to the Database Template Library
• Designing C++ Interfaces - Exception Safety
• Are You Afraid of The Dark? - Making Sense of the STL
• An introduction to C++ Traits
• .NET

• Typesafe Registry for Windows
• Multimethods
• Editor << letters;
• Editor << letters;
• Editorial
• Compile Time Indirection - An Unusual Template Technique
• C++ Idioms: First Thoughts
• A Generic Non-intrusive Smart Pointer Implementation
• A Deeper Look at Inline Functions

• C++ Standards - The "swap" Problem
• Experiences of Implementing the Observer Design Pattern (Part 3)
• Editorial
• Where is __FUNCTION__?
• Thread Pooling: An Investigation
• Source Code Modules and Layering
• Extensibility - A Reason For Using Streams in C++

• Programming with Interfaces in C++
• More Include File Rules
• Here be Dragons
• From Mechanism to Method
• editorial: Concerning Patents

• User Defined Types: Qualities, Principles and Archetypes.
• Include Files
• From Mechanism to Method: Substitutability
• Editorial
• C++ Patterns Source Cohesion and Decoupling

• Supporting Threads in Standard C++ (Addendum)
• Intuitive Multi-Paradigm Design:
• Interpreting "Supporting the 'Cheshire Cat' Idiom"
• Experiences of Implementing the Observer Design Pattern (Part 2)
• Editorial
• A Fistful Of Idioms - Giving STL Iterators a Base Class

• editor << letters;
• The Pet Project (part 4)
• Supporting Threads in Standard C++ (Part 3)
• editorial
• A framework for object serialization in C++
• In Response to Extreme Programming
• Experiences of Implementing the Observer Design Pattern (Part 1)

• XML in Applications II DOM - the Document Object Model
• The Pet Project - Monopoly (Part 3)
• Supporting Threads in Standard C++ (Part 2)
• editorial
• An Implementation of Double Dispatch in Java
• An Application of Pointers to Members
• A Response to the C++ SIG Organiser

• Standard C++
• My Pet Project Monopoly 2
• eXtreme Programming An interview with Kent Beck
• File Headers
• Exceptions - Guidance
• Error handling and logging
• editorial
• Automatic Object Versioning for Forward and Backward File Format Compatibility

• editor << letters;
• XML
• When's an object not an object?
• Uncounted pointers in C++
• The Diary of Bridget Jones the Weekend Before OT
• Software Architecture
• SAX - A Simple API for XML
• My Pet Project - Monopoly
• Exceptions - The Details
• Error logging and patterns
• Editorial

• editor << letters;
• The State Pattern - A New Implementation
• Religious Issues
• More threading with templates
• More cow_ptr<type> Ruminations
• Exceptions - The Basics
• Editorial
• Coping with Copying in C++

• The EPOC C++ API
• Ruminations on Studying Design Patterns
• Polymorphism In Object-Oriented Languages
• Modern Art as an Inspiration for Software
• Micro-Derivation & Related Ideas
• Editorial
• Builder & Factory Method Patterns
• BroadVision, Part 4
• Beyond ACCU
• A Simple Model for Object Persistence Using the Standard Library
• A Review of cow_ptr<type>

• Using Templates To Handle Multi-Threading
• copy_on_write_ptr<type>
• Thoughts on Functoids
• Response To "Patterns - The Abstract Factory" (Francis Glassborow, Overload 30)
• Objects In Databases
• Goodbye Overload
• Fitting in with multiple frameworks in C++ and Java
• Factories in C++: Disposing of the Product
• Exception Handling Alternatives (Part 2)
• Editorial

• Write to Learn
• UML Relationships and Associations, Aggregation and Composition
• Patterns - The Abstract Factory
• Overloading Operators
• editor << letters;
• Garbage Collection Implementation Considerations
• Exception Handling Alternatives
• Editorial
• Data Attribute Notation - Part 3
• An Eventful Story
• A Letter from Ken Hagan annotated by The Harpist

• operator == ()
• counted_ptr<type> revisited
• Static vs Member Functions
• Exception Specifications
• Exception Errors
• Exception Discussion
• Editorial
• Debug new and delete Part 3
• Data Attribute Notation - Part 2
• Beyond ACCU... Patterns on the 'net
• A Message from the ACCU Chair
• A Delphic Experience

• Shallow Pointer
• Notes on Exceptions
• Exploring Patterns 3 - The Adapter
• Exceptions & Exception Specifications
• Exception Usage
• Editor << letters;
• Editorial
• Controlling access to objects by using private interfaces
• Broadvision - Part 3
• Beyond ACCU... Java on the 'net

• Overload 27 PDF
• Object (low-level) Design and Implementation
• Hotel Case Study Comments
• UML Interactions & Collaborations
• Self Registering Classes - Taking polymorphism to the limit
• Hotel Case Study Comments
• Exploring Patterns Part 2
• Editorial
• Broadvision - Part 2
• Beyond ACCU... Patterns on the 'net
• Almost a Pattern

• Overload 26 PDF

• Overload 25 PDF

• Overload 24 PDF

• Overload 23 PDF

• Overload 22 PDF

• Overload 21 PDF

• Overload 20 PDF

• Overload 19 PDF

• Editorial
• The uses and abuses of inheritence
• Caught in the pattern web
• The Casting Vote I
• The Casting Vote II
• Circles and Ellipses revisited: coding techniques - 2
• Standard containers for polymorphic types
• auto_ptr || !auto_ptr
• Using objects for background tasks (3)

• Overload 16 PDF

• Overload 15 PDF

• Overload 14 PDF

• Overload 13 PDF

• Overload 12 PDF

• Overload 11 PDF

• Overload 10 PDF

• Overload 9 PDF

• Overload 8 PDF

• Overload 7 PDF

• The Casting Vote
• Putting Jack in the Box
• Overloading on const is wrong
• Friends - who needs them?
• C++ compilers for MSDOS / MSWindows
• Blindspots
• An alternative to wchar_t
• A Text Formatting Class

• The Virtual Interview
• Operators for Arithmetic Classes
• Are “Safe” Computer Systems Possible?
• So you want to be a cOOmpiler writer?
• Microsoft Visual C++ V1.5 (16bit)
• Borland C++ V4.
• Writing Your Own Stream Manipulators
• The Casting Vote
• Microsoft Visual C++ Strategy
• Letters
• Afterword

• Editor's Ramble
• The Casting Vote
• Windows Waffle
• Do birds in their little nests always agree?
• new & delete
• Shared Memory Class
• Run-time checking for C++
• Why C++ will replace FORTRAN (or, at least, why it should)
• char* p vs char *p
• Readers Letters
• Epilogue

• Editor's Ramble
• Welcome to ECUG
• Minimising Stack Use and Other Uses of new
• C++ Strings -The ANSI Way
• Managing Class Coupling
• Custom Controls
• Windows File Class
• Class Struggle
• Unit Testing Of C++ Classes
• Uses of Classes with only Private and Protected Constructors
• A Short Exposure to C++
• Readers Letters
• Epilogue

• Editor's Ramble
• C++ Streams (Part 2)
• Class Struggle
• The Help Compiler
• Some Thoughts on the Use of New
• An E-mail Conversation with Bjarne Stroustrup
• Members' Letters
• The Pedant
• Epilogue

• Editor's Ramble
• C++ Streams
• Make...or Break?
• Templates
• An Introduction to Object Orientation
• Class Struggle
• Rumbaugh's OMT - The method behind C++ Designer
• Dates & Times
• Starting out with OWL
• Some Thoughts on Writing Classes
• Whingeing Session
• Epilogue

• On the Other Side of the Barricade: Job Interviewer Do’s and Don’ts
• Object-Environment Collision Detection using Onion BSPs
• How to Program Your Way Out of a Paper Bag Using Genetic Algorithms [XML/HTML]
• Hand edited from Test-HTML-1. Last changed: 10 July 2013, Martin Moene]">Executable Documentation Doesn’t Have To Slow You Down [Test-HTML-2]
• Sample Overload Article (title)
• Executable Documentation Doesn’t Have To Slow You Down [Test-XML-1]
• HTML generated by Alison Peck. A hand edited version is at Test-HTML-2 by Martin Moene]">Executable Documentation Doesn’t Have To Slow You Down [Test-HTML-1]