Members: please login and return to this page for full access.
Non-Members: join today to gain access to the content summarised below.
- Overload Journal 190 - December 2025 PDF
- Overload Journal 190 - December 2025 ePub
- A Guest Editorial
- Why I Don’t Use AI
- Concurrency Flavours
- Coroutines – A Deep Dive
- Dynamic Memory Management on GPUs with SYCL
- 15 Different Ways to Filter Containers in Modern C++
- Afterwood
- Overload Journal 189 - October 2025 PDF
- Overload Journal 189 - October 2025 ePub
- Ignore Rants
- Vibe Coding in Rust
- UDB: The undo.io Time Travel Debugger
- Filters and Wildcards (Shell Globbing)
- User-Defined Formatting in std::format
- Afterwood
- Overload Journal 188 - August 2025 PDF
- Overload Journal 188 - August 2025 ePub
- What’s THIS for?
- Local Reasoning Can Help Prove Correctness
- Simple Compile-Time Dynamic Programming in Modern C++
- UI Development with BDD and Approval Testing
- Trip report: C++ On Sea 2025
- AI Powered Healthcare Application
- Afterwood
- Overload Journal 187 - June 2025 PDF
- Overload Journal 187 - June 2025 ePub
- Eliminate the Impossible
- Debugging Run-time Windows DLL Problems
- Codurance AI Hackathon
- Tracking Success
- Afterwood
- Overload Journal 186 - April 2025 PDF
- Overload Journal 186 - April 2025 ePub
- self->doubt
- Writing Senders
- C++26: Erroneous Behaviour
- constexpr Functions: Optimization vs Guarantee
- UML Statecharts Formal Verification
- P271828R2: Adding mullptr to C++
- Overload Journal 185 - February 2025 PDF
- Overload Journal 185 - February 2025 ePub
- All the Information is on the Task
- Using Senders/Receivers
- Bit Fields, Byte Order and Serialization
- Valgrind’s Dynamic Heap Analysis Tool: DHAT
- Afterwood
- Overload Journal 184 - December 2024 PDF
- Overload Journal 184 - December 2024 ePub
- Counting Quails
- User Stories and BDD – Part 4, Features Are Not Stories
- Static Reflection in C++
- Senders/Receivers: An Introduction
- Replacing ‘bool’ Values
- Afterwood
- Overload Journal 183 - October 2024 PDF
- Overload Journal 183 - October 2024 ePub
- What Does It All Mean?
- Formal Verification
- C++ Compile-Time Programming
- The Publish Pattern
- Modernization of Legacy Arrays: Replacing CArray with std::vector
- Afterwood
- Overload Journal 182 - August 2024 PDF
- Overload Journal 182 - August 2024 ePub
- A Humble Proposal
- User-Defined Formatting in std::format – Part 3
- In an Atomic World
- Trip report: C++ On Sea 2024
- Afterwood
- Overload Journal 181 - June 2024 PDF
- Overload Journal 181 - June 2024 ePub
- Breaking Bad (Habits)
- User-Defined Formatting in std::format – Part 2
- Reverse-Engineering cuBLAS
- Fat API Bindings of C++ Objects into Scripting Languages
- Concurrency: From Theory to Practice
- Afterwood
- Overload Journal 180 - April 2024 PDF
- Overload Journal 180 - April 2024 ePub
- I Don’t Believe It!
- C++ Safety, In Context
- To See a World in a Grain of Sand
- User-Defined Formatting in std::format
- Judgment Day
- Overload Journal 179 - February 2024 PDF
- Overload Journal 179 - February 2024 ePub
- Over-Promise, Under-Deliver
- User Stories and BDD – Part 3, Small or Far Away?
- C++20 Concepts Applied – Safe Bitmasks Using Scoped Enums
- And the Winners Are...
- Safety, Revisited
- Afterwood
- Overload Journal 178 - December 2023 PDF
- Overload Journal 178 - December 2023 ePub
- General Knowledge and Selective Ignorance
- User Stories and BDD – Part 2, Discovery
- Use SIMD: Save The Planet
- Dollar Origins
- How to Write an Article
- Afterwood
- Overload Journal 177 - October 2023 PDF
- Overload Journal 177 - October 2023 ePub
- Frozen or Buffering?
- Enodo, Divide et Impera
- Live and Let Die
- C# v12 Primary Constructors
- Drive Musings on Linux
- Afterwood
- Overload Journal 176 - August 2023 PDF
- Overload Journal 176 - August 2023 ePub
- Asleep at the Wheel
- C++ Exceptions and Memory Allocation Failure
- C++ on Sea 2023: Trip Report
- Reasoning about Complexity – Part 2
- Passkey Idiom: A Useful Empty Class
- C++20 Dynamic Allocations at Compile-time
- Afterwood
- Overload Journal 175 - June 2023 PDF
- Overload Journal 175 - June 2023 ePub
- Production and Productivity
- Reasoning About Complexity – Part 1
- Incompatible Language Features in C#
- Need Something Sorted? Sleep On It!
- Type Safe C++ enum Extensions
- Why You Should Only Rarely Use std::move
- Afterwood
- Overload Journal 174 - April 2023 PDF
- Overload Journal 174 - April 2023 ePub
- The Rise and Fall of Almost Everything
- Drawing a Line Under Aligned Memory
- C++20 Concepts: Testing Constrained Functions
- In Search of a Better Concurrency Model
- Meta Verse
- Overload Journal 173 - February 2023 PDF
- Overload Journal 173 - February 2023 ePub
- Under Pressure
- Floating-Point Comparison
- Determining If A Template Specialization Exists
- Stack Frame Layout On x86-64
- And the Winners Are...
- Value-Oriented Programming
- Afterwood
- Overload Journal 172 - December 2022 PDF
- Overload Journal 172 - December 2022 ePub
- Don’t Believe the Hype
- Compile-Time Strings
- The Year of C++ Successor Languages
- An Introduction to Go for C++ Programmers
- The Testing Iceberg
- The Model Student: The Regular Travelling Salesman – Part 2
- Afterwood
- Overload Journal 171 - October 2022 PDF
- Overload Journal 171 - October 2022 ePub
- Sustainability: An Impossible Dream?
- User Stories and BDD – Part 1
- The Power of Ref-qualifiers
- The ACCU Conference
- The Model Student: The Regular Travelling Salesman – Part 1
- Afterwood
- Overload Journal 170 - August 2022 PDF
- Overload Journal 170 - August 2022 ePub
- Whodunnit?
- saturating_add vs. saturating_int – New Function vs. New Type?
- Advancing the State of the Art for std::unordered_map Implementations
- Don’t Block Doors
- Lessons Learned After 20 Years of Software Engineering
- Afterwood
- Overload Journal 169 - June 2022 PDF
- Overload Journal 169 - June 2022 ePub
- What Happened to Demo 13?
- Performance Considered Essential
- Compile-time Wordle in C++20
- ACCU 2022 Trip Reports
- Afterwood
- Overload Journal 168 - April 2022 PDF
- Overload Journal 168 - April 2022 ePub
- On Becoming Unstuck
- Taming Wordle with the Command Line
- C++20: A Coroutine Based Stream Parser
- Structured Concurrency in C++
- The Vector Refactored
- Overload Journal 167 - February 2022 PDF
- Overload Journal 167 - February 2022 ePub
- What are you optimizing for?
- Revisiting Data-Oriented Design
- An Associative Container for Non-bash Shell Scripts
- Why Should Automation Be Done By The Dev Team?
- C++20 Benefits: Consistency With Ranges
- Afterwood
- Overload Journal 166 - December 2021 PDF
- Overload Journal 166 - December 2021 ePub
- It’s Not Normal
- Programming Language Unlimited
- C++20 Text Formatting: An Introduction
- No Move vs Deleted Move Constructors
- Afterwood
- Overload Journal 165 - October 2021 PDF
- Overload Journal 165 - October 2021 ePub
- The Right Tool for the Job
- Showing Variables Using the Windows Debugging API
- Stufftar Revisited
- Executors: a Change of Perspective
- Afterwood
- Overload Journal 164 - August 2021 PDF
- Overload Journal 164 - August 2021 ePub
- Too Much Typing
- C++ Executors: the Good, the Bad, and Some Examples
- Testing Propositions
- Teach Your Computer to Program Itself
- Afterwood
- Overload Journal 163 - June 2021 PDF
- Overload Journal 163 - June 2021 ePub
- Geek, Nerd or Neither?
- Replacing ‘bool’ Values
- How We (Don’t) Reason About Code
- Out of Control
- The Sea of C You Don’t Want to See
- Overload Journal 162 - April 2021 PDF
- Overload Journal 162 - April 2021 ePub
- Keep Up at the Back
- Amongst Our Weaponry
- Composition and Decomposition of Task Systems
- Chepurni Multimethods for Contemporary C++
- <script>
- Overload Journal 161 - February 2021 PDF
- Overload Journal 161 - February 2021 ePub
- In. Sub. Ordinate.
- A Case Against Blind Use of C++ Parallel Algorithms
- C++ – an Invisible Foundation of Everything
- Test Precisely and Concretely
- Afterwood
- Overload Journal 160 - December 2020 PDF
- Overload Journal 160 - December 2020 ePub
- Debt – My First Thirty Years
- Questions on the Form of Software
- Building g++ From the GCC Modules Branch
- Consuming the uk-covid19 API
- What is the Strict Aliasing Rule and Why Do We Care?
- Afterwood
- Overload Journal 159 - October 2020 PDF
- Overload Journal 159 - October 2020 ePub
- Virtual/Reality
- poly::vector – A Vector for Polymorphic Objects
- Kafka Acks Explained
- Concurrency Design Patterns
- C++ Modules: A Brief Tour
- The Edge of C++
- Afterwood
- Overload Journal 158 - August 2020 PDF
- Overload Journal 158 - August 2020 ePub
- 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 Journal 157 - June 2020 PDF
- Overload Journal 157 - June 2020 ePub
- Rainclouds and Olive Branches
- Comment Only What The Code Cannot Say
- Refocusing Amdahl’s Law
- Some Objects Are More Equal Than Others
- Afterwood
- Overload Journal 156 - April 2020 PDF
- Overload Journal 156 - April 2020 ePub
- 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 Journal 155 - February 2020 PDF
- Overload Journal 155 - February 2020 ePub
- 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 Journal 154 - December 2019 PDF
- Overload Journal 154 - December 2019 ePub
- Inside-Out
- Trip Reports: Meeting C++ 2019 and Embedded C++ 2019
- Non-Recursive Compile Time Sort
- Quick Modular Calculations (Part 1)
- Afterwood
- Overload Journal 153 - October 2019 PDF
- Overload Journal 153 - October 2019 ePub
- 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 Journal 152 - August 2019 PDF
- Overload Journal 152 - August 2019 ePub
- 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 Journal 151 - June 2019 PDF
- Overload Journal 151 - June 2019 ePub
- How Hard Can It Be?
- Do Repeat Yourself
- On IT and... CO2 Footprints
- Use UTF-16 Interfaces to Ship Windows Code
- ACCU Conference 2019: Reports
- Afterwood
- Overload Journal 150 - April 2019 PDF
- Overload Journal 150 - April 2019 ePub
- 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 Journal 149 - February 2019 PDF
- Overload Journal 149 - February 2019 ePub
- Rip It Up and Start Again
- 5 Big Fat Reasons Why Mutexes Suck Big Time
- A Small Universe
- QM Bites: Understand Windows Operating-System Identification Preprocessor Macros
- A Thorough Introduction to Distributed Systems
- Don’t Use std::endl
- Afterwood
- Overload Journal 148 - December 2018 PDF
- Overload Journal 148 - December 2018 ePub
- 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 Journal 147 - October 2018 PDF
- Overload Journal 147 - October 2018 ePub
- 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 Journal 146 - August 2018 PDF
- Overload Journal 146 - August 2018 ePub
- 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 Journal 145 - June 2018 PDF
- Overload Journal 145 - June 2018 ePub
- 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 Journal 144 - April 2018 PDF
- Overload Journal 144 - April 2018 ePub
- 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 Journal 143 - February 2018 PDF
- Overload Journal 143 - February 2018 ePub
- 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 Journal 142 - December 2017 PDF
- Overload Journal 142 - December 2017 ePub
- 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 Journal 141 - October 2017 PDF
- Overload Journal 141 - October 2017 ePub
- 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 Journal 140 - August 2017 PDF
- Overload Journal 140 - August 2017 ePub
- 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 Journal 139 - June 2017 PDF
- Overload Journal 139 - June 2017 ePub
- 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 Journal 138 - April 2017 PDF
- Overload Journal 138 - April 2017 ePub
- 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 Representing numbers presents many choices.
- Overload Journal 137 - February 2017 PDF
- Overload Journal 137 - February 2017 ePub
- The Uncertainty Guidelines
- Mean Properties
- The Importance of Back-of-Envelope Estimates
- Multiprocessing and Clusters in Python
- doctest - the Lightest C++ Unit Testing Framework
- Correct Integer Operations with Minimal Runtime Penalties
- Afterwood
- Overload Journal 136 - December 2016 PDF
- Overload Journal 136 - December 2016 ePub
- 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 Journal 135 - October 2016 PDF
- Overload Journal 135 - October 2016 ePub
- 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 Journal 134 - August 2016 PDF
- Overload Journal 134 - August 2016 ePub
- Editorial: Just a minute
- Some Big-Os are Bigger Than Others
- Kill the Clones
- Implementing SNAAAKE
- C++ Antipatterns
- Testing Propositions
- Afterwood
- Overload Journal 133 - June 2016 PDF
- Overload Journal 133 - June 2016 ePub
- 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 Journal 132 - April 2016 PDF
- Overload Journal 132 - April 2016 ePub
- 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 Journal 131 - February 2016 PDF
- Overload Journal 131 - February 2016 ePub
- 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 Journal 130 - December 2015 PDF
- Overload Journal 130 - December 2015 ePub
- 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 Journal 129 - October 2015 PDF
- Overload Journal 129 - October 2015 ePub
- Editorial: 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 Journal 128 - August 2015 PDF
- Overload Journal 128 - August 2015 ePub
- Editorial: 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 Journal 127 - June 2015 PDF
- Overload Journal 127 - June 2015 ePub
- 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 Journal 126 - April 2015 PDF
- Overload Journal 126 - April 2015 ePub
- Where was I?
- Non-Superfluous People:
- 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 Journal 125 - February 2015 PDF
- Overload Journal 125 - February 2015 ePub
- 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 Journal 124 - December 2014 PDF
- Overload Journal 124 - December 2014 ePub
- Editorial: Finding your muse
- Designing Observers in C++11
- Non-Superfluous People: Testers
- Ruminations on Self Employment and Running a Business
- Order Notation in Practice
- People of the .Doc
- Testing Drives the Need for Flexible Configuration
- Overload Journal 123 - October 2014 PDF
- Overload Journal 123 - October 2014 ePub
- 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 Partricle Swarm Optimisation
- Feeding Back
- Overload Journal 122 - August 2014 PDF
- Overload Journal 122 - August 2014 ePub
- 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 Journal 121 - June 2014 PDF
- Overload Journal 121 - June 2014 ePub
- 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 Journal 120 - April 2014 PDF
- Overload Journal 120 - April 2014 ePub
- Editorial: 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 Journal 119 - February 2014 PDF
- Overload Journal 119 - February 2014 ePub
- 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 Journal 118 - December 2013 PDF
- Overload Journal 118 - December 2013 ePub
- 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 Journal 117 - October 2013 PDF
- Overload Journal 117 - October 2013 ePub
- 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 Journal 116 - August 2013 PDF
- Overload Journal 116 - August 2013 ePub
- 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 Journal 115 - June 2013 PDF
- Overload Journal 115 - June 2013 ePub
- 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 Journal 114 - April 2013 PDF
- Overload Journal 114 - April 2013 ePub
- 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 Journal 113 - February 2013 PDF
- Overload Journal 113 - February 2013 ePub
- 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 Journal 112 - December 2012 PDF
- Overload Journal 112 - December 2012 ePub
- 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 Journal 111 - October 2012 PDF
- Overload Journal 111 - October 2012 ePub
- Editorial: Too Much Information
- Valgrind Part 4
- Universal References in C++11
- A DSEL for Addressing the Problems Posed by Parallel Architectures
- Keep It Simple, Singleton!
- Software Developer Business Patterns
- Overload Journal 110 - August 2012 PDF
- Overload Journal 110 - August 2012 ePub
- 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 Journal 109 - June 2012 PDF
- Overload Journal 109 - June 2012 ePub
- It’s Not What You Know, It’s Who You Know Most human endeavours are not solitary pursuits.
- 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 Journal 108 - April 2012 PDF
- Overload Journal 108 - April 2012 ePub
- 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 Journal 107 - February 2012 PDF
- Overload Journal 107 - February 2012 ePub
- Many Hands Make Light Work
- Memory Leaks and Memory Leaks
- Many Slices of Pi
- Why Computer Algebra Won’t Cure Your Calculus Blues
- The Eternal Battle Against Redundancies, Part 2
- A Practical Introduction to Erlang
- Overload Journal 106 - December 2011 PDF
- Overload Journal 106 - December 2011 ePub
- Patently Ridiculous!
- 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 Journal 105 - October 2011 PDF
- Overload Journal 105 - October 2011 ePub
- 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 Journal 104 - August 2011 PDF
- Overload Journal 104 - August 2011 ePub
- 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 Journal 103 - June 2011 PDF
- Overload Journal 103 - June 2011 ePub
- 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 Journal 102 - April 2011 PDF
- Overload Journal 102 - April 2011 ePub
- 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 Journal 101 - February 2011 PDF
- Overload Journal 101 - February 2011 ePub
- 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
- Overload Journal 100 - December 2010 PDF
- 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 Journal 99 - October 2010 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
- Overload Journal 98 - August 2010 PDF
- 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’
- Overload Journal 97 - June 2010 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 Journal 96 - April 2010 PDF
- Dealing with Growing Pains
- The Model Student: A Game of Six Integers (Part 2)
- Using Design Patterns to Manage Complexity
- The Predicate Student: A Game of Six Integers
- Bug Elimination - Defensive Agile Ruses
- A Practical, Reasoned and Inciteful Lemma for Overworked and Overlooked Loners
- Overload Journal 95 - February 2010 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
- Overload Journal 94 - December 2009 PDF
- 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 Journal 93 - October 2009 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 Journal 92 - August 2009 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 Journal 91 - June 2009 PDF
- A Good Craftsman Knows His Tools
- Floating Point Fun and Frolics
- On Management: The Business Analyst's Role
- Complexity, Requirements and Models
- 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 Journal 90 - April 2009 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 Journal 89 - February 2009 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 Journal 88 - December 2008 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 Journal 87 - October 2008 PDF
- The Invisible Hand
- Seeing Things Differently
- DynamicAny (Part 2)
- Focus, Quality, Time-boxes and Ducks
- The Model Student: Can Chance Make Fine Things? (Part 1)
- Performitis (Part 3)
- Overload Journal 86 - August 2008 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 Journal 85 - June 2008 PDF
- Plus ça change
- Performitis
- The Model Student: A Knotty Problem, Part 2
- RSA Made Simple
- Quality Manifesto
- Overload Journal 84 - April 2008 PDF
- After Four Years
- Watersheds and Waterfalls (Part 2)
- The Model Student: A Knotty Problem, Part 1
- The Way of the Consultant
- Overload Journal 83 - February 2008 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 Journal 82 - December 2007 PDF
- The Essence of Success
- The PfA Papers: Context Matters
- The Model Student
- Java Protocol Handlers
- Upgrading Legacy Software in Data Communications Systems
- Creating Awareness
- Overload Journal 81 - October 2007 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
- Overload Journal 80 - August 2007 PDF
- 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 Journal 79 - June 2007 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
- Overload Journal 78 - April 2007 PDF
- 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 Journal 77 - February 2007 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 Journal 76 - December 2006 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 Journal 75 - October 2006 PDF
- Life in the Fast Lane
- Letters
- Up Against the Barrier
- Inventing a Mutex
- C++ Unit Testing Easier: CUTE
- From CVS to Subversion
- Overload Journal 74 - August 2006 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 Journal 73 - June 2006 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 Journal 72 - April 2006 PDF
- Editorial: Doing What You Can
- Multithreading 101
- To Grin Again
- A Fistful Of Idioms
- C++ Best Practice - Designing Header Files
- Visiting Alice
- Overload Journal 71 - February 2006 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 Journal 70 - December 2005 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 Journal 69 - October 2005 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 Journal 68 - August 2005 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 Journal 67 - June 2005 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 Journal 66 - April 2005 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 Journal 65 - February 2005 PDF
- Editorial: "They" Have Their Reasons
- The Developer's New Work
- Stable Intermediate Forms
- Multiple Streams Going Nowhere
- Letters: Encapsulate Context
- From Waterfall to EVO in a Medium Size Norwegian Software House
- C++ Properties - a Library Solution
- C Abuse
- A Pair Programming Experience
- Overload Journal 64 - December 2004 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 Journal 63 - October 2004 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 Journal 62 - August 2004 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 Journal 61 - June 2004 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 Journal 60 - April 2004 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 Journal 59 - February 2004 PDF
- Editorial
- Why do requirements change?
- More is Less
- Letters to the Editor(s)
- Heretical Java #1
- From Mechanism to Method: Further Qualifications
- C++ as a Safer C
- Overload Journal 58 - December 2003 PDF
- Editorial
- From Mechanism to Method: Data Abstraction and Heterarchy
- 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 Journal 57 - October 2003 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 Journal 56 - August 2003 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 Journal 55 - June 2003 PDF
- Editorial
- Ruminations on Knowledge in Software Development
- How To Write A Loop
- From Mechanism to Method: Distinctly Qualified
- Embedded Scripting Languages
- A bin Manipulator For IOStreams
- Overload Journal 54 - April 2003 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 Journal 53 - February 2003 PDF
- Editorial
- Build Systems
- Implementing the Observer Pattern in C++ - Part 2
- From Mechanism to Method: Total Ellipse
- Indexing STL Lists With Maps
- A Return Type That Doesn’t Like Being Ignored
- C++rossword
- C++ Standards Library Report
- C++ Templates
- Overload Journal 52 - December 2002 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 Journal 51 - October 2002 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 Journal 50 - August 2002 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 Journal 49 - June 2002 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 Journal 48 - April 2002 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 Journal 47 - February 2002 PDF
- What is Boost?
- Tiny Template Tidbit
- Of Minimalism, Constructivism and Program Code
- minimalism
- Editorial: Product Definition
- Minimalist Constructive Criticism
- Introduction to WOC: Abstracting OpenGL 3-D Model Definition and Rendering with C++.
- 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: Valued Conversions
- 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
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
- Using Templates To Handle Multi-Threading
- copy_on_write_ptr
- 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
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 Journal 27 - August 1998 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 Journal 26 - June 1998 PDF
- Broadening
- Sean's Show
- Make a date with C++, A Touch of Class
- Dynamic Function Calling Using Operator Overloading
- Exploring Patterns: Part 1
- Structured Analysis: OOD’s older brother?
- Object Design and Implementation
- Broadvision: A lesson in application frameworks
- STL Implementations: Personal Experiences
- Java 1.2 and JavaScript for C and C++ Programmers
- Overload Journal 25 - April 1998 PDF
- Editorial
- Counted Body Techniques
- counted_ptr{type}
- UML - Parameterised Classes (Templates) and Utilities
- (Almost) No Casting Vote, Standard’s Report
- Generalizing Overloading for C++2000
- Irrational Behaviour
- Implementations & Interfaces
- Debuggable new and delete, Part Two
- Overload Journal 24 - February 1998 PDF
- UML - State-Transition Diagrams
- Embed with C++
- pointer{type}
- STL Algorithms: Finding
- Rational Value Comments
- Rational Values Part 3
- Protecting Member Data's Right to Privacy
- ‘There may be trouble ahead’
- editor << letters;
- Overload Journal 23 - December 1997 PDF
- UML - Objects and Patterns
- Candidates for inline
- The Casting Vote
- The Story of auto_ptr, A Cautionary Tale
- STL Vectors
- Rational Values Implementation Part 2
- A Finite State Machine Design II
- Debug new and delete, Preamble
- editor << letters;
- Overload Journal 22 - October 1997 PDF
- Editorial
- Allocation Stats
- An Introduction to the UML
- extern "X" and namespaces
- Make a date with C++ And so to const
- Premature Optimisation
- Using Algorithms-Sorting
- Rational Values Implementation Part 1
- Some Opportunities to Increase STL Efficiency
- editor << letters;
- Overload Journal 21 - August 1997 PDF
- Editorial
- Circles and Ellipses Revisited: Coding Techniques - 3
- The Casting Vote
- Getting the Best
- Safe Assignment? No Problem!
- Make a date with C++ Independence of Declaration
- Whiteboard
- inline delegation
- A Finite State Machine Design
- Object Counting
- Rational Values
- The C&C++ European Developers Forum
- They pursued it with forks and hope.
- Overload Journal 20 - June 1997 PDF
- Editorial
- Whence Objects?
- The Casting Vote
- Painting the Bicycle Shed
- Make a date with C++: Typing Lessons
- The Pitfall of Being Ignorant
- Self Assignment? No Problem!
- Lessons from fixed_vector Part 1
- Shared experience: a C++ pitfall
- Further Thoughts on Inheritance for Reuse
- Whiteboard
- editor << letters;
- Overload Journal 19 - April 1997 PDF
- Editorial
- Observations on the Design of an Address Class
- The Uses and Abuses of Inheritance
- The Problem of Self-Assignment
- Borland C++ Builder for expert programmers
- Make a date with C++: In the Beginning...
- C++ Committee Draft
- The Casting Vote
- New Keywords For...
- OOD again: Some light, some shadows
- A model for backsolving
- editor << letters;
- 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 Journal 16 - October 1996 PDF
- Editorial
- Some OOD answers
- Go with the flow - part II
- Mixing Java & C++ Ruminations
- Circles and Ellipses revisited: coding techniques - an introduction
- Why is the standard C++ library value based?
- editor << letters;
- questions->answers
- Overload Journal 15 - August 1996 PDF
- Editorial
- Some questions about OOD
- Explorations around a linked list
- Go with the flow
- So you want to be a cOOmpiler writer? - part VI
- The Casting Vote
- Making string literals constant - a cautionary tale
- Circles and ellipses revisited
- The Standard Template Library - sorted associative containers part 1 set & multiset
- The return type of member functions
- /tmp/late/* Constraining template parameter values
- editor << letters;
- Java in a Nutshell reviewed by Chris Southern
- Overload Journal 14 - June 1996 PDF
- Editorial
- Concerning values, left, right and converted
- Real world patterns
- More on Java
- The Standard Template Library - first steps auto_ptr
- Functionoids
- Return from a member function
- Time please, ladies and gentlemen
- editor << letters;
- Practical C++ Programming a response from Steve Oualline
- Overload Journal 13 - April 1996 PDF
- Editorial
- Those problems revisited
- So you want to be a cOOmpiler writer? - part V
- Simple classes - Part 4: Game of Life
- Some pitfalls of class design: a case study
- The Casting Vote
- I do not love thee, STL!
- You can’t get there from here - a closer look at input iterators
- The Standard Template Library - first steps: sequence containers
- Using STL with pointers
- /tmp/late/* Specifying integer size
- editor << letters;
- questions->answers
- Overload Journal 12 - February 1996 PDF
- Editorial
- We have a problem
- So you want to be a cOOmpiler writer? - part IV
- Compiler updates
- Notes on Microsoft Visual C++ V4.0
- A UK perspective
- An implementation pattern using RTTI
- Rot in L
- Simple classes for debugging in C++ - Part 3
- Heapwalking problems
- /tmp/late/* Constraining template parameter types
- editor << letters;
- Handling dates with locale based day and month information
- Making a date
- Overload Journal 11 - December 1995 PDF
- Editorial
- Classes and Associations
- Java? Where is that?
- The Casting Vote
- Some thoughts on linkage
- Literally yours
- Anonymously yours
- Simple classes for debugging in C++ - Part 2
- A deeper look at copy assignment
- Change of address
- /tmp/late/* Generating constants with templates
- editor << letters;
- Date with a Design
- Scientific and Engineering C++ reviewed by Sean A. Corfield
- Overload Journal 10 - October 1995 PDF
- Editorial
- Multiple inheritance in C++ - part III
- So you want to be a cOOmpiler writer? - part III
- When is an “is a” not an “is a”?
- What’s in a name?
- Addressing polymorphic types
- Simple classes for debugging in C++ - part I
- Pausing for thought
- editor << letters;
- Thinking in C++ (Bruce Eckel) reviewed by Peter Booth
- From Chaos to Classes (Daniel Duffy) reviewed by Sean A. Corfield
- Overload Journal 9 - August 1995 PDF
- Editorial
- A Better C?
- Quantum Chromo Typology
- Seduction: The Last? - Applying the STL mindset
- Joy Unconfined - reflections on three issues
- Diary of an Observer
- The Casting Vote
- Uncontained - oddities and oversights in the standard library
- Multiple inheritance in C++ - part II
- On not mixing it...again
- Another “too-many-objects” lesson
- editor << letters;
- editor << letters;
- editor << letters;
- Interview with Jiri Soukup by Roger Lever
- Design Patterns reviewed by Sean A. Corfield
- Overload Journal 8 - June 1995 PDF
- Editorial
- The case against learning C++ right now - right or wrong?
- OOA - The Shlaer-Mellor Approach
- So you want to be a cOOmpiler writer? - part II
- C++ - the official UK site maintained by Steve Rumsby
- cv-qualified constructors
- namespace - a short exposé
- Wait for me! - virtual
- Circle & Ellipse - Vicious Circles
- Circle & Ellipse - Creating Polymorphic Objects
- Having Multiple Personalities
- ‘Individual’ Control Validation in MFC
- From polymorphism to garbage collection
- A “too-many-objects” lesson
- editor << letters;
- editor << letters;
- editor << letters;
- editor << letters;
- editor << letters;
- ++puzzle;
- Writing “Industrial Strength C++”
- Overload Journal 7 - April 1995 PDF
- Editorial
- C++ compilers - mainly for OS/2
- No such thing as a free lunch
- Subsidising lunch? - a reply
- Operators - an overloaded menace
- Overloading on const and other stories
- operator= and const - a reply
- The Casting Vote
- Wait for me! - copying and assignment
- Related objects
- Related addendum
- Multiple inheritance in C++ - part I
- On not mixing it...
- editor << letters;
- editor << letters;
- editor << letters;
- editor << letters;
- editor << letters;
- editor << letters;
- editor << letters;
- Questions & Answers
- ++puzzle;
- Books and Journals
- 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
- Operators for Arithmetic Classes
- Are “Safe” Computer Systems Possible?
- The Virtual Interview
- So you want to be a cOOmpiler writer?
- Microsoft Visual C++ V1.5 (16bit)
- Borland C++ V4.0
- 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
Advertisement
