• 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]

• Jumping around in Emacs
• The Global Lockdown of Locks
• C++20: A Simple Math Module
• Agile Manchester 2020: Testers Edition
• Static Analysis in GCC and Clang
• Comment Only What The Code Cannot Say
• Some Objects Are More Equal Than Others
• Reviews
• Pass the Parcel
• Using Compile Time Maps for Sorting
• Profiting from the Folly of Others
• Adding Python 3 Compatibility to Python 2 Code
• Making a Linux Desktop – Launching Applications
• Reviews
• A line-to-line conversion from Node.js to Node.cpp
• Quick Modular Calculations(Part 2)
• Restaurant C++ and Pidgin Python
• Python has setdefault
• Static C library and GNU Make
• Reviews
• Non-Recursive Compile Time Sort
• we they do better? Cassio Neri shows they can.">Quick Modular Calculations (Part 1)
• Exodep : A Simple External Dependency Refresher
• The Standard Report
• Scenarios Using Custom DSLs
• I Come Here Not to Bury Delphi, But to Praise It
• Attitude, Accomplishment, Artistry
• Empty Scoped Enums as Strong Aliases for Integral Types
• C++ Reflection for Python Binding
• A Case for Code Reuse
• Who Are You Calling Weak?
• Do Repeat Yourself
• Use UTF-16 Interfaces to Ship Windows Code
• Building C#/.NET, Go, and Ruby Programs with libCLImate – Part 1: Ruby
• Assembly Club
• Challenges
• NullableAttribute and C# 8
• lvalues, rvalues, glvalues, prvalues, xvalues, help!
• The Duality…
• Blockchain-Structured Programming
• QM Bites: Understand Windows Operating-System Identification Preprocessor Macros
• C++ Tagged Reference Types
• When Will Python 2 End?
• Code Critique Competition 115
• Report on Challenge 5
• Algol 68 – A Retrospective
• Improve Code by Removing It
• 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
• The Ghost of a Codebase Past
• On Francis’s Challenge #4
• ACCU Standards Report
• Code Critique Competition
• Challenge 4 Report & Outlining Challenge 5
• 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
• Don’t Assume Any Non-Zero exit() Will Fail!
• Everyday Coding Habits for Safety and Simplicity
• Code Critique Competition 112
• Program Challenge Report 3 and Challenge 4
• Type-agnostic Tracing Using {fmt}
• A Short Overview of Object Oriented Software Design
• Libraries, Console Apps and GUIs
• The New C++ Interview
• Code Critique Competition 111
• No News is Good News
• 5 Reasons NOT to Use std::ostream for Human-Readable Output
• The Expressive C++ Coding Challenge in D
• Code Critique Competition 110 Part II
• CTAD – What Is This New Acronym All About?
• Functional Error-Handling with Optional and Expected
• Testing Times (Part 1)
• The Last Word in Patterns
• Implementing Type-Classes as OCaml Modules
• Afterwood
• Code Aesthetics
• A Brief Introduction to Docker
• ‘Speedy Gonzales’ Serializing (Re)Actors via Allocators
• Polymorphism in C++ – A Type Compatibility View
• C++11 (and beyond) Exception Support
• Thonny: Python IDE for Beginners
• A Glint of Ruby
• Why I Avoid PHP
• Code Critique Competition 107
• A C++ Developer Sees Rustlang for the First Time
• Portable Console I/O via iostreams
• Afterwood
• Living Within Constraints
• In Java I Wish I Could...
• Learning Other Languages
• Code Critique Competition 106
• 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
• An Ode to Code
• Myths about ‘Big Data’
• On Turnabout is Fair Play
• A Hollywood Take on Dangling Pointers?
• Code Critique Competition 105
• Space invaders in Elm
• Single Module Builds – The Fastest Heresy in Town
• (Not Really So) New Niche for C++: Browser!?
• Contractual Loopholes
• On the Defensive
• Beyond Functional Programming: Manipulate Functions with the J Language
• 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
• A Case of Mistaken Identity
• Turnabout is Fair Play
• A Class What I Wrote
• Kate Gregory: An Interview
• Code Critique Competition 103
• The MirAL Story
• Overloading with Concepts
• Ultra-fast Serialization of C++ Objects
• Modern C++ Features: User-Defined Literals
• Python Streams vs Unix Pipes
• Hello World in Go
• Afterwood
• Commit Checklist
• On High Rollers
• A Commoner’s Response
• Determinism: Requirements vs Features
• Eight Rooty Pieces
• Polymorphic Comparisons
• C++ Synchronous Continuation Passing Style
• Attacking Licensing Problems with C++
• Home-Grown Tools
• Why Floats Are Never Equal
• Smarter, Not Harder
• An Introduction to OpenMP
• Random Confusion
• High Rollers
• Standards Report
• Some Big-Os are Bigger Than Others
• Kill the Clones
• Implementing SNAAAKE
• C++ Antipatterns
• Testing Propositions
• Testing Private
• The Codealow
• Debugging – What Has Changed in the Last Decade?
• Code Critique Competition 100
• 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
• Encryption
• Come Code With Me
• On Fifteen Love
• Standards Report
• Code Critique Competition 99
• The Tao of Scratch
• Knowledge-Sharing Architects As An Alternative to Coding Architects
• QM Bites: Understand Windows OS Identification Preprocessor Macros
• 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
• Sliding Window Filters : A Set-based Implementation
• An Open Question (or How I Learned To Stop Worrying And Love Public Wi-Fi)
• Groovy and Grails eXchange 2015
• Fifteen Love
• Using Clara to Parse Command Lines in C++
• Software Development Is...
• 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?
• Bug Hunting
• Finding Text
• in vivo, in vitro, in silico
• "HTTPS Everywhere" considered harmful
• 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
• Bug Hunting
• Building C & C++ CLI Programs with the libCLImate Mini-framework
• Raspberry Pi Linux User Mode GPIO in C++ (Part 3)
• One Definition Rule
• Functional Programming in C++
• Code Critique Competition 96
• Introducing Concepts
• Building and Running Software on an Ubuntu Phone
• Password Hashing: Why and How
• An Inline-variant-visitor with C++ Concepts
• Refactoring Guided by Duplo
• Ode to the BBDB
• Anatomy of a CLI Program written in C++
• The Cat’s Meow
• Raspberry Pi Linux User Mode GPIO in C++ (Part 2)
• Standards Report
• Code Critique Competition 95
• 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
• Are we nearly there yet? Refactoring C++
• Golang programming on AppEngine
• Split and Merge Revisited
• 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
• Wallowing in Filth
• Writing Good C++ APIs
• Split and Merge – Another Algorithm for Parsing Mathematical Expressions
• Using 32-bit COM Objects from 64-bit Programs
• Raspberry Pi Linux User Mode GPIO in C++ – Part 1
• Standards Report
• Code Critique Competition 93
• 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
• Using ACCU Membership for Unique IDs
• LAMP on Ubuntu
• The Developer’s Sandbox
• Simple Android programming with WebKit
• Raspberry Pi Linux User Mode GPIO in Python
• Code Critique Competition 92
• Standards Report
• Best Practices vs Witch Hunts
• Making a Tool of Deception
• Modern C++ Testing
• I Like Whitespace
• Faking C Function with fff.h
• Letter to the Editor
• Simplicity Through Immutability
• Advice for the Young at Heart
• Delayed Copy Pattern
• Const and Concurrency (part 2)
• Non-Superfluous People: Testers
• Designing Observers in C++11
• Order Notation in Practice
• Testing Drives the Need for Flexible Configuration
• Const and Concurrency (Part 1)
• Parsing Configuration Files in C++ with Boost
• Perl is a Better Sed, and Python 2 is Good
• Debuggers Are Still For Wimps
• Debug Complexity: How Assertions Affect Debugging Time
• Alternative Overloads
• Everyone Hates build.xml
• Defining Visitors Inline in Modern C++
• Paper Bag Escapology Using Particle Swarm Optimisation
• Does Test-Driven Development Harm Clarity?
• Musings on Python – by a C++ Developer
• Activatable Object
• KISSing SOLID Goodbye
• TDD Discussions and Disagreements
• Branching Strategies
• Beauty in Code
• The Code Is Not the Most Important Thing
• Stop the Constant Shouting
• Minimal Overhead for Multiple Interfaces
• 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
• 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
• 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
• Code as a Crime Scene
• 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
• Hard Upper Limit on Memory Latency
• Simple Instrumentation
• Portable String Literals in C++
• Dynamic C++ (Part 2)
• Auto – a necessary evil? (Part 2)
• 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
• 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
• ‘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
• 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
• 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!
• 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
• 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
• 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
• 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
• Memory Leaks and Memory Leaks
• Many Slices of Ï€
• Why Computer Algebra Won’t Cure Your Calculus Blues
• The Eternal Battle Against Redundancies, Part 2
• A Practical Introduction to Erlang
• The Eternal Battle Against Redundancies, Part I
• RAII is not Garbage
• Why Polynomial Approximation Won't Cure Your Calculus Blues
• Concurrent Programming with Go
• 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
• Over-Generic Use of Abstractons as a Major Cause of Wasting Resources
• Thread-Safe Access Guards
• An Introduction to Test Driven Development
• Why [Insert Algorithm Here] Won’t Cure Your Calculus Blues
• Some Objects Are More Equal Than Others
• Exception Specifications in C++ 2011
• Why Interval Arithmetic Won’t Cure Your Floating Point Blues
• The ACCU 2011 Crypto Challenge
• Benefits of Well Known Interfaces in Closed Source Code
• Why Computer Algebra Won’t Cure Your Floating Point Blues
• Refactoring and Software Complexity Variability
• Queue with Position Reservation
• Why Rationals Won’t Cure Your Floating Point Blues
• Overused Code Reuse
• From Occam's Razor to No Bugs' Axe
• Why Fixed Point Won't Cure Your Floating Point Blues
• Interface Versioning in C++
• Quality Matters Christmas Intermezzo
• You're Going To Have To Think!
• To DLL or Not To DLL
• Making String ReTRIEval Fast
• Quality Matters #6: Exceptions for Practically-Unrecoverable Conditions
• The Model Student: The ACCU 2010 Crypto Challenge
• Debugging Run Time Memory Problems
• The ANSI Standard For C
• Defining New Data Types In C++
• Notes from the Ultra-Conservative Right Wing
• Debugging with the Macro Processor
• Commenting programs, how and why
• Everything You Wanted To Know About C ......
• Structure, Part 2
• Everything You Wanted To Know About C ......
• An introduction to ADVSYS
• Structure, Part 1
• Adventures In C
• Scalable Graph Coverage
• Single-Threading: Back to the Future?
• The Functional Student: A Game of Six Integers
• The Predicate Student: A Game of Six Integers
• 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)
• Shadow Data Types
• Creating a Framework for the iPhone
• The Model Student: A Primal Skyline (Part 3)
• The Model Student: A Primal Skyline (Part 2)
• Multi-threading in C++0x
• I Think I'll Parse
• Quality Matters: Introductions, and Nomenclature
• Code Rot
• Floating Point Fun and Frolics
• Complexity, Requirement and Modules
• An Introduction to FastFormat (Part 3): Solving Real Problems, Quickly
• Boiler Plating Database Resource Cleanup (Part 2)
• Testing State Machines
• The Model Student: A Rube-ish Square (Part 2)
• An Introduction to FastFormat (Part 2): Custom Argument and Sink Types
• Through The Looking Glass
• Orderly Termination of Programs
• An Introduction to Fast Format (Part 1): The State of the Art
• Model View Controller with Java Swing
• The Legion's Revolting!
• Iterators and Memberspaces
• Generics without Templates - Revisited
• Seeing Things Differently
• DynamicAny (Part 2)
• DynamicAny, Part I
• Globals, Singletons and Parameters
• Exceptions Make for Elegant Code
• The Model Student: A Knotty Problem, Part 2
• Watersheds and Waterfalls (Part 2)
• The Model Student: A Knotty Problem, Part 1
• Watersheds and Waterfalls
• Testing Visiting Files and Directories in C#
• Generics Without Templates
• C++0x An Overview
• Functional Programming Using C++ Templates (Part 2)
• Java Protocol Handlers
• Software Product Lines
• Code Generation Network
• The PfA Papers: The Clean Dozen
• Functional Programming Using C++ Templates (Part 1)
• auto_value: Transfer Semantics for Value Types
• He Sells Shell Scripts to Intersect Sets
• Release Mode Debugging
• auto_value: Transfer Semantics for Value Types
• The Policy Bridge Design Pattern
• Continuous Integration with CruiseControl.Net
• Working with GNU Export Maps
• auto_value: Transfer Semantics for Value Types
• 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
• Programming - Abstraction by Design
• C++ Trivial Logger
• FRUCTOSE - a C++ Unit Test Framework
• Letter to the Editor
• Pooled Lists
• The Singleton in C++ - A force for good?
• C++ Interface Classes - Strengthening Encapsulation
• Inventing a Mutex
• C++ Unit Testing Easier: CUTE
• From CVS to Subversion
• Comments Considered Good
• Introducing CODEF/CML
• Fine Tuning for lexical_cast
• C# Generics - Beyond Containers of T
• The Kohonen Neural Network Library
• 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
• Multithreading 101
• To Grin Again
• A Fistful Of Idioms
• C++ Best Practice – Designing Header Files
• Visiting Alice
• Boost C++ Libraries
• STLFilt
• Effective STL Example Source Code
• C++ Archive
• Scott Meyers
• Lisp
• Accelerated C++
• Don Knuth's Home Page
• WTL Quick Reference
• WTL
• Subversion
• Compilers and Compiler Generators
• Perl
• PHP Resource Center
• KDB (Built-in Kernel Debugger)
• Blitz
• Microsoft Press Books
• Microsoft Visual C++
• Microsoft Developers Network
• Andrei Alexandrescu
• Cross-Referencing Linux
• Linux Assembly
• Building and Testing gcc/glibc cross toolchains
• Apache Tomcat
• Apache Struts
• Apache Maven
• Apache Lucene
• Logging Services Project @ Apache
• Apache Gump
• Excalibur
• Apache Ant
• JSP Taglibs
• Jakarta Slide
• Jakarta Regexp
• Jakarta POI
• Jakarta-ORO
• Java Caching System
• Element Construction Set
• Cactus
• Bean Scripting Framework
• BCEL
• Turbine
• Velocity
• Jakarta Commons
• Tapestry
• Hive Mind
• The Apache Jakarta Project
• LinuxMM
• Haskell
• GCC online documentation
• GCC Home Page
• Trolltech Online Reference Documentation
• KDE 3.0 API Reference
• Java Technology Articles by Category
• Java Tech Tips
• Java Technology
• The GNOME development site.
• Borland Developer Network
• The development of the C language
• The C Programming Language
• The Practise of Programming
• Objective Caml
• The Caml Language
• BitKeeper configuration management system.
• Borland C++Builder Devlopers Journal
• The Decompilation Wiki
• Soft Documentation
• Dead Code
• Friend or Foe!
• Recursive Make Considered Harmful
• Let's Do C# and MySQL - Part 2 - A Beginning
• Two-thirds of a Pimpl and a Grin
• The Curate's Wobbly Desk
• "Here be Dragons"
• Better Encapsulation for the Curiously Recurring Template Pattern
• db4objects - Innovating Object Databases with Open Source
• Pointer Reversal: An Algorithm Design Technique
• Let's Do C# and MySQL - Part 1 - MySQL
• J2SE 5.0 New Features
• With Spirit
• Polynomial Classes
• Incremental Design: A Case Study of a Compiler
• A Framework for Generating Numerical Test Data
• Transactions with Delegates in C#
• Sharp as C
• Qt 4.0 is Out!
• Investigating Java Class Loading
• C-side Re-sort
• C++ Interface Classes - Noise Reduction
• A Technique for Register Access in C++
• Welcome to the Wonderful World of Porting!
• Silas's Corner
• New Container Classes in Qt 4
• Introduction to Tcl/Tk: Part 2
• The Trial of the Reckless Coder
• Taming Complexity: A Class Hierarchy Tale
• Microsoft Symbol Engine
• Separating Interface and Implementation in C++
• Overload Resolution - Selecting the Function
• Metaprogramming is Your Friend
• Digging a Ditch
• I Wish Programming Was Easy Again
• Using Qt's Non-GUI Classes
• Introduction to Tcl/Tk
• Forgetting the ABC
• An Introduction to Objective-C
• Multiple Streams Going Nowhere
• C++ Properties - a Library Solution
• C Abuse
• Wx - A Live Port - Part 3
• Patterns in C - Part 1
• Memory For a Short Sequence of Assignment Statements
• Elephant - A C++ Memory Observer
• An Introduction to Programming with GTK+ and Glade in ISO C and ISO C++ - Part 4
• An Introduction to Objective-C
• Mini-project to Decode A Mini-language - Part Two
• An Experience Report on Implementing a Custom Agile Methodology on a C++/Python Project
• Wx - A Live Port
• ">Writing Custom Widgets in Qt
• What's in a Namespace?
• An Introduction to Programming with GTK+ and Glade in ISO C and ISO C++ - Part 3
• An Introduction to Objective-C
• Wx - A Live Port
• ">Rapid Dialog Design Using Qt
• Introduction to STL (Standard Template Library)
• An Introduction to Programming with GTK+ and Glade - Part 2
• An Introduction to Objective-C
• 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
• XML as a Model-View-Controller System for Documents
• Introduction to C# - Part 2
• Creating Standard GUI Applications
• C++ Templates - A Simple Example
• An Introduction to Programming with GTK+ and Glade in ISO C and ISO C++
• An Introduction to Objective-C
• The Curious Case of the Compile-Time Function
• ACCU Mentored Developers XML Project
• Letters to the Editor
• Handling Exceptions in finally
• C++ Interface Classes - An Introduction
• A Template Programmer's Struggles Revisited
• Introduction To C#
• Going GUI with Qt
• Functional Programming in Python: An Introduction by Example
• When is a "Pattern" not a "Pattern"?
• The Tale of a Struggling Template Programmer
• Lvalues and Rvalues
• Efficient Exceptions?
• A Template Programmer’s Struggles Resolved
• Transforming XML with XSLT
• From Mechanism to Method: Generic Decoupling
• All Heap No Leaks
• Achieving FitNesse in C++
• A Little Detail
• Writing Maintainable Code
• I_mean_something_to_somebody, Part Two
• Francis' Scribbles
• http://www.ecma-international.org/publications/standards/Ecma-335.htm.
  ">C++/CLI, Ecma TC39/TG5,and SC22/WG21
• A Python Script to Relocate Source Trees
• There is more to life than increasing its speed” - Mahatma Gandhi

  We live in a fast food culture. Not only must our dinner arrive yesterday, our car should be fast, and our entertainment instant. Our code should also run like lightning. I want my result. And I want it now.

  Ironically, writing fast programs takes a long time.

  Optimisation is a spectre hanging over software development, as W.A. Wulf observed. “More computing sins are committed in the name of efficiency (without necessarily achieving it) than for any other single reason – including blind stupidity”.

  It’s a well-worn subject, with plenty of trite soundbites bounding around, and the same advice being served time and time again. But despite this, a lot of code is still not developed sensibly. Programmers get sidetracked by the lure of efficiency and write bad code in the name of performance.

  In these articles we’ll address this. We’ll tread some familiar ground and wander well-worn paths, but look out for some new views on the way. Don’t worry – if the subject’s optimisation it shouldn’t take too long...

  ">Professionalism in Programming #24
• do...while loop? It just does something while some condition holds. End of story, right?

  No, of course not. That would make the title of this small article silly, so let’s cover two topics.

  ">do...while
• Letters to the Editor(s)
• From Mechanism to Method:
• C++ as a Safer C
• Example 0

  for (Surfaces::iterator sf = surfaces.begin();
       sf != surfaces.end();
       ++sf) {
    // std::cout << "Drawing: " << *sf << "\n";
    sf->draw();
  }

  OK, I’m being disingenuous. I’m aware that the comment isn’t really a comment, it’s commented-out code. And, like any tolerant and capable programmer, by examining the surrounding context I can guess why this code has been commented out.

  This article examines how to comment out code, then describes various problems which lead to code being commented out, before finally arguing that there’s often a better solution to these problems.

  ">Code in Comments
• Comment on “Problem 11”
• Student Code Critique Competition 26
• Maintaining Context for Exceptions (Alternative)
• BRACKETS OFF!
• From Mechanism to Method:
• Choosing Template Parameters
• CheckedInt: A Policy-Based Range-Checked Integer
• A More Flexible Container
• Copy on Write
• Combining the STL with SAX and XPath for Effective XML Parsing
• Statically Checking Exception Specifications
• Software As Read
• Single Exit
• Error and Exception Handling
• Chaos Theory
• A Policy-Driven CORBA Template Library to Facilitate the Rapid Development of DOC Middleware
• Mixing Strings in C++
• Maintaining Context for Exceptions
• A Polygon Seed Fill Algorithm
• Quick Guide to MinGW (GCC for Windows)
• Stream-Based Parsing in C++
• Learning C++: A Student's Perspective
• Intrusive Identifiers
• Generating Lists for C++ in Python
• A Python project (2)
• How To Write A Loop
• From Mechanism to Method
• Embedded Scripting Languages
• A bin Manipulator For IOStreams
• Non-Standard Code
• A Python Project
• 10 Things You Always Wanted to Know About Assert (But Were Afraid to Ask)
• Implementing the Bridge pattern using templates with Microsoft Visual C++ 6.0
• EXPR_TYPE - An Implementation of typeof Using Current Standard C++
• Addendum to "Tiny Template Tidbit"
• A C++ Petri Net Framework For Multithreaded Programming
• 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
• Implementing the Observer Pattern in C++ - Part 1
• From Mechanism to Method - Good Qualifications
• File Format Conversion Using Templates and Type Collections
• XML Parsing with the Document Object Model
• What is a Hash Table?
• Enlarging on "A Problem of Access" in C Vu December 2001 Volume 13 Number 6
• 4DML Revisited
• Pairing Off Iterators
• Mutate? or Create?
• Exception Handling in C#
• Some Personal Reflections on C++ and Java
• My First Steps in Java Web Development
• Examining C++
• A Little String Thing
• Template Metaprogramming: Shifting Down a Gear
• STL-style Circular Buffers By Example
• Even More Java Exceptions
• Alternatives for Partial Template Function Specialisation
• Applied Reading - Taming Shared Memory
• Developing a C++ Unit Testing Framework
• Programming with Interfaces in C++
• More Exceptional Java
• An Overview of C#.NET
• Introduction to XML and C++
• The C++ Template Argument Deduction
• Template Titbit - A Different Perspective
• From Mechanism to Method - Function Follows Form
• Exceptional Java
• C++ Exceptions and Linux Dynamic Libraries
• ">If Problems Arise
• Applying OO to C
• What is Boost?
• Tiny Template Tidbit
• Introduction to WOC:
• String Comparison with Wild Characters.
• Template Metaprogramming
• Techniques for Debugging in C++
• Metaclasses and Reflection in C++ - Part 2
• Summing Arrays
• An Introduction to Personal Java
• minimalism
• Metaclasses and Reflection in C++
• Introduction to C++ Templates
• Introducing JUnit
• A Little Class
• Using Version Control
• String Tokenization - A Programmer's Odyssey
• Porting (part 2) - Addressing the Differences
• Flexible Functors and Binders
• Designing C++ Interfaces - Templates
• Are You Afraid of The Dark Too? Making More Sense of the STL
• What Is Swing?
• 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
• What Is Swing?
• Some Thoughts on Java
• Getting Started with J2EE
• Typesafe Registry for Windows
• Multimethods
• Editor << letters;
• Editor << letters;
• Compile Time Indirection - An Unusual Template Technique
• C++ Idioms: First Thoughts
• A Generic Non-intrusive Smart Pointer Implementation
• A Deeper Look at Inline Functions
• Members' Experiences
• Gotcha(); // describe some bugs
• Ada Overview - Part 2
• Editorial
• Where is __FUNCTION__?
• Thread Pooling: An Investigation
• Extensibility - A Reason For Using Streams in C++
• Questions and Answers
• Swamp Fever
• Ada Overview - Part 1
• Here be Dragons
• From Mechanism to Method
• Questions and Answers
• OOD and Testing using the Dependency Inversion Principle
• User Defined Types: Qualities, Principles and Archetypes.
• Include Files
• From Mechanism to Method: Substitutability
• C++ Patterns Source Cohesion and Decoupling
• Undefined vs. Implementation Defined
• Building the Board (part II)
• Supporting Threads in Standard C++ (Addendum)
• Intuitive Multi-Paradigm Design:
• A Fistful Of Idioms - Giving STL Iterators a Base Class
• ">What's An Implerface?
• Servlets
• Reading Integers Revisited
• Reading C & C++ Variable Declarations
• Java Parameter Semantics
• ISO 8601: A Standard You Should Know About
• Building the Board
• editor << letters;
• Supporting Threads in Standard C++ (Part 3)
• A framework for object serialization in C++
• Questions and Answers
• Mostly Comments
• Java Q & A
• Building the Hexes
• An Introduction to Fuzzy Logic
• Adding Enumerators
• A Tale of Old Java
• Supporting Threads in Standard C++ (Part 2)
• An Implementation of Double Dispatch in Java
• An Application of Pointers to Members
• Questions and Answers
• Reading Integers
• Pure, functional, lazy ISBNs
• Buffer Overflows and the Standard C Library
• Adding Polymorphic Classes to the Anthem 'threads' Model
• Standard C++
• Exceptions - Guidance
• Error handling and logging
• Automatic Object Versioning for Forward and Backward File Format Compatibility
• Questions & Answers
• Learning Standard C++ as a New Language
• operator == ()
• counted_ptr<type> revisited
• Static vs Member Functions
• Exception Errors
• Debug new and delete Part 3
• Data Attribute Notation - Part 2
• A Delphic Experience
• Notes on Exceptions
• Exception Usage
• Editor << letters;
• Controlling access to objects by using private interfaces
• Broadvision - Part 3
• Object (low-level) Design and Implementation
• Hotel Case Study Comments
• editor << letters;
• Uncounted pointers in C++
• SAX - A Simple API for XML
• Exceptions - The Details
• File Positioning
• Anonymous Code Exercise Rewrite
• The Journey is a reduction of the postings to accu-general compiled every month. ACCU general provides an opportunity for members to discuss, share, educate and be educated.
  ">The Journey
• Seductive Tips
• Questions & Answers
• Members Experiences
• If your going to use it, learn it!
• We very rarely publish material that is not original. However I thought that readers might enjoy this item from one of the great programmers of any time. Please note that this was first presented 25 years ago. I think it is worth reflecting on what we have and have not learnt since.
  ">1974 ACM Turing Award Lecture
• Hotel Case Study Comments
• Exploring Patterns Part 2
• More threading with templates
• More cow_ptr<type> Ruminations
• Exceptions - The Basics
• Coping with Copying in C++
• Syntax v Semantics Part 1
• ISBN Numbers
• Compile Time Assertions in C Revisited
• COMMENTS- A Personal Perspective
• An Exercise - Source unknown
• The EPOC C++ API
• Ruminations on Studying Design Patterns
• Micro-Derivation & Related Ideas
• A Review of cow_ptr<type>
• What's In a Struct?
• Pointers in Hyperspace
• Compile Time Assertions in C Revisited
• Code Review - A Big Number Class
• A Software Probe
• Using Templates To Handle Multi-Threading
• copy_on_write_ptr<type>
• Thoughts on Functoids
• Fitting in with multiple frameworks in C++ and Java
• Software Development with Java User Interfaces II
• Questions & Answers
• More Thoughts About Hungarian Notation
• Java Style & Idioms : exceptions are fun
• Compile Time Assertions in C
• Being Silly?
• All You Need to Know About enums
• Write to Learn
• Overloading Operators
• Exception Handling Alternatives
• Data Attribute Notation - Part 3
• An Eventful Story
• A Letter from Ken Hagan annotated by The Harpist
• Naming Conventions for Spoken Readability
• Multithreading (2)
• ">Java Style & Idioms
• Software Development with Java User Interfaces
• Multithreading
• Java Idioms
• Hungarian Notation- Another View
• Close Encounters with Internationalisation
• Life Stories
• A Little Bit of Humour for a Monday Morning
• The uses and abuses of inheritence
• 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)
• Understanding Windows (9)
• String Theory
• MSDOS Interrupts
• Understanding Windows (8)
• String Theory
• Software Engineers Toolbox
• Sets a-la Pascal
• Increase your Program's Execution Speed?
• 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 Casting Vote
• 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
• Minimising Stack Use and Other Uses of new
• C++ Strings -The ANSI Way
• Custom Controls
• Windows File Class
• Unit Testing Of C++ Classes
• Uses of Classes with only Private and Protected Constructors
• A Short Exposure to C++
• C++ Streams (Part 2)
• Class Struggle
• The Help Compiler
• Some Thoughts on the Use of New
• C++ Streams
• Make...or Break?
• Templates
• An Introduction to Object Orientation
• Class Struggle
• Dates & Times
• Starting out with OWL
• Whingeing Session

Project Management  (95)

• The Ethical Programmer
• Coding Accountability
• Afterwood
• An Interview Icebreaker
• Are we nearly there yet?
• Ruminations on Self Employment and Running a Business
• On the Other Side of the Barricade: Job Interviewer Do’s and Don’ts
• Software Developer Business Patterns
• Moving with the Times
• The Guy We’re All Working For
• What motivates software developers: a workshop report
• "I'm a Business Analyst - Get Me Out Of Here"
• Renovating a Legacy C++ Project
• Socially Responsible Recruitment
• On Management: The Business Analyst's Role
• Software Development in the 21st Century
• On Management: Product Managers
• WRESTLE: Aggressive and Unprincipled Agile Development in the Small
• On Management: Caveat Emptor
• On Management: Understanding Who Creates Software
• On Management: Focus, Quality, Time-boxes and Ducks
• Performitis (Part 3)
• On Management
• Quality Manifesto
• Creating Awareness
• Managing Technical Debt
• Effective Software Testing
• Atlantic Systems Guild
• Open Source Development with CVS, 3rd Edition
• The Risks Digest
• The Agile Manifesto Explained (and a First Amendment)
• Setting up a Subversion Server for Remote Use
• Editorial: Size Does Matter
• Becoming and Being Agile
• Software Project Management: Adding Stakeholder Metrics to Agile Projects
• Professionalism in Programming #32
• Are Certificates Worth the Paper they are Written On?
• "The C++ Community" - Are We Divided by a Common Language?
• Grain Storage MIS: A Failure of Communications (27 March 1998)
• Editorial: Need to Unlearn
• Sheep Farming for Software Development Managers
• Automatically Generating Word Documents
• A Subversion Primer
• The Developer's New Work
• 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
• A Pair Programming Experience
• Memory for a Short Sequence of Assignment Statements
• Blue Fountain Systems - An Open Source Company
• Where Egos Dare
• Editorial
• Letters to the Editor(s)
• Why do requirements change?
• An Alternative View of design (and planning)
• A Standard Individual: A Licensed Engineer
• Editorial
• Is IT worth it?
• On Not Being a Software Engineer
• Three Phantastic Tales
• EuroPLoP 2003 Conference Report
• Ruminations on Knowledge in Software Development
• Software development and the learning organisation
• Labouring: An Analogy
• Extendable Software and the Bigger Picture
• Editorial - Software Quality
• Building Java Applications
• Thinking about "reuse"
• Editorial
• How to Raise the Dead
• Editorial: Product Definition
• How about a Turner Prize for software?
• Using CVS (A Beginner's Guide)
• A Personal View: Computing Anywhere
• In Defense of Sys Admins
• From the Coalface
• Editorial
• .NET
• Editorial
• Members' Experiences
• To Certify or not to Certify?
• Thinking Aloud
• Some Thoughts on Academic Papers
• editorial: Concerning Patents
• Pros and Cons of Contracting
• Editorial
• Visual Control and COM
• In Response to Extreme Programming
• What Use is a Degree?
• Iteractive Development - Prologue
• eXtreme Programming An interview with Kent Beck
• File Headers
• So Your Code is NOT Critical?
• Recent Interview Experiences (and Other Gripes)
• From the Coalface
• Exception Discussion
• A Message from the ACCU Chair
• From the Academic Coalface
• Religious Issues
• From the Academic Coalface
• C minus

• Design +

• Making a Linux Desktop
• Piping Software for Less
• An Example Confined User Shell
• The Standard Report
• Refocusing Amdahl’s Law
• Expect the Unexpected (Part 1)
• What Is Your Name?
• Quick Modular Calculations (Part 3)
• Deconstructing Inheritance
• It’s About Time
• The Standard Report
• The Path of Least Resistance
• A Secure Environment for Running Apps?
• Afterwood
• Making a Linux Desktop: Painting Some Wallpaper
• OOP Is not Essential
• C++ Pipes
• Making a Linux Desktop
• A Low-Latency Logging Framework
• On IT and... CO₂ Footprints
• Modern SAT solvers: fast, neat and underused (part 1 of N)
• The Simple Life
• 5 Big Fat Reasons Why Mutexes Suck Big Time
• A Small Universe
• A Small Universe Part II
• A Thorough Introduction to Distributed Systems
• Don’t Use std::endl
• China’s New AI School Textbooks
• 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
• Measuring Throughput and the Impact of Cache-line Awareness
• Afterwood
• Write Less Code!
• The Half-Domain/Half-Primitive Proxy
• How to Write a Programming Language: Part 1, The Lexer
• Writing a Wayland Server Using Mir
• Monitoring: Turning Noise into Signal
• The Interface to Component Pattern and DynaMix
• Practical Cryptographical Theory for Programmers
• A Wider Vision of Software Development
• An MWSR Queue with Minimalist Locking
• Testing: Choose the Right Level
• C++ with Meta-classes?
• Practical Scale Testing
• Visualisation of Multidimensional Data
• Programmers’ Puzzles
• CAS (Re)Actor for Non-Blocking Multithreaded Primitives
• A Design Example
• Evolutionary Computing Frameworks for Optimisation
• Marking Benches
• A New Competition
• A Usable C++ Dialect that is Safe Against Memory Corruption
• Metaclasses: Thoughts on Generative C++
• A Functional Alternative to Dependency Injection in C++
• Rip It Up and Start Again
• Non-Superfluous People: UX Specialists
• Does Test-Driven Development Harm Clarity?
• KISSing SOLID Goodbye
• TDD Discussions and Disagreements
• Object-Environment Collision Detection using Onion BSPs
• YAGNI-C as a Practical Application of YAGNI
• Has the Singleton Not Suffered Enough
• C++ Range and Elevation
• Executable Documentation Doesn’t Have To Slow You Down
• Systems Thinking Software Development
• Rise of the Machines
• Quality Matters Christmas Intermezzo
• You're Going To Have To Think!
• To DLL or Not To DLL
• Renovating a Legacy C++ Project
• Single-Threading: Back to the Future? (Part 2)
• Quality Matters: The Worst Form of 'Error' Handling Except For All The Others
• Scalable Graph Coverage
• Single-Threading: Back to the Future?
• The Model Student: A Game of Six Integers (Part 3)
• The Functional Student: A Game of Six Integers
• The Model Student: A Game of Six Integers (Part 2)
• Using Design Patterns to Manage Complexity
• The Predicate Student: A Game of Six Integers
• The Model Student: A Game of Six Integers (Part 1)
• Quality Matters: Diagnostic Measures
• Quality Matters: Diagnostic Measures (Listings)
• Creating a Framework for the iPhone
• Project-Specific Language Dialects
• The Generation, Management and Handling of Errors (Part 2)
• I Think I'll Parse
• Quality Matters: Introductions, and Nomenclature
• The Model Student: A Primal Skyline (Part 1)
• The Generation, Management and Handling of Errors (Part 1)
• Complexity, Requirement and Modules
• An Introduction to FastFormat (Part 3): Solving Real Problems, Quickly
• Testing State Machines
• If You Can't See Me, I Can't See You
• The Model Student: A Rube-ish Square (Part 2)
• An Introduction to FastFormat (Part 2): Custom Argument and Sink Types
• Through The Looking Glass
• The Model Student: A Rube-ish Square (Part 1)
• An Introduction to Fast Format (Part 1): The State of the Art
• The Model Student: Can Chance Make Fine Things? (Part 2)
• Model View Controller with Java Swing
• The Legion's Revolting!
• Iterators and Memberspaces
• Generics without Templates - Revisited
• Seeing Things Differently
• DynamicAny (Part 2)
• The Model Student: Can Chance Make Fine Things? (Part 1)
• DynamicAny, Part I
• Performitis - Part 2
• Globals, Singletons and Parameters
• Exceptions Make for Elegant Code
• Divide and Conquer: Partition Trees and Their Uses
• Performitis
• The Model Student: A Knotty Problem, Part 2
• RSA Made Simple
• Watersheds and Waterfalls (Part 2)
• The Model Student: A Knotty Problem, Part 1
• Watersheds and Waterfalls
• The PfA Papers: Deglobalisation
• The Regular Travelling Salesman, Part 2
• The PfA Papers: Context Matters
• The Model Student
• Upgrading Legacy Software in Data Communications Systems
• The PfA Papers: The Clean Dozen
• Functional Programming Using C++ Templates (Part 1)
• auto_value: Transfer Semantics for Value Types
• The PfA Papers: From the Top
• auto_value: Transfer Semantics for Value Types
• The Policy Bridge Design Pattern
• Software Product Line Engineering with Feature Models
• A Perspective on Use of Conditional Statements versus Assertions
• Design in Test-Driven Development
• C++ Unit Test Frameworks
• A Practical Form of OO Layering
• Programming - Abstraction by Design
• Exceptional Design
• The Singleton in C++ - A force for good?
• C++ Interface Classes - Strengthening Encapsulation
• The Rise and Fall of Singleton Threaded
• James O. Coplien
• Test Driven Development of C# User Interfaces
• ">Debuggers Should Go Backwards
• Cryptographic Mistakes Made in Programming
• A Reflection on Defensive Programming
• Patterns in C - Part 5: REACTOR
• Vorsprung Durch Testing
• Patterns in C - Part 4: OBSERVER
• Patterns in C - Part 3: Strategy
• Can C++ Learn from Generics in Ada?
• Metaprogramming is Your Friend
• Patterns in C - Part 2: State
• Stable Intermediate Forms
• Yet Another Hierarchical State Machine
• Evolution of the Observer Pattern
• From Mechanism to Method: The Safe Stacking of Cats
• More is Less
• Heretical Java #1
• I_mean_something_to_somebody
• An Alternative View of design (and planning)
• SINGLETON - the anti-pattern!
• Reshaping an Old Piece of Design
• A Unified Singleton Framework
• Members' experiences
• The Nature and Aesthetics of Design
• Observer Pattern Implementation
• Exported Templates
• Organising Source Code
• STL-style Circular Buffers By Example, Part Two
• Patterns Collaborations: Observer and Composite
• An Introduction to 4DML
• The Philosophy of Extensible Software
• Execute Around Method and Proxy Goulash
• Writing Extendable Software
• The scoping problem
• A Short History of Character Sets
• Porting part 3 :
• What is Boost?
• Of Minimalism, Constructivism and Program Code
• minimalism
• Minimalist Constructive Criticism
• Modelling and Software Development
• Metaclasses and Reflection in C++
• Designing C++ Interfaces - Templates
• C++ Standards - The "swap" Problem
• Experiences of Implementing the Observer Design Pattern (Part 3)
• Source Code Modules and Layering
• A Touch Of Abstraction
• Programming with Interfaces in C++
• More Include File Rules
• Interpreting "Supporting the 'Cheshire Cat' Idiom"
• Experiences of Implementing the Observer Design Pattern (Part 2)
• The Pet Project (part 4)
• Experiences of Implementing the Observer Design Pattern (Part 1)
• XML in Applications II DOM - the Document Object Model
• The Pet Project - Monopoly (Part 3)
• An Implementation of Double Dispatch in Java
• My Pet Project Monopoly 2
• Shallow Pointer
• Exploring Patterns 3 - The Adapter
• Exceptions & Exception Specifications
• XML
• When's an object not an object?
• The Diary of Bridget Jones the Weekend Before OT
• Software Architecture
• My Pet Project - Monopoly
• Error logging and patterns
• UML Interactions & Collaborations
• Self Registering Classes - Taking polymorphism to the limit
• Broadvision - Part 2
• The State Pattern - A New Implementation
• The Journey - from accu.general May 1999
• Polymorphism In Object-Oriented Languages
• Builder & Factory Method Patterns
• BroadVision, Part 4
• A Simple Model for Object Persistence Using the Standard Library
• Response To "Patterns - The Abstract Factory" (Francis Glassborow, Overload 30)
• Objects In Databases
• Factories in C++: Disposing of the Product
• Exception Handling Alternatives (Part 2)
• Impression of C++ for Embedded Systems
• UML Relationships and Associations, Aggregation and Composition
• Patterns - The Abstract Factory
• Garbage Collection Implementation Considerations
• Exception Handling Alternatives
• Abstraction, Syntax, Intent
• Waterfall versus RAD
• Almost a Pattern
• Caught in the pattern web
• Windows Waffle
• Run-time checking for C++
• C++ Strings -The ANSI Way
• Managing Class Coupling
• Class Struggle
• An Introduction to Object Orientation
• Rumbaugh's OMT - The method behind C++ Designer
• Some Thoughts on Writing Classes

Internet Topics  (35)

• Afterwood
• When Will Python 2 End: An Update
• Diving into the ACCU Website
• ‘HTTPS Everywhere’ Less Harmful Now
• Why I Don’t Develop for iOS
• How to Stay Out of a Webmaster’s Bad Books
• GitHub’s Crazy Contribution-Graph Game
• One SSH Key Per Machine!
• Planet Code
• Open Source – And Still Deceiving Programmers
• How to Block Russia From Your Website (and why you might want to)
• Inspirational (P)articles: Use the DOM Inspector
• Web Annotation with Modified-Yarowsky and Other Algorithms
• Implementing drop-down menus in pure CSS (no JavaScript)
• Apache Week
• The Apache Software Foundation
• Java Lobby
• Apache Portals
• Apache James Mail and News Server
• JMeter
• How to Quantify Quality: Finding Scales of Measure
• When Worlds Collide 2 - Circuit Switch Telephony and Packet Switch Networks
• Tracking Exceptions in Web Services with GUIDs
• Patterns in the Web
• I Wish They'd Use the Standard
• Editorial
• Editorial
• Conference: ACM CHI 2001
• Editorial
• An Introduction to CGI Programming
• Beyond ACCU... Patterns on the 'net
• Beyond ACCU... Java on the 'net
• Beyond ACCU... Patterns on the 'net
• Beyond ACCU
• Web Sites to Review
• Web Sites to Review
• Sources on the Internet
• Home, Home on the Web...
• Security Implications of Running a Web Gateway
• Onward to American Online...
• Common Gateway Interface Program Testing

Process Topics  (83)

• The Standards Report
• A Thorough Introduction to Apache Kafka
• Expect the Unexpected (Part 2)
• Greenback Backup
• The Trouble with GitHub Forks
• Afterwood
• Thoughts on ‘Computational Thinking’
• The Standard Report
• A Day in the Life of a Full-Stack Developer
• Afterwood
• The Refactor Part of TDD – Reducing to the Min with FizzBuzz
• A Case Against the Use of Code ‘Smells’
• Afterwood
• Avoid Stagnation
• Afterwood
• Effective Software Testing
• DIY Technical Authoring
• Afterwood
• Don’t Brush Bugs Under The Carpet
• To Mob, Pair, or Fly Solo
• A Guide to Group Decision Making
• Afterwood
• Testing Times (Part 2)
• Getting Personal
• Afterwood
• Afterwood
• Navigating a Route
• The Path of the Programmer
• About the C++ Core Guidelines
• Afterwood
• I Can't Think Fast Enough in a Coding Interview
• Be Available, Not Busy
• The Importance of Back-of-Envelope Estimates
• Speak Up! (Part 2)
• A Case of Mistaken Identity
• How Do You Read?
• Speak Up!
• Delivering Bad News from QA
• Smarter, Not Harder
• Whiteboards
• Organised Chaos
• Why Collaboration is Key for QA Teams in an Agile World
• The Very Model of a Model Modern Programmer
• The Cat’s Meow
• Writing a Technical Book
• What Do People Do All Day?
• Standards Report
• Playing By The Rules
• Taming the Inbox
• Standards Report
• A Scheduling Technique for Small Software Projects and Teams
• Feeding Back
• Branching Strategies
• Lies, Damn Lies and Estimates
• The Uncertainty Principle
• Software Developer Business Patterns
• The Virtual Interview
• Moving with the Times
• From the Age of Power to the Age of Magic and beyond...
• Integrating Testers Into An Agile Team
• Systems Thinking Software Development
• The Agile Spectrum
• On CMM, Formalism and Creativity
• Despair Programming
• The Agile 10 Steps Model
• Bug Hunting and the Scientific Method
• From Occam's Razor to No Bugs' Axe
• Bug Elimination - Defensive Agile Ruses
• Quality Matters: A Case Study in Quality
• Quality Matters: Correctness, Robustness and Reliability
• Software Development in the 21st Century
• Measurable Value with Agile
• On Management: Focus, Quality, Time-boxes and Ducks
• Performitis (Part 3)
• Future Workers (Prototype)
• Creating Awareness
• Software Product Lines
• Blue-White-Red, an Example Agile Process
• Live and Learn with Retrospectives
• Continuous Integration with CruiseControl.Net
• Up Against the Barrier
• The Documentation Myth
• Pair Programming Explained
• How to Shoot Yourself in the Foot. In an Agile Way.

C Vu Volume 32 Issue 4 PDF

Overload 158 PDF

C Vu Volume 32 Issue 3 PDF

Overload 157 PDF

C Vu Volume 32 Issue 2 PDF

Overload 156 PDF

C Vu Volume 32 Issue 1 PDF

Overload 155 PDF

C Vu Volume 31 Issue 6 PDF

Overload 154 PDF

C Vu Volume 31 Issue 5 PDF

Overload 153 PDF

C Vu Volume 31 Issue 4 PDF

Overload 152 PDF

C Vu Volume 31 Issue 3 PDF

Overload 151 PDF

C Vu Volume 31 Issue 2 PDF

Overload 150 PDF

C Vu Volume 31 Issue 1 PDF

Overload 149 PDF

C Vu Volume 30 Issue 6 PDF

Overload 148 PDF

C Vu Volume 30 Issue 5 PDF

Overload 147 PDF

C Vu Volume 30 Issue 4 PDF

Overload 146 PDF

C Vu Volume 30 Issue 3 PDF

Overload 145 PDF

C Vu Volume 30 Issue 2 PDF

Overload 144 PDF

C Vu Volume 30 Issue 1 PDF

Overload 143 PDF

C Vu Volume 29 Issue 6 PDF

Overload 142 PDF

C Vu Volume 29 Issue 5 PDF

Overload 141 PDF

C Vu Volume 29 Issue 4 PDF

Overload 140 PDF

C Vu Volume 29 Issue 3 PDF

Overload 139 PDF

C Vu Volume 29 Issue 2 PDF

Overload 138 PDF

C Vu Volume 29 Issue 1 PDF

Overload 137 PDF

C Vu Volume 28 Issue 6 PDF

Overload 136 PDF

C Vu Volume 28 Issue 5 PDF

Overload 135 PDF

C Vu Volume 28 Issue 4 PDF

Overload 134 PDF

C Vu Volume 28 Issue 3 PDF

Overload 133 PDF

C Vu Volume 28 Issue 2 PDF

Overload 132 PDF

C Vu Volume 28 Issue 1 PDF

Overload 131 PDF

C Vu Volume 27 Issue 6 PDF

Overload 130 PDF

C Vu Volume 27 Issue 5 PDF

Overload 129 PDF

C Vu Volume 27 Issue 4 PDF

Overload 128 PDF

C Vu Volume 27 Issue 3 PDF

Overload 127 PDF

C Vu Volume 27 Issue 2 PDF

Overload 126 PDF

C Vu Volume 27 Issue 1 PDF

Overload 125 PDF

C Vu Volume 26 Issue 6 PDF

Overload 124 PDF

C Vu Volume 26 Issue 5 PDF

Overload 123 PDF

C Vu Volume 26 Issue 4 PDF

Overload 122 PDF

C Vu Volume 26 Issue 3 PDF

Overload 121 PDF

C Vu Volume 26 Issue 2 PDF

Overload 120 PDF

C Vu Volume 26 Issue 1 PDF

Overload 119 PDF

C Vu Volume 25 Issue 6 PDF

Overload 118 PDF

C Vu Volume 25 Issue 5 PDF

Overload 117 PDF

C Vu Volume 25 Issue 4 PDF

Overload 116 PDF

C Vu Volume 25 Issue 3 PDF

Overload 115 PDF

C Vu Volume 25 Issue 2 PDF

Overload 114 PDF

C Vu Volume 25 Issue 1 PDF

Overload 113 PDF

C Vu Volume 24 Issue 6 PDF

Overload 112 PDF

C Vu Volume 24 Issue 5 PDF

Overload 111 PDF

C Vu Volume 24 Issue 4 PDF

Overload 110 PDF

C Vu Volume 24 Issue 3 PDF

Overload 109 PDF

C Vu Volume 24 Issue 2 PDF

Overload 108 PDF

C Vu Volume 24 Issue 1 PDF

Overload 107 PDF

C Vu Volume 23 Issue 6 PDF

Overload 106 PDF

ACCU magic

C Vu Volume 23 Issue 5 PDF

Overload 105 PDF

C Vu Volume 23 Issue 4 PDF

Overload 104 PDF

C Vu Volume 23 Issue 3 PDF

Overload 103 PDF

C Vu Volume 23 Issue 2 PDF

Overload 102 PDF

C Vu Volume 23 Issue 1 PDF

Overload 101 PDF

C Vu Volume 22 Issue 6 Erratum PDF

C Vu Volume 22 Issue 6 PDF

Overload 100 PDF

C Vu Volume 22 Issue 5 PDF

Overload 27 PDF

Overload 26 PDF

Overload 25 PDF

Overload 24 PDF

Overload 23 PDF

Overload 22 PDF

Overload 21 PDF

Overload 20 PDF

Overload 19 PDF

Overload 16 PDF

Overload 15 PDF

Overload 14 PDF

Overload 13 PDF

Overload 12 PDF

Overload 11 PDF

Overload 99 PDF

C Vu Volume 22 Issue 4 PDF

Overload 98 PDF

C Vu Volume 22 Issue 3 PDF

C Vu Volume 1 Issue 3 PDF

Overload 97 PDF

C Vu Volume 22 Issue 2 PDF

Overload 96 PDF

C Vu Volume 22 Issue 1 PDF

Overload 10 PDF

Overload 9 PDF

Overload 95 PDF

Overload 8 PDF

Overload 7 PDF

C Vu Volume 21 Issue 6 PDF

C Vu Volume 1 Issue 5 PDF

C Vu Volume 1 Issue 4 PDF

Overload 94 PDF

C Vu Volume 21 Issue 5 PDF

Overload 93 PDF

C Vu Volume 21 Issue 4 PDF

Overload 92 PDF

C Vu Volume 21 Issue 3 PDF

Overload 91 PDF

C Vu Volume 21 Issue 2 PDF

Overload 90 PDF

C Vu Volume 21 Issue 1 PDF

Overload 89 PDF

C Vu Volume 20 Issue 6 PDF

Overload 88 PDF

C Vu Volume 20 Issue 5 PDF

Overload 87 PDF

C Vu Volume 20 Issue 4 PDF

Overload 86 PDF

C Vu Volume 20 Issue 3 PDF

Overload 85 PDF

C Vu Volume 20 Issue 2 PDF

Overload 84 PDF

Overload 83 PDF

C Vu Volume 20 Issue 1 PDF

C Vu Volume 19 Issue 6 PDF

Overload 82 PDF

C Vu Volume 19 Issue 5 PDF

Overload 81 PDF

Overload 80 PDF

C Vu Volume 19 Issue 4 PDF

C Vu Volume 1 Issue 2 PDF

Overload 79 PDF

C Vu Volume 19 Issue 3 PDF

C Vu Volume 1 Issue 1 PDF

C Vu Volume 19 Issue 2 PDF

Overload 78 PDF

CVu 18 2 PDF

Overload 77 PDF

CVu 19.1 PDF

CVu 18.6 PDF

Overload 76 PDF

CVu V14 6 PDF

CVu V14 5 PDF

CVu V14 4 PDF

CVu V18 5 PDF

CVu V18 4 PDF

CVu V18 3 PDF

CVu V18 1 PDF

CVu V17 6 PDF

CVu V17 5 PDF

CVu V17 4 PDF

CVu V17 3 PDF

CVu V17 2 PDF

CVu V17 1 PDF

CVu V16 6 PDF

CVu V16 5 PDF

CVu V16 4 PDF

CVu V16 3 PDF

CVu V16 2 PDF

CVu V16 1 PDF

CVu V15 6 PDF

CVu V15 5 PDF

CVu V15 4 PDF

CVu V15 3 PDF

CVu V15 2 PDF

CVu V15 1 PDF

Overload 75 PDF

Overload 74 PDF

Overload 73 PDF

Overload 72 PDF

Overload 71 PDF

Overload 70 PDF

Overload 69 PDF

Overload 68 PDF

Overload 67 PDF

Overload 66 PDF

Overload 65 PDF

Overload 64 PDF

Overload 63 PDF

Overload 62 PDF

Overload 61 PDF

Overload 60 PDF

Overload 59 PDF

Overload 58 PDF

Overload 57 PDF

Overload 56 PDF

Overload 55 PDF

Overload 54 PDF

Overload 53 PDF

Overload 52 PDF

Overload 51 PDF

Overload 50 PDF

Overload 49 PDF

Overload 48 PDF

Overload 47 PDF

Overload 158 ePub

C Vu Volume 32 Issue 3 ePub

Overload 157 ePub

C Vu Volume 32 Issue 2 ePub

Overload 156 ePub

C Vu Volume 32 Issue 1 ePub

Overload 155 ePub

C Vu Volume 31 Issue 6 ePub

Overload 154 ePub

C Vu Volume 31 Issue 5 ePub

Overload 153 ePub

C Vu Volume 31 Issue 4 ePub

Overload 152 ePub

C Vu Volume 31 Issue 3 ePub

Overload 151 ePub

C Vu Volume 31 Issue 2 ePub

Overload 150 ePub

C Vu Volume 31 Issue 1 ePub

Overload 149 ePub

C Vu Volume 30 Issue 6 ePub

Overload 148 ePub

Overload 131 ePub

Overload 132 ePub

Overload 133 ePub

Overload 134 ePub

Overload 135 ePub

Overload 136 ePub

Overload 137 ePub

Overload 138 ePub

Overload 139 ePub

C Vu Volume 30 Issue 5 ePub

Overload 147 ePub

Overload 144 ePub

Overload 143 ePub

Overload 142 ePub

Overload 141 ePub

Overload 140 ePub

C Vu Volume 30 Issue 4 ePub

C Vu Volume 29 Issue 1 ePub

C Vu Volume 29 Issue 2 ePub

C Vu Volume 29 Issue 3 ePub

C Vu Volume 29 Issue 4 ePub

C Vu Volume 29 Issue 5 ePub

C Vu Volume 29 Issue 6 ePub

C Vu Volume 30 Issue 1 ePub

C Vu Volume 30 Issue 2 ePub

Overload 145 ePub

Overload 146 ePub

C Vu Volume 30 Issue 3 ePub

Making a Linux Desktop
Description : Alan Griffiths adds support for shell components to the desktop environment. by Alan Griffiths
Category: [ CVu Journal Vol 32, #4 - September 2020 | Design of applications and programs ]

Piping Software for Less
Description : Paul Grenyer continues his mission to build a DevOps pipeline on a budget. by Paul Grenyer
Category: [ CVu Journal Vol 32, #4 - September 2020 | Design of applications and programs ]

An Example Confined User Shell
Description : Snap confinement is not just for individual apps but can be applied to a complete GUI environment. Alan Griffiths demonstrates with the Mircade shell. by Alan Griffiths
Category: [ Overload Journal #158 - August 2020 | Design of applications and programs ]

The Standard Report
Description : Guy Davidson reports on the latest developments. by Guy Davidson
Category: [ CVu Journal Vol 32, #3 - July 2020 | Design of applications and programs ]

Refocusing Amdahl’s Law
Description : Parallelising code can make it faster. Lucian Radu Teodorescu explores how to get the most out of multi-threaded code. by Lucian Radu Teodorescu
Category: [ Overload Journal #157 - June 2020 | Design of applications and programs ]

Expect the Unexpected (Part 1)
Description : Pete Goodliffe looks into dealing with the inevitable. by Pete Goodliffe
Category: [ CVu Journal Vol 32, #2 - May 2020 | Design of applications and programs ]

What Is Your Name?
Description : Simon Sebright considers the importance of names as identification. by Simon Sebright
Category: [ CVu Journal Vol 32, #2 - May 2020 | Design of applications and programs ]

Quick Modular Calculations (Part 3)
Description : This article concludes the 3-part series. Cassio Neri presents a new algorithm that also works for 64-bit operands. by Cassio Neri
Category: [ Overload Journal #156 - April 2020 | Design of applications and programs ]

Deconstructing Inheritance
Description : Inheritance can be overused. Lucian Radu Teodorescu considers how it can go wrong and the alternatives. by Lucian Radu Teodorescu
Category: [ Overload Journal #156 - April 2020 | Design of applications and programs ]

It’s About Time
Description : How easy is it to make code wait for a time period before doing something? Mike Crowe looks at ways to avoid problems when a system clock changes. by Mike Crowe
Category: [ Overload Journal #156 - April 2020 | Design of applications and programs ]

The Standard Report
Description : Guy Davidson reports from the C++ Standards Committee. by Guy Davidson
Category: [ CVu Journal Vol 32, #1 - March 2020 | Design of applications and programs ]

The Path of Least Resistance
Description : Python’s modules and imports can be overwhelming. Steve Love attempts to de-mystify the process. by Steve Love
Category: [ Overload Journal #155 - February 2020 | Design of applications and programs ]

A Secure Environment for Running Apps?
Description : Getting apps from the app store is easy. Alan Griffiths considers this from a security perspective. by Alan Griffiths
Category: [ Overload Journal #155 - February 2020 | Design of applications and programs ]

Afterwood
Description : We are aware of the film Get Carter. Chris Oldwood asks if it should be called Acquire Carter instead. by Chris Oldwood
Category: [ Overload Journal #154 - December 2019 | Design of applications and programs ]

Making a Linux Desktop: Painting Some Wallpaper
Description : Alan Griffiths continues his series on coding with the Mir library. by Alan Griffiths
Category: [ CVu Journal Vol 31, #5 - November 2019 | Design of applications and programs ]

OOP Is not Essential
Description : People tend to love or hate Object Oriented Programming. Lucian Teodorescu considers a recent OOP claim.
Category: [ Overload Journal #153 - October 2019 | Design of applications and programs ]

C++ Pipes
Description : Expressive code can make life easier. Jonathan Boccara demonstrates fluent pipelines for collections in C++. by Jonathan Boccara
Category: [ Overload Journal #153 - October 2019 | Design of applications and programs ]

Making a Linux Desktop
Description : Alan Griffiths illustrates how to get started with Mir. by Alan Griffiths
Category: [ CVu Journal Vol 31, #4 - September 2019 | Design of applications and programs ]

A Low-Latency Logging Framework
Description : Logging can be a bottleneck in systems. Wesley Maness and Richard Reich demonstrate a low-latency logging framework that avoids common problems. by Wesley Maness & Richard Reich
Category: [ Overload Journal #152 - August 2019 | Design of applications and programs ]

On IT and... CO₂ Footprints
Description : Recent headlines declare a climate emergency. Sergey Ignatchenko considers how we can make an impact on IT’s carbon footprint. by Sergey Ignatchenko
Category: [ Overload Journal #151 - June 2019 | Design of applications and programs ]

  |<   <<   1   2   3   4   5   6   7   8   9   10   >>   >|