Advertisement
Advertisement
Membership
Login
ACCU Buttons
Add them to your site:
| Browse in : | > Journals > Overload > 72 |
- 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... CO2 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
• 72
+
- 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]
- ACCU: The Early Days (Part 2)
- ACCU – The Early Days (Part 1)
- Learning Other Languages
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Student Code Critique Competition 27
- Francis' Scribbles
- Repository of Projects
We need to program in order to develop our programming skills. Anything more than the most trivial program takes time and effort. Most students (in the broadest sense of someone who is studying) find it hard to motivate themselves with projects whose end product is of little use or interest to them. It is much easier to put in the hours doing a job properly if the result is something we have a personal interest in.
">Francis’ Scribbles - Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Francis' Scribbles
- Experiences of Graphic Role Playing Games
- Time for Change
- Members' Experiences
- Surreal Numbers
- Relish the Challenge
- Code Aesthetics
- Dictionary and Thesaurus
- Coding Dinosaurs
- EuroLLVM Conference 2015
- Code Club
- Coders Causing Conflict
- Seb Rose: An Interview
- Professionalism in Programming #35
- Professionalism in Programming #34
- Professionalism in Programming #33
- Professionalism in Programming #31
- Professionalism in Programming #30
- Professionalism in Programming #29
- Professionalism in Programming #28
- Professionalism in Programming #27
- Professionalism in Programming #26
- Professionalism in Programming #25
- 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 - Professionalism in Programming #23
- Professionalism in Programming #22
- Professionalism in Programming #21
- Professionalism in Programming #20
- Professionalism in Programming #19
- Professionalism in Programming #16
- Professionalism in Programming #15
- Professionalism in Programming #14
- Professionalism in Programming #13
- Professionalism in Programming #12
- Professionalism in Programming #11
- Professionalism in Programming #10
- Professionalism in Programming #9
- Professionalism in Programming #8
- Professionalism in Programming #7
- Professionalism in Programming Part 6
- Professionalism in Programming #5
- Professionalism in programming Part 4
- Professionalism in programming Part 3
- Professionalism in programming
- Professionalism in Programming Part 1
- Code Critique Competition 125
- Further Comments on Code Critique 123
- Code Critique Competition 124
- Code Critique Competition 123
- Code Critique Competition 122
- Code Critique Competition 121
- Code Critique Competition 120
- Code Critique Competition 119
- Code Critique Competition 118
- Beyond Code Criticism
- Code Critique Competition 117
- Code Critique Competition 116
- Code Critique Competition 115
- Code Critique Competition 114
- Code Critique Competition
- Code Critique Competition 112
- Code Critique Competition 111
- Code Critique Competition 110 Part II
- Code Critique Competition 110
- Code Critique Competition 109
- Code Critique Competition 108
- Code Critique Competition 107
- Code Critique Competition 104
- Code Critique Competition 102
- Code Critique Competition 100
- Code Critique Competition 100
- Code Critique Competition 98
- Code Critique Competition 97
- Code Critique Competition 94
- Code Critique Competition 92
- Code Critique Competition 90
- Student Code Critique Competition 37
- Student Code Critique Competition 36
- Student Code Critique Competition 35
- Student Code Critique Competition 34
- Student Code Critique Competition 33
- Student Code Critique Competition 32
- Student Code Critique Competition 31
- Student Code Critique Competition 30
- Student Code Critique Competition 29
- Student Code Critique Competition 28
- Student Code Critique Competition 26
- Student Code Critique Competition
- Student Code Critique Competition
- Student Code Critique Competition
- Student Code Critique Competition
- Student Code Critique Competition
- Student Code Critique Competition
- Student Code Critique Competition
- Student Code Critique Competition
- Student Code Critique Competition
- Student Code Critique
- Student Code Critique Competition 13
- Student Code Critique Competition 12
- Student Code Critique Competition 11
- Student Code Critique Competition 10
- Student Code Critique Competition
- Student Code Critique Competition
- Student Code Critique Competition 6
- Student Code Critique Competition 5
- Student Code Critique Competition
- Student Code Critique Competition
- Student Code Critique Competition
- Student Code Critique
- Student Code Critique Competition
- Code Review
- Code Critique Competition
- Questions & Answers
- A Code Critique
- A Code Review
• Editorial
+
- Optimal
- RE:Purpose FWD:Thinking
- More than a label
- Rainclouds and Olive Branches
- The Story of Code
- R.E.S.P.E.C.T.
- Imaginary friends
- Members and Remembrances
- On not doing anything
- Inside-Out
- Sympathy for the Devil
- Predictions and Predilections
- Afterwood
- This is only a test
- Reactive or Proactive
- WRITEME
- How Hard Can It Be?
- Full Nine Yards
- This means war!
- Nobody Does It Better
- Rip It Up and Start Again
- Editorial: Usefulness Versus Complexity
- Revolution, Restoration and Revival
- Editorial: Precious Metals
- Are we nearly there yet?
- Editorial: Precision Engineered
- Should I Lead by Example?
- Editorial: Into Gold
- Automate all the things
- Editorial: And another thing...
- Deeds not words
- Editorial: On Being Lazy
- Hapaxes, Singletons and Anomalies
- Editorial: Know It All
- Too Fast! Too slow! Too right!!
- Editorial: Fiction
- This way up!
- Editorial: The art of laziness
- Gnomes and Misnomers
- Editorial: It's written, that's why
- I am not a number
- Editorial: Production legacy
- Breadth First, Depth First, Test First
- Editorial: Unnecessary complexity
- Editorial: The Uncertainty Guidelines
- Editorial: No obvious deficiencies
- Editorial: The Font of Wisdom
- Editorial: Necessary technology
- Editorial: Ain’t that the truth?!
- Editorial: The integrated developer
- Editorial: Just a minute
- Editorial: Fixed fixation
- Editorial: Metrics and Imperialism
- More Than One
- Editorial: Where Does All The Time Go?
- Cross Polinated
- Editorial: Be lucky
- Editorial: Choose your mask
- Editorial: Reduce, reuse, recycle
- Editorial: Selective ignorance
- Failure is an option
- Developing programs
- Semi-automatic Weapons
- Editorial: What is a user interface?
- Editorial: A little more conversation, a little less action
- Editorial: In Between
- Editorial: Where was I?
- Editorial: Private Funding
- Editorial: FUD – Fear, uncertainty and doubt
- Editorial: A Mutual Understanding
- Editorial: Finding your muse
- Editorial: Community Service
- Editorial: Peer Reviewed
- Editorial: Shop ’til you Drop
- Editorial: Very small or very far away:A sense of perspective
- Your Life in Their Hands
- The Ecumenical Programmer
- Editorial: Random (non)sense
- Editorial: Not So Much a Program, More a Way of Life
- Editorial: Decisions, Decisions
- Editorial: Learning Fantasy Languages
- Editorial: Fantasy Languages
- Editorial: Knitting Needles and Keyboards
- Editorial: The Good, The Bad and The Discordant
- Editorial: Originally, Overload Didn’t Have an Editorial
- Editorial: Too Much Information
- Editorial: Allow Me To Introduce Myself
- Editorial: It’s Not What You Know, It’s Who You Know
- Afterword
- Editorial: The Computing Revolution Will Be Televised (Again)
- Editorial: Many Hands Make Light Work
- Editorial: Patently Ridiculous!
- Editorial: A Journey Through History
- Editoral: Rise of the Machines
- Editorial: Can you keep a secret?
- Editorial: This Year’s Model
- Editorial: Ah! The fog is lifting!
- Numbers and The Appliance of Science
- Lies, Damn Lies, and Statistics
- A Little Learning Is A Dangerous Thing
- Editorial
- Editorial
- Editorial
- The Art of the Possible
- Dealing with Growing Pains
- Back To The Future
- A Crack in Time
- All together now.
- Moments in History
- A Good Craftsman Knows His Tools
- Back to School
- Watt's going on?
- The Sweet Smell of Success
- The Invisible Hand
- It's good to talk...
- Plus ça change
- After Four Years
- When Things Go Wrong
- The Essence of Success
- While the Cat's Away...
- Consensus
- Guidelines for Contributors
- Rip It Up and Start Again
- New Tricks for an Old Dog
- The Power of Inertia
- How Overload Comes to You
- Life in the Fast Lane
- Take a Step Forward
- Editorial
- Editorial: Doing What You Can
- Editorial: Keeping Up Standards
- Editorial
- Editorial: The "Safe C++ Standard Library"
- Editorial
- Editorial: Can We Change For The Better?
- Editorial
- Editorial: Size Does Matter
- Editorial
- Editorial: Does all this help make better software?
- Editorial: Need to Unlearn
- Editorial
- Editorial: "They" Have Their Reasons
- Editorial
- Editorial: A Glimpse Behind the Scenes
- Editorial
- Editorial: The Buzzword Adoption Pattern?
- Editorial
- Editorial: The Value of What You Know
- Editorial
- Editorial: New Things Under the Sun
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial - On Writing
- Editorial
- Editorial - Software Quality
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial - Coming Home
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- editorial: Concerning Patents
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- editorial
- Editorial
- editorial
- Editorial
- editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Editorial
- Civic Duty
- Editorial
- Goodbye Overload
- Editorial
- The Proposal from Centaur Communications Ltd
- Editorial
- Editorial Comment on Behalf of ACCU Committee
- Editorial
- Editorial
- Editor's Ramble
- Epilogue
- Editor's Ramble
- Epilogue
- Editor's Ramble
- Epilogue
- Editor's Ramble
- Epilogue
- Letters to the Editor
- Letter to the Editor
- ACCU Conference 2019: Reports
- Letters to the Editor
- A Magical New World?
- Letter
- Letter to the Editor
- Letter to the Editor
- Letter to the Editor
- Letters
- Commenting programs, how and why
- The Italian Connection
- Letter to the Editor
- Letter to the Editor
- Letters to the Editor
- Letter to the Editor
- Letters
- Letter to the Editor
- Comments
- Comments
- Letters to the Editor
- Letter to the Editor
- Letters: Encapsulate Context
- Letters to the Editor
- Letters to the Editor
- Letters to the Editor
- Letters to the Editor
- Letter to the Editor
- Letters to the Editor
- Letters to the Editor
- Letters to the Editor
- Letters: Software’s No Different...
- Letters: The Invisibility of Software Design
- Letters: Software Project Management Classics?
- Letters to the Editor(s)
- Letters to the Editor(s)
- Letter to the Editor
- Letters to the Editor(s)
- Letters to the Editor(s)
- Letters to the Editor(s)
- Letter to the Editor(s)
- Letters to the Editor
- Letters to the Editor
- Letters to the Editor
- Letters to the Editor
- Letters to the Editor
- Letters to the Editor
- The Wall
- The Wall
- The Wall
- The Wall
- Letter To The Editor
- The Wall
- The Wall - Your Letters etc.
- The Wall - Your Letters etc.
- The Wall - Your Letters etc.
- Members' Experiences
- Editor << letters;
- Editor << letters;
- Your Letters - The Editor's Replies
- Your Letters - The Editor's Replies
- Your Letters - The Editor's Replies
- Your Letters - The Editor's Replies
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- editor << letters;
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- A Response to the C++ SIG Organiser
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- The Wall
- Editor << letters;
- editor << letters;
- You Write, the Editor Replies
- You Write, the Editor Replies
- You Write, the Editor Replies
- You Write, the Editor Replies
- You Write, the Editor Replies
- editor << letters;
- You Write, The Editor Replies
- You Write, The Editor Replies
- Questions & Answers
- You Write - The Editor Replies
- editor << letters;
- You Write - The Editor Responds
- Questions & Answers
- Comments on Hungarian Type Notations
- Questions & Answers
- You Write - The Editor Replies
- Readers Letters
- Readers Letters
- Members' Letters
Editorial
Description : A few words from the editor. by Phil J. Stubbington
Category: [ CVu Journal Vol 1, #1 - Oct 1987 | Journal Editorial ]
Description : A few words from the editor. by Phil J. Stubbington
Category: [ CVu Journal Vol 1, #1 - Oct 1987 | Journal Editorial ]
The Art of the Possible
Description : In polite company you should never talk about religion or politics. Ric Parkin makes an exception. by Ric Parkin
Category: [ Overload Journal #97 - June 2010 | Journal Editorial ]
Description : In polite company you should never talk about religion or politics. Ric Parkin makes an exception. by Ric Parkin
Category: [ Overload Journal #97 - June 2010 | Journal Editorial ]
Dealing with Growing Pains
Description : Expanding your team is never easy. Ric Parkin experiences the recruiting process. by Ric Parkin
Category: [ Overload Journal #96 - April 2010 | Journal Editorial ]
Description : Expanding your team is never easy. Ric Parkin experiences the recruiting process. by Ric Parkin
Category: [ Overload Journal #96 - April 2010 | Journal Editorial ]
Back To The Future
Description : The last decade has seen huge changes. Ric Parkin looks at technology and its effects. by Ric Parkin
Category: [ Overload Journal #95 - February 2010 | Journal Editorial ]
Description : The last decade has seen huge changes. Ric Parkin looks at technology and its effects. by Ric Parkin
Category: [ Overload Journal #95 - February 2010 | Journal Editorial ]
A Crack in Time
Description : Encoding messages has a long history. Ric Parking looks back at how this affected computing. by Ric Parkin
Category: [ Overload Journal #94 - December 2009 | Journal Editorial ]
Description : Encoding messages has a long history. Ric Parking looks back at how this affected computing. by Ric Parkin
Category: [ Overload Journal #94 - December 2009 | Journal Editorial ]
All together now.
Description : Can you do several things at once? Ric Parkin tries multi-tasking. by Ric Parkin
Category: [ Overload Journal #93 - October 2009 | Journal Editorial ]
Description : Can you do several things at once? Ric Parkin tries multi-tasking. by Ric Parkin
Category: [ Overload Journal #93 - October 2009 | Journal Editorial ]
Moments in History
Description : Technology shapes our world. Ric Parkin looks back at 40 years of change. by Ric Parkin
Category: [ Overload Journal #92 - August 2009 | Journal Editorial ]
Description : Technology shapes our world. Ric Parkin looks back at 40 years of change. by Ric Parkin
Category: [ Overload Journal #92 - August 2009 | Journal Editorial ]
A Good Craftsman Knows His Tools
Description : Are you using the right ones? Ric Parkin looks in his toolbox... by Ric Parkin
Category: [ Overload Journal #91 - June 2009 | Journal Editorial ]
Description : Are you using the right ones? Ric Parkin looks in his toolbox... by Ric Parkin
Category: [ Overload Journal #91 - June 2009 | Journal Editorial ]
Back to School
Description : Much is made of the Knowledge Economy. But just how can you keep up to date? by Ric Parkin
Category: [ Overload Journal #90 - April 2009 | Journal Editorial ]
Description : Much is made of the Knowledge Economy. But just how can you keep up to date? by Ric Parkin
Category: [ Overload Journal #90 - April 2009 | Journal Editorial ]
Watt's going on?
Description : Just how much power are you using... by Ric Parkin
Category: [ Overload Journal #89 - February 2009 | Journal Editorial ]
Description : Just how much power are you using... by Ric Parkin
Category: [ Overload Journal #89 - February 2009 | Journal Editorial ]
The Sweet Smell of Success
Description : If your last project wasn't successful, you're not alone... by Ric Parkin
Category: [ Overload Journal #88 - December 2008 | Journal Editorial ]
Description : If your last project wasn't successful, you're not alone... by Ric Parkin
Category: [ Overload Journal #88 - December 2008 | Journal Editorial ]
The Invisible Hand
Description : Large groups can behave as one, but how predicatable are they? by Ric Parkin
Category: [ Overload Journal #87 - October 2008 | Journal Editorial ]
Description : Large groups can behave as one, but how predicatable are they? by Ric Parkin
Category: [ Overload Journal #87 - October 2008 | Journal Editorial ]
It's good to talk...
Description : Writing code is only part of developing software. by Ric Parkin
Category: [ Overload Journal #86 - August 2008 | Journal Editorial ]
Description : Writing code is only part of developing software. by Ric Parkin
Category: [ Overload Journal #86 - August 2008 | Journal Editorial ]
Plus ça change
Description : Our job titles seem to be dictated as much by fashion as by anything else. Does it matter? It does to some. Oh, and Overload has a new editor. by Ric Parkin
Category: [ Overload Journal #85 - June 2008 | Journal Editorial ]
Description : Our job titles seem to be dictated as much by fashion as by anything else. Does it matter? It does to some. Oh, and Overload has a new editor. by Ric Parkin
Category: [ Overload Journal #85 - June 2008 | Journal Editorial ]
After Four Years
Description : After four years as editor of Overload it is time for a change. by Alan Griffiths
Category: [ Overload Journal #84 - April 2008 | Journal Editorial ]
Description : After four years as editor of Overload it is time for a change. by Alan Griffiths
Category: [ Overload Journal #84 - April 2008 | Journal Editorial ]
When Things Go Wrong
Description : Can we reduce the pain of computer problems? by Roger Orr
Category: [ Overload Journal #83 - Feb 2008 | Journal Editorial ]
Description : Can we reduce the pain of computer problems? by Roger Orr
Category: [ Overload Journal #83 - Feb 2008 | Journal Editorial ]
The Essence of Success
by Alan Griffiths
Category: [ Overload Journal #82 - Dec 2007 | Journal Editorial ]
by Alan Griffiths
Category: [ Overload Journal #82 - Dec 2007 | Journal Editorial ]
While the Cat's Away...
Description : ...instead of spending your time playing, why not learn to be multi-lingual in a multi-cultural world? by Ric Parkin
Source : Editorial
Category: [ Overload Journal #81 - Oct 2007 | Journal Editorial ]
Description : ...instead of spending your time playing, why not learn to be multi-lingual in a multi-cultural world? by Ric Parkin
Source : Editorial
Category: [ Overload Journal #81 - Oct 2007 | Journal Editorial ]