ACCU Home page ACCU Conference Page
Search Contact us ACCU at Flickr ACCU at GitHib ACCU at Google+ ACCU at Facebook ACCU at Linked-in ACCU at Twitter Skip Navigation
pin

Overload - Bibliography by Author

[Abrahams, 2003]
David Abrahams. Error and Exception Handling Overload, 11(57):, October 2003. (PDF)
[Alday, 2014]
Juan Alday. Enforcing the Rule of Zero Overload, 22(120):6-8, April 2014. We’ve had years to get used to the old rules for making classes copyable. Juan Alday sees how the new standards change them. (PDF)
[Allan, 2009]
Alan Griffiths, Marc Allan. Software Development in the 21st Century Overload, 17(90):, April 2009. What's the future of software development? Alan Griffiths and Marc Allan have a timely look at recent experiences. (PDF)
[Antonsen, 2003]
Frank Antonsen. Stream-Based Parsing in C++ Overload, 11(56):, August 2003. (PDF)
[Antonsen, 2004]
Frank Antonsen. Letters to the Editor(s) Overload, 12(59):, February 2004. (PDF)
[Armstrong, 1996]
Nigel Armstrong. Some pitfalls of class design: a case study Overload, 4(13):14-16, April 1996. Software Development in C++ (PDF)
[Arnold, 1993]
Peter Arnold. Make...or Break? Overload, 1(1):, April 1993. (PDF)
[Arnold, 1995]
Peter Arnold. editor << letters; Overload, 3(9):34-35, August 1995. (PDF)
[Arregui, 2012]
Hugo Arregui, Carlos Castro, Daniel Gutson. Curiously Recursive Template Problems with Aspect Oriented Programming Overload, 20(109):20-23, June 2012. (PDF)
[Asproni, 2004]
Giovanni Asproni, Alexander Fedotov. An Experience Report on Implementing a Custom Agile Methodology on a C++/Python Project Overload, 12(64):, December 2004. (PDF)
[Asproni, 2006]
Giovanni Asproni. How to Shoot Yourself in the Foot In an Agile Way Overload, 14(71):16-17, February 2006. (PDF)
[Asproni, 2009]
Giovanni Asproni. ACCU 2009 Overload, 17(91):, June 2009. The 2009 ACCU Conference took place in March. The conference chair, Giovanni Asproni, provides a report. (PDF)
[Bailey, 1994]
David Bailey. Run-time checking for C++ Overload, 2(4):, February 1994. (PDF)
[Baker-Munton, 1995]
Kristen Baker-Munton. editor << letters; Overload, 3(9):33-34, August 1995. (PDF)
[Balaam, 2010]
Andy Balaam. Scalable Graph Coverage Overload, 18(97):, June 2010. Optimising data processing is often about compromise. Andy Balaam finds the right balance. (PDF)
[Balaam, 2012]
Andy Balaam. Tail Call Optimisation in C++ Overload, 20(109):10-13, June 2012. Stack based languages can be very powerful, but often can’t deal with arbitrary recursion. Andy Balaam finds a way around this limitation. (PDF)
[Balaam, 2012]
Andy Balaam. Footprint on Modify Overload, 20(112):16-19, December 2012. Tracking history can be done in a variety of ways. Andy Balaam describes one technique with many advantages. (PDF)
[Balaam, 2014]
Andy Balaam. Does Test-Driven Development Harm Clarity? Overload, 22(122):4-5, August 2014. Is clarity the key thing to aim for when writing software? Andy Balaam considers if TDD harms clarity and if this matters. (PDF)
[Balaam, 2014]
Andy Balaam. Everyone Hates build.xml Overload, 22(123):12-16, October 2014. Andy Balaam shows how to structure and test Antbuild code. (PDF)
[Balaam, 2015]
Andy Balaam. Mocks are Bad, Layers are Bad Overload, 23(127):8-11, June 2015. Many people use mocks in their unit tests. Andy Balaam asks if there’s a better way. (PDF)
[Balaam, 2015]
Andy Balaam. Don’t Design for Performance Until It’s Too Late Overload, 23(128):12-13, August 2015. People claim optimisation can cause unreadable code. Andy Balaam argues good performance should be at the core of code design. (PDF)
[Balaam, 2018]
Andy Balaam. Testing: Choose the Right Level Overload, 26(143):10-12, February 2018. Testing can be easy. Andy Balaam considers levels to keep your focus just right. (PDF)
[Barber, 2012]
Pete Barber. Unit Testing Compilation Failure Overload, 20(108):23-27, April 2012. We usually test that our code does what we expect. Pete Barber tries to prove that his code fails to compile. (PDF)
[Barber, 2014]
Pete Barber. Capturing lvalue References in C++11 Lambdas Overload, 22(119):19-20, February 2014. How confusing does it get when references refer to references and references are captured by value? Pete Barber shows us that it all falls out in the C++ consistency wash. (PDF)
[Barrett-Powell, 2004]
Tony Barrett-Powell. Handling Exceptions in finally Overload, 12(62):, August 2004. (PDF)
[Barta, 2002]
Vaclav Barta. Building Java Applications Overload, 10(49):, June 2002. (PDF)
[Bashir, 2007]
Omar Bashir. Upgrading Legacy Software in Data Communications Systems Overload, 15(82):, December 2007. Changing operational software is a risky business. Omar Bashir offers a case study in matching risk with reward. (PDF)
[Bashir, 2009]
Omar Bashir. Orderly Termination of Programs Overload, 17(89):, February 2009. Ensuring a clean shutdown is important. Omar Bashir presents some techniques. (PDF)
[Bashir, 2010]
Omar Bashir. Using Design Patterns to Manage Complexity Overload, 18(96):, April 2010. Simpler programs are more reliable. Omar Bashir sees how to make improvements. (PDF)
[Bashir, 2013]
Omar Bashir. Has the Singleton Not Suffered Enough Overload, 21(117):15-21, October 2013. Singletons are much maligned. Omar Bashir considers why. (PDF)
[Bass, 1996]
Sean A. Corfield, Remi Sellem, Bryan Colyer, Phil Bass, Colin Harkness, Steve Watson. editor << letters; Overload, 4(14):18-19, June 1996. (PDF)
[Bass, 1996]
Sean A. Corfield, Allan Newton, Graham Jones, Phil Bass, Steven Youngs. editor << letters; Overload, 4(15):35-36, August 1996. (PDF)
[Bass, 1996]
Francis Glassborow, Kevlin A. P. Henney, Colin Hersom, Graham Jones, Phil Bass, Steve Mertz, Walter Brown. editor << letters; Overload, 4(16):19-24, October 1996. (PDF)
[Bass, 1998]
Phil Bass, Unknown. editor << letters; Overload, 6(24):35-36, February 1998. (PDF)
[Bass, 1998]
Phil Bass. STL Implementations: Personal Experiences Overload, 6(26):29-34, June 1998. Whiteboard (PDF)
[Bass, 1999]
Phil Bass. The State Pattern - A New Implementation Overload, 7(33):, October 1999. (PDF)
[Bass, 2000]
Phil Bass. Standard C++ Overload, 8(35):, February 2000. (PDF)
[Bass, 2000]
Phil Bass. Supporting Threads in Standard C++ (Part 2) Overload, 8(36):, April 2000. (PDF)
[Bass, 2000]
Phil Bass. Supporting Threads in Standard C++ (Part 3) Overload, 8(37):, June 2000. (PDF)
[Bass, 2000]
Phil Bass. Supporting Threads in Standard C++ (Addendum) Overload, 8(38):, August 2000. (PDF)
[Bass, 2002]
Phil Bass. C++ Exceptions and Linux Dynamic Libraries Overload, 10(48):, April 2002. (PDF)
[Bass, 2002]
Phil Bass. Template Titbit - A Different Perspective Overload, 10(48):, April 2002. (PDF)
[Bass, 2002]
Phil Bass. Implementing the Observer Pattern in C++ - Part 1 Overload, 10(52):, December 2002. (PDF)
[Bass, 2003]
Phil Bass. Implementing the Observer Pattern, Part 2 Overload, 11(53):10-13, February 2003. (PDF)
[Bass, 2003]
Stefan Heinzmann, Phil Bass. Observer Pattern Implementation Overload, 11(54):, April 2003. (PDF)
[Bass, 2004]
Stefan Heinzmann, Phil Bass. A Template Programmer’s Struggles Resolved Overload, 12(61):, June 2004. (PDF)
[Bass, 2004]
Phil Bass. The Curious Case of the Compile-Time Function Overload, 12(62):, August 2004. (PDF)
[Bass, 2004]
Phil Bass. Evolution of the Observer Pattern Overload, 12(64):, December 2004. (PDF)
[Bass, 2005]
Phil Bass. The Trial of the Reckless Coder Overload, 13(67):, June 2005. (PDF)
[Bass, 2005]
Phil Bass. Grain Storage MIS: A Failure of Communications (27 March 1998) Overload, 13(67):, June 2005. (PDF)
[Bass, 2005]
Phil Bass. The Curate's Wobbly Desk Overload, 13(70):, December 2005. (PDF)
[Bass, 2006]
Phil Bass. Visiting Alice Overload, 14(72):, April 2006. (PDF)
[Bass, 2010]
Phil Bass. The Quartermaster’s Store Overload, 18(100):11-13, December 2010. Be careful what you wish for. Phil Bass tries to simulate a missing language feature. (PDF)
[Baus, 2006]
Christopher Baus. Pooled Lists Overload, 14(76):, December 2006. Christopher Baus explains the advantages of using a pooled memory allocation strategy for high performance applications. (PDF)
[Belch, 2009]
Yaakov Belch, Sergey Ignatchenko, Dmytro Ivanchykhin. Project-Specific Language Dialects Overload, 17(94):17--25, December 2009. Today’s languages force a one-size-fits-all approach on projects. Yaakov Belch, Sergey Ignatchenko and Dmytro Ivanchykhin suggest a more flexible solution. (PDF)
[Bellingham, 1995]
Alan Bellingham. editor << letters; Overload, 3(8):41, June 1995. (PDF)
[Bellingham, 1997]
Alan Bellingham. Shared experience: a C++ pitfall Overload, 5(20):27-31, June 1997. C++ Techniques (PDF)
[Bellingham, 1998]
Alan Bellingham. Structured Analysis: OOD’s older brother? Overload, 6(26):19-22, June 1998. Whiteboard (PDF)
[Bellingham, 1998]
Alan Bellingham. Self Registering Classes - Taking polymorphism to the limit Overload, 6(27):, August 1998. (PDF)
[Benfield, 2014]
Lee Benfield, Mike Strobel. Anatomy of a Java Decompiler Overload, 22(119):11-15, February 2014. Java byte code can be reverted back into source code. Lee Benfield and Mike Strobel show how. (PDF)
[Beuche, 2007]
Mark Dalgarno, Danilo Beuche. Software Product Line Engineering with Feature Models Overload, 15(78):, April 2007. (PDF)
[Blundel, 1998]
Richard Blundel. Dynamic Function Calling Using Operator Overloading Overload, 6(26):8-13, June 1998. Software Development in C++ (PDF)
[Blundell, 1997]
Richard Blundell. An Introduction to the UML Overload, 5(22):8-12, October 1997. (PDF)
[Blundell, 1997]
Richard Blundell. UML - Objects and Patterns Overload, 5(23):5-9, December 1997. Software Development in C++ (PDF)
[Blundell, 1998]
Richard Blundell. UML - State-Transition Diagrams Overload, 6(24):3-8, February 1998. Software Development in C++ (PDF)
[Blundell, 1998]
Richard Blundell. UML - Parameterised Classes (Templates) and Utilities Overload, 6(25):13-17, April 1998. Software Development in C++ (PDF)
[Blundell, 1998]
Richard Blundell. UML Interactions & Collaborations Overload, 6(27):, August 1998. (PDF)
[Blundell, 1999]
Richard Blundell. UML Relationships and Associations, Aggregation and Composition Overload, 7(30):, February 1999. (PDF)
[Blundell, 1999]
Richard Blundell. Thoughts on Functoids Overload, 7(31):, April 1999. (PDF)
[Blundell, 1999]
Richard Blundell. A Simple Model for Object Persistence Using the Standard Library Overload, 7(32):, June 1999. (PDF)
[Blundell, 2000]
Richard Blundell. Automatic Object Versioning for Forward and Backward File Format Compatibility Overload, 8(35):, February 2000. (PDF)
[Blundell, 2002]
Richard Blundell. File Format Conversion Using Templates and Type Collections Overload, 10(52):, December 2002. (PDF)
[Booth, 1995]
Peter Booth. Thinking in C++ (Bruce Eckel) reviewed by Peter Booth Overload, 3(10):29, October 1995. Review (PDF)
[Bouillot, 2015]
Nicolas Bouillot. Make and Forward Consultables and Delegates Overload, 23(127):20-24, June 2015. Sometimes forwarding to a contained object requires lots of boilerplate code. Nicolas Bouillot introduces consultables and delegates to automate this. (PDF)
[Bouillot, 2015]
Nicolas Bouillot. Type Mosaicing with Consultables and Delegates Overload, 23(130):8-12, December 2015. If several classes need to work together lots of boilerplate code is often needed. Nicolas Bouillot introduces type mosaicing to avoid this. (PDF)
[Bourguet, 2003]
Jean-Marc Bourguet. Exported Templates Overload, 11(54):, April 2003. (PDF)
[Bourguet, 2003]
Jean-Marc Bourguet. Letters to the Editor(s) Overload, 11(57):, October 2003. (PDF)
[Brand, 2017]
Brand Brand. Initialization in C++ is Bonkers Overload, 25(139):9-11, June 2017. Uninitialised variables can cause problems. Simon Brand reminds us how complicated it can get. (PDF)
[Brand, 2018]
Simon Brand. Functional Error-Handling with Optional and Expected Overload, 26(143):21-23, February 2018. Exceptions should be exceptional. Simon Brand shows modern alternatives from the standard library and ways to improve them. (PDF)
[Brazier, 2007]
Tom Brazier. Managing Technical Debt Overload, 15(77):, February 2007. Software projects often cut corners in the rush to meet deadlines, resulting in bad code. Tom Brazier helps us to budget the cost of "doing it wrong". (PDF)
[Brennig, 1995]
Sean A. Corfield, Keith Derrick, George Wendle, Chris Simons, Dave Midgley, Dr. James Brennig. editor << letters; Overload, 3(10):25-28, October 1995. (PDF)
[Breymann, 1995]
Uli Breymann. editor << letters; Overload, 3(8):42, June 1995. (PDF)
[Breymann, 1995]
Uli Breymann. A deeper look at copy assignment Overload, 3(11):28-34, December 1995. C++ Techniques (PDF)
[Breymann, 1996]
Uli Breymann. An implementation pattern using RTTI Overload, 3(12):14-18, February 1996. C++ Techniques (PDF)
[Brown, 2012]
Silas Brown. Web Annotation with Modified-Yarowsky and Other Algorithms Overload, 20(112):4-7, December 2012. Annotating text automatically requires word disambiguation. Silas Brown introduces the Yarowsky algorithm to help. (PDF)
[Brown, 2003]
Silas S. Brown. Indexing STL Lists With Maps Overload, 11(53):18-19, February 2003. (PDF)
[Brown, 2008]
Silas S. Brown. Letter to the Editor Overload, 16(83):, February 2008. (PDF)
[Brown, 2016]
Silas S. Brown. Letter Overload, 24(136):24, December 2016. Silas S. Brown comments on Steve Love’s recent article. (PDF)
[Brown, 2017]
Silas S. Brown. Multiprocessing and Clusters in Python Overload, 25(137):13-15, February 2017. Multiprocessing is possible in Python. Silas S. Brown shows us various ways. (PDF)
[Brown, 2017]
Silas S. Brown, Deák Ferenc, Frances Buontempo. Letters to the Editor Overload, 25(141):4, October 2017. Two letters and their replies. (PDF)
[Brown, 1996]
Francis Glassborow, Kevlin A. P. Henney, Colin Hersom, Graham Jones, Phil Bass, Steve Mertz, Walter Brown. editor << letters; Overload, 4(16):19-24, October 1996. (PDF)
[Bruntlett, 1999]
Ian Bruntlett. Beyond ACCU Overload, 7(32):, June 1999. (PDF)
[Bruntlett, 2000]
Ian Bruntlett. Intuitive Multi-Paradigm Design: Overload, 8(38):, August 2000. (PDF)
[Bruntlett, 2000]
Ian Bruntlett. User Defined Types: Qualities, Principles and Archetypes. Overload, 8(39):, October 2000. (PDF)
[Bruntlett, 2010]
Ian Bruntlett. Socially Responsible Recruitment Overload, 18(97):, June 2010. Finding talented people is hard. Ian Bruntlett highlights an under-appreciated source. (PDF)
[Bruntlett, 2016]
Ian Bruntlett. Stufftar Overload, 24(132):17-20, April 2016. How do you quickly transfer data from one machine to another? Ian Bruntlett shows us the bash script he uses. (PDF)
[Buontempo, 2009]
Frances Buontempo. Floating Point Fun and Frolics Overload, 17(91):, June 2009. Representing numbers in computers is a non-trivial problem. Frances Buontempo finds using them is hard, too. (PDF)
[Buontempo, 2012]
Frances Buontempo. Large Objects and Iterator Blocks Overload, 20(110):22-24, August 2012. Arrays can cause memory issues in .Net. Frances Buontempo shows how iterator blocks can help to relieve the pressure. (PDF)
[Buontempo, 2012]
Frances Buontempo. Allow Me To Introduce Myself Overload, 20(110):2-3, August 2012. Using data mining techniques to write an editorial. (PDF)
[Buontempo, 2012]
Frances Buontempo. Editoial: Too Much Information Overload, 20(111):2-3, October 2012. Overload usually has an editorial. Frances Buontempo explains why she hasn’t had time to write one for this issue. (PDF)
[Buontempo, 2012]
Frances Buontempo. Originally, Overload Didn’t Have an Editorial Overload, 20(112):2-3, December 2012. Frances Buontempo considers history, predictions about the future and how to shirk off writing an editorial. (PDF)
[Buontempo, 2013]
Frances Buontempo. The Good, The Bad and The Discordant Overload, 21(113):2-3, February 2013. There are several signs of bad code. Frances Buontempo considers ugliness, stench and discord in a search for beauty. (PDF)
[Buontempo, 2013]
Frances Buontempo. Knitting Needles and Keyboards Overload, 21(114):2-3, April 2013. Traditionally, both journals and developers have editors. Frances Buontempo considers the role of an editor, in another attempt to avoid writing an editorial. (PDF)
[Buontempo, 2013]
Frances Buontempo. Editorial: Learning Fantasy Languages Overload, 21(116):2-3, August 2013. The last Overload editorial described a Fantasy Language. Now, how do you learn one? (PDF)
[Buontempo, 2013]
Frances Buontempo. Editorial: Decisions, Decisions Overload, 21(117):2-3, October 2013. Providing precise definitions can be difficult. For example, what is a program? (PDF)
[Buontempo, 2013]
Frances Buontempo. Editorial: Not So Much a Program, More a Way of Life Overload, 21(118):2-3, December 2013. In an attempt to continue and improve on the successful formula of previous editorial avoidance techniques, Frances Buontempo considers what a program really is. (PDF)
[Buontempo, 2013]
Frances Buontempo. How to Program Your Way Out of a Paper Bag Using Genetic Algorithms Overload, 21(118):7-9, December 2013. It is often claimed people cannot program their way out of a paper bag. Frances Buontempo bucks the trend using genetic algorithms. (PDF)
[Buontempo, 2014]
Frances Buontempo. Editorial: Random (non)sense Overload, 22(119):2-3, February 2014. It’s not pretty and it’s not clever. Frances Buontempo considers if the cut-up method can be used to generate editorials. (PDF)
[Buontempo, 2014]
Frances Buontempo. Editorial: Very small or very far away: A sense of perspective Overload, 22(121):2-3, June 2014. A tension exists between being immersed in something and stepping back. Frances Buontempo considers the importance of taking a break. (PDF)
[Buontempo, 2014]
Frances Buontempo. Editorial: Shop ’til you Drop Overload, 22(122):2-3, August 2014. Deciding which tools to acquire can be a difficult decision. Frances Buontempo muses on a failed shopping trip. (PDF)
[Buontempo, 2014]
Frances Buontempo. Paper Bag Escapology Using Partricle Swarm Optimisation Overload, 22(123):24-27, October 2014. Frances Buontempo uses particle swarm optimisation to program her way out of a paper bag. (PDF)
[Buontempo, 2014]
Frances Buontempo. Editorial: Peer Reviewed Overload, 22(123):2-3, October 2014. Nobody gets it right first time. Frances Buontempo considers the importance ofthe review team. (PDF)
[Buontempo, 2014]
Frances Buontempo. Editorial: Finding your muse Overload, 22(124):2-3, December 2014. Lack of ideas and confidence can freeze an author. Frances Buontempo considers how to warm up. (PDF)
[Buontempo, 2015]
Frances Buontempo. How to Write an Article Overload, 23(125):20-21, February 2015. Submitting an article for publication might seem difficult. Frances Buontempo explains how easy it is. (PDF)
[Buontempo, 2015]
Frances Buontempo. FUD - Fear, uncertainty and doubt Overload, 23(125):2-3, February 2015. Sometimes programming is neither an engineering discipline nor a science. Frances Buontempo considers when it slips into the numinous realm. (PDF)
[Buontempo, 2015]
Frances Buontempo. Where was I? Overload, 23(126):2-3, April 2015. Space and time are relative. Frances Buontempo wonders whether this will wash as an excuse for another lack of editorial. (PDF)
[Buontempo, 2015]
Frances Buontempo. Editorial: A little more conversation, a little less action Overload, 23(127):2-3, June 2015. A tension exists between talking and doing. Frances Buontempo wonders which matters more. (PDF)
[Buontempo, 2015]
Frances Buontempo. Editorial: Semi-automatic Weapons Overload, 23(128):2-3, August 2015. Automating work can save time and avoid mistakes. But Frances Buontempo doesn’t think you should script everything. (PDF)
[Buontempo, 2015]
Frances Buontempo. Editorial: Failure is an option Overload, 23(129):2-3, October 2015. Motivational speeches and aphorisms are clichés. Frances Buontempo wonders if they sometimes do more harm than good. (PDF)
[Buontempo, 2015]
Frances Buontempo. Editorial: Reduce, reuse, recycle Overload, 23(130):2-3, December 2015. The introduction of a carrier bag tax has caused a little fuss. Frances Buontempo considers if it has lessons for programmers. (PDF)
[Buontempo, 2016]
Frances Buontempo. Be lucky Overload, 24(131):2-3, February 2016. Do you consider yourself unlucky? Frances Buontempo wonders what we can do to avoid disasters. (PDF)
[Buontempo, 2016]
Frances Buontempo. How to Diffuse Your Way Out of a Paper Bag Overload, 24(132):13-16, April 2016. Diffusion models can be used in many areas. Frances Buontempo applies them to paper bag escapology. (PDF)
[Buontempo, 2016]
Frances Buontempo. Where Does All The Time Go? Overload, 24(132):2-3, April 2016. There’s never enough time. Frances Buontempo wonders what this really means. (PDF)
[Buontempo, 2016]
Frances Buontempo. Metrics and Imperialism Overload, 24(133):2-3, June 2016. Measuring accurately underpins science. Frances Buontempo considers what constitutes sensible metrics. (PDF)
[Buontempo, 2016]
Frances Buontempo. Editorial: Just a minute Overload, 24(134):2-3, August 2016. Constraints can seem like an imposition. Frances Buontempo wonders if banning hesitation, deviation or repetition is a good thing. (PDF)
[Buontempo, 2016]
Frances Buontempo. Editorial: Ain’t that the truth?! Overload, 24(135):2-3, October 2016. Witnesses promise to tell the truth, the whole truth and nothing but the truth. Frances Buontempo wonders what truth actually means. (PDF)
[Buontempo, 2016]
Frances Buontempo. The Font of Wisdom Overload, 24(136):2-3, December 2016. The choice of typeface can convey a tone. Frances Buontempo considers the plethora of dilemmas this presents. (PDF)
[Buontempo, 2017]
Frances Buontempo. The Uncertainty Guidelines Overload, 25(137):2-3, February 2017. Uncertainty can be overwhelming. Frances Buontempo embraces the advantages of ambiguity. (PDF)
[Buontempo, 2017]
Frances Buontempo. An Interview: Emyr Williams Overload, 25(138):10-11, April 2017. CVu has been running a series of interviews. Frances Buontempo interviews the interviewer, Emyr Williams. (PDF)
[Buontempo, 2017]
Frances Buontempo. Breadth First, Depth First, Test First Overload, 25(138):2-3, April 2017. You can approach a problem top-down or bottom-up. Frances Buontempo wonders if algorithms can help us choose the most appropriate direction. (PDF)
[Buontempo, 2017]
Frances Buontempo. I am not a number Overload, 25(139):2-3, June 2017. When is a number not a number? Frances Buontempo counts the ways this happens. (PDF)
[Buontempo, 2017]
Frances Buontempo. Gnomes and Misnomers Overload, 25(140):2-3, August 2017. What's in a name? Frances Buontempo decides some names are better than others. (PDF)
[Buontempo, 2017]
Silas S. Brown, Deák Ferenc, Frances Buontempo. Letters to the Editor Overload, 25(141):4, October 2017. Two letters and their replies. (PDF)
[Buontempo, 2017]
Frances Buontempo. This way up! Overload, 25(141):2-3, October 2017. Directions in computing can be very confusing. Frances Buontempo wonders if we know our right from left. (PDF)
[Buontempo, 2017]
Frances Buontempo. Too Fast! Too slow! Too right!! Overload, 25(142):2-3, December 2017. Many products over-promise. Frances Buontempo muses on how to get things just right. (PDF)
[Buontempo, 2018]
Frances Buontempo. Hapaxes, Singletons and Anomalies Overload, 26(143):2-3, February 2018. Programmers can be odd. Frances Buontempo celebrates many manifold peculiarities. (PDF)
[Buontempo, 2018]
Frances Buontempo. Deeds not words Overload, 26(144):2-3, April 2018. Women’s suffrage used the motto "Deeds not Words". Frances Buontempo applies this to programming. (PDF)
[Cacciola, 2006]
Fernando Cacciola. Introducing CODEF/CML Overload, 14(74):, August 2006. This article introduces a C# serialization facility that proposes a novel separation between object models, representing the serialized data, and class descriptors, representing the binding to the receiving design space. (PDF)
[Castro, 2012]
Hugo Arregui, Carlos Castro, Daniel Gutson. Curiously Recursive Template Problems with Aspect Oriented Programming Overload, 20(109):20-23, June 2012. (PDF)
[Charney, 2003]
Reg Charney. C++ Templates Overload, 11(53):25-26, February 2003. (PDF)
[Charney, 2003]
Reg Charney. C++ Standards Library Report Overload, 11(53):23-24, February 2003. (PDF)
[Charney, 1998]
Reginald B. Charney. Data Attribute Notation - Part 2 Overload, 6(29):, December 1998. (PDF)
[Charney, 1999]
Reginald B. Charney. Data Attribute Notation - Part 3 Overload, 7(30):, February 1999. (PDF)
[Cheshire, 2002]
Andrew Cheshire. Template Metaprogramming: Shifting Down a Gear Overload, 10(50):, August 2002. (PDF)
[Clamage, 1997]
Steve Clamage. C++ Committee Draft Overload, 5(19):15, April 1997. The Draft International C++ Standard (PDF)
[Clare, 2008]
Bill Clare. Globals, Singletons and Parameters Overload, 16(86):, August 2008. One size rarely fits all. Bill Clare considers different approaches to parameterization. (PDF)
[Coe, 2014]
Robert Mill, Jonathan Coe. Defining Visitors Inline in Modern C++ Overload, 22(123):17-19, October 2014. Robert Mill and Jonathan Coe present an inline visitor in C++. (PDF)
[Coe, 2015]
Jonathan Coe, Andrew Sutton. An Inline-variant-visitor with C++ Concepts Overload, 23(129):17-20, October 2015. Concepts are abstract. Jonathan Coe and Andrew Sutton provide us with a concrete example of their use. (PDF)
[Colyer, 1996]
Sean A. Corfield, Remi Sellem, Bryan Colyer, Phil Bass, Colin Harkness, Steve Watson. editor << letters; Overload, 4(14):18-19, June 1996. (PDF)
[Corfield, 1997]
Sean Corfield. Editorial Overload, 5(17/18):, January 1997. (PDF)
[Corfield, 1998]
Sean Corfield. Broadvision: A lesson in application frameworks Overload, 6(26):26-29, June 1998. Whiteboard (PDF)
[Corfield, 1998]
Sean Corfield. Broadvision - Part 2 Overload, 6(27):, August 1998. (PDF)
[Corfield, 1998]
Sean Corfield. Broadvision - Part 3 Overload, 6(28):, October 1998. (PDF)
[Corfield, 1999]
Sean Corfield. BroadVision, Part 4 Overload, 7(32):, June 1999. (PDF)
[Corfield, 1998]
Sean A Corfield. Sean's Show Overload, 6(26):2, June 1998. Editorial (PDF)
[Corfield, 1994]
Sean A. Corfield. The Casting Vote Overload, 2(4):, February 1994. (PDF)
[Corfield, 1994]
Sean A. Corfield. So you want to be a cOOmpiler writer? Overload, 2(5):10-11, September 1994. (PDF)
[Corfield, 1994]
Sean A. Corfield. The Virtual Interview Overload, 2(5):7, September 1994. John Max Skaller was interviewed by Sean A. Corfield (PDF)
[Corfield, 1994]
Sean A. Corfield. The Casting Vote Overload, 2(5):18-21, September 1994. (PDF)
[Corfield, 1995]
Sean A. Corfield. The Casting Vote Overload, 3(6):, March 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. Editorial Overload, 3(7):3-4, April 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. The Casting Vote Overload, 3(7):18-22, April 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. Questions & Answers Overload, 3(7):40-41, April 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. ++puzzle; Overload, 3(7):41, April 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. Books and Journals Overload, 3(7):42, April 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. Subsidising lunch? - a reply Overload, 3(7):10-11, April 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. Editorial Overload, 3(8):3, June 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. namespace - a short exposé Overload, 3(8):18-19, June 1995. The Draft International C++ Standard (PDF)
[Corfield, 1995]
Sean A. Corfield. ++puzzle; Overload, 3(8):43, June 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. So you want to be a cOOmpiler writer? - part II Overload, 3(8):12-14, June 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. Design Patterns reviewed by Sean A. Corfield Overload, 3(9):38-39, August 1995. Books and Journals (PDF)
[Corfield, 1995]
Sean A. Corfield. Editorial Overload, 3(9):3, August 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. The Casting Vote Overload, 3(9):18-21, August 1995. The Draft International C++ Standard (PDF)
[Corfield, 1995]
Sean A. Corfield, Keith Derrick, George Wendle, Chris Simons, Dave Midgley, Dr. James Brennig. editor << letters; Overload, 3(10):25-28, October 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. Editorial Overload, 3(10):3-4, October 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. So you want to be a cOOmpiler writer? - part III Overload, 3(10):5-11, October 1995. Software Development in C++ (PDF)
[Corfield, 1995]
Sean A. Corfield. From Chaos to Classes (Daniel Duffy) reviewed by Sean A. Corfield Overload, 3(10):29-31, October 1995. (PDF)
[Corfield, 1995]
Sean A. Corfield. What’s in a name? Overload, 3(10):13-16, October 1995. The Draft International C++ Standard (PDF)
[Corfield, 1995]
Sean A. Corfield. Scientific and Engineering C++ reviewed by Sean A. Corfield Overload, 3(11):42-43, December 1995. Books and Journals (PDF)
[Corfield, 1995]
Sean A. Corfield. The Casting Vote Overload, 3(11):18-19, December 1995. The Draft International C++ Standard (PDF)
[Corfield, 1995]
Sean A. Corfield. Editorial Overload, 3(11):3, December 1995. (PDF)
[Corfield, 1996]
Sean A. Corfield, Dave Midgley, Roger Lever, Chris Simons, Andrew King, Alan Griffiths, Jay. editor << letters; Overload, 3(12):, February 1996. (PDF)
[Corfield, 1996]
Sean A. Corfield. So you want to be a cOOmpiler writer? - part IV Overload, 3(12):7-9, February 1996. Software Development in C++ (PDF)
[Corfield, 1996]
Sean A. Corfield. A UK perspective Overload, 3(12):13-14, February 1996. The Draft International C++ Standard (PDF)
[Corfield, 1996]
Sean A. Corfield. Heapwalking problems Overload, 3(12):22-23, February 1996. C++ Techniques (PDF)
[Corfield, 1996]
Sean A. Corfield. Editorial Overload, 3(12):3, February 1996. (PDF)
[Corfield, 1996]
Sean A. Corfield. The Casting Vote Overload, 4(13):16-18, April 1996. The Draft International C++ Standard (PDF)
[Corfield, 1996]
Sean A. Corfield. So you want to be a cOOmpiler writer? - part V Overload, 4(13):9-11, April 1996. Software Development in C++ (PDF)
[Corfield, 1996]
Sean A. Corfield. Editorial Overload, 4(13):3-6, April 1996. (PDF)
[Corfield, 1996]
Sean A. Corfield, Peter Wippell, Dave Midgley, Roger Woollett, The Harpist. editor << letters; Overload, 4(13):30-31, April 1996. (PDF)
[Corfield, 1996]
Sean A. Corfield. Using STL with pointers Overload, 4(13):24-27, April 1996. C++ Techniques (PDF)
[Corfield, 1996]
Sean A. Corfield. You can’t get there from here - a closer look at input iterators Overload, 4(13):20-21, April 1996. C++ Techniques (PDF)
[Corfield, 1996]
Sean A. Corfield, Remi Sellem, Bryan Colyer, Phil Bass, Colin Harkness, Steve Watson. editor << letters; Overload, 4(14):18-19, June 1996. (PDF)
[Corfield, 1996]
Sean A. Corfield. Editorial Overload, 4(14):3, June 1996. (PDF)
[Corfield, 1996]
Sean A. Corfield. The Casting Vote Overload, 4(15):19-20, August 1996. The Draft International C++ Standard (PDF)
[Corfield, 1996]
Sean A. Corfield. So you want to be a cOOmpiler writer? - part VI Overload, 4(15):15-19, August 1996. Software Development in C++ (PDF)
[Corfield, 1996]
Sean A. Corfield. Editorial Overload, 4(15):3, August 1996. (PDF)
[Corfield, 1996]
Sean A. Corfield, Allan Newton, Graham Jones, Phil Bass, Steven Youngs. editor << letters; Overload, 4(15):35-36, August 1996. (PDF)
[Corfield, 1996]
Sean A. Corfield. Editorial Overload, 4(16):3, October 1996. (PDF)
[Corfield, 1997]
Sean A. Corfield. The Casting Vote II Overload, 5(17/18):, January 1997. (PDF)
[Corfield, 1997]
Sean A. Corfield. The Casting Vote I Overload, 5(17/18):, January 1997. (PDF)
[Corfield, 1997]
Sean A. Corfield. The Casting Vote Overload, 5(19):15-17, April 1997. The Draft International C++ Standard (PDF)
[Corfield, 1997]
Sean A. Corfield. The Casting Vote Overload, 5(20):7-8, June 1997. The Draft International C++ Standard (PDF)
[Corfield, 1997]
Sean A. Corfield. The Casting Vote Overload, 5(21):7-9, August 1997. The Draft International C++ Standard (PDF)
[Corfield, 1998]
Sean A. Corfield. Java 1.2 and JavaScript for C and C++ Programmers Overload, 6(26):34-36, June 1998. Reviews (PDF)
[Cornish, 1999]
Steve Cornish. Exceptions - The Basics Overload, 7(33):, October 1999. (PDF)
[Cornish, 1999]
Steve Cornish. Error logging and patterns Overload, 7(34):, December 1999. (PDF)
[Cornish, 1999]
Steve Cornish. SAX - A Simple API for XML Overload, 7(34):, December 1999. (PDF)
[Cornish, 1999]
Steve Cornish. Exceptions - The Details Overload, 7(34):, December 1999. (PDF)
[Cornish, 2000]
Steve Cornish. Exceptions - Guidance Overload, 8(35):, February 2000. (PDF)
[Cornish, 2000]
Steve Cornish. XML in Applications II DOM - the Document Object Model Overload, 8(36):, April 2000. (PDF)
[Craveiro, 2016]
Marco Craveiro. Dogen: The Package Management Saga Overload, 24(133):4-6, June 2016. How do you manage packages in C++? Marco Craveiro eventually discovered Conan after some frustrating experiences. (PDF)
[Crickett, 2002]
John Crickett. Developing a C++ Unit Testing Framework Overload, 10(52):, December 2002. (PDF)
[Dalgarno, 2007]
Mark Dalgarno, Danilo Beuche. Software Product Line Engineering with Feature Models Overload, 15(78):, April 2007. (PDF)
[Daudel, 2003]
Jeff Daudel. A Unified Singleton Framework Overload, 11(56):, August 2003. (PDF)
[Daudel, 2003]
Jeff Daudel. Letter to the Editor(s) Overload, 11(58):, December 2003. (PDF)
[Davies, 1995]
David Davies. OOA - The Shlaer-Mellor Approach Overload, 3(8):5-12, June 1995. (PDF)
[Davies, 1995]
David Davies. Classes and Associations Overload, 3(11):5-15, December 1995. Software Development in C++ (PDF)
[Davies, 2006]
Rachel Davies. Pair Programming Explained Overload, 14(73):, June 2006. Rachel Davies explains how to implement pair programming and why it can be an effective practice for programmers. (PDF)
[Davies, 2006]
Colin Paul Gloster, William Fishburne, Seweryn Habdank-Wojewódzki, Rachel Davies. Letters Overload, 14(75):, October 2006. (PDF)
[Davies, 2007]
Rachel Davies. Live and Learn with Retrospectives Overload, 15(79):, June 2007. How can a team learn from experience? Rachel Davies presents a powerful technique for this. (PDF)
[Deigh, 2007]
Teedy Deigh. A Practical Form of OO Layering Overload, 15(78):, April 2007. (PDF)
[Deigh, 2008]
Teedy Deigh. The Way of the Consultant Overload, 16(84):, April 2008. Effective communication is a challenging reponsibility of the communicator - Teedy Deigh offers some observations on how consultants can meet this challenge. (PDF)
[Deigh, 2009]
Teedy Deigh. WRESTLE: Aggressive and Unprincipled Agile Development in the Small Overload, 17(90):, April 2009. Agile development is all the rage. Teedy Deigh introduces a popular variant. (PDF)
[Deigh, 2010]
Teedy Deigh. A Practical, Reasoned and Inciteful Lemma for Overworked and Overlooked Loners Overload, 18(96):, April 2010. Popular movements need a rallying cry. Teedy Deigh offers a timely one. (PDF)
[Deigh, 2011]
Teedy Deigh. Despair Programming Overload, 19(102):24, April 2011. Managing relationships is vital to a successful project. Teedy Deigh looks back on a lifetime’s experience. (PDF)
[Deigh, 2012]
Teedy Deigh. A Position on Running Interference in Languages Overload, 20(108):36, April 2012. There is much debate about the merits of different approaches to type systems. Teedy Deigh considers how to make the most of them. (PDF)
[Deigh, 2013]
Teedy Deigh. Why Dysfunctional Programming Matters Overload, 21(114):27-28, April 2013. Function progamming is all the rage. Teedy Deigh considers how it offers many opportunities for the serious programmer. (PDF)
[Deigh, 2014]
Teedy Deigh. Teenage Hex Overload, 22(120):32, April 2014. There’s a big push to get programming into schools. Teedy Deigh considers what would suit the target audience. (PDF)
[Deigh, 2015]
Teedy Deigh. Seeing the Wood for the Trees Overload, 23(126):32, April 2015. The outdoors is fabled to be great. Teedy Deigh suggests your code reflects your environment without ever having to look out of the window. (PDF)
[Deigh, 2016]
Teedy Deigh. 9.7 Things Every Programmer Really, Really Should Know Overload, 24(132):24, April 2016. Most of us have heard of the twelve step program. Teedy Deigh introduces a 9.7 step plan for programmers. (PDF)
[Deigh, 2017]
Teedy Deigh. All About the Base Representing numbers presents many choices. Overload, 25(138):20, April 2017. Teedy Deigh counts the ways. (PDF)
[Deigh, 2018]
Teedy Deigh. Ex Hackina Overload, 26(144):28, April 2018. Machine Learning and AI are popular at the moment. Teedy Deigh takes the Turing test. (PDF)
[Demin, 2012]
Alexander Demin. A Practical Introduction to Erlang Overload, 20(107):24-28, February 2012. The future of massively parallel hardware will need good language support. Alexander Demin takes a look at an unexpected approach. (PDF)
[Derrick, 1995]
Sean A. Corfield, Keith Derrick, George Wendle, Chris Simons, Dave Midgley, Dr. James Brennig. editor << letters; Overload, 3(10):25-28, October 1995. (PDF)
[Derrick, 1996]
Keith Derrick. Real world patterns Overload, 4(14):7-9, June 1996. Software Development in C++ (PDF)
[Derrick, 1997]
Keith Derrick. Caught in the pattern web Overload, 5(17/18):, January 1997. (PDF)
[Dorrans, 1995]
Barry Dorrans. editor << letters; Overload, 3(9):34, August 1995. (PDF)
[Durbin, 1996]
Dave Durbin. More on Java Overload, 4(14):9-12, June 1996. Software Development in C++ (PDF)
[Easterbrook, 2006]
Mark Easterbrook. Comments Considered Evil Overload, 14(73):, June 2006. We are taught that adding comments to code is a good thing and adds value. In practice this value is seldom, if ever, realised. Mark Easterbrook makes the case for a better way. (PDF)
[Egan, 2012]
Jason McGuiness, Colin Egan. A DSEL for Addressing the Problems Posed by Parallel Architectures Overload, 20(111):13-18, October 2012. Programming parallel algorithms correctly is hard. Jason McGuiness and Colin Egan demonstrate how a C++ DESEL can make it simpler. (PDF)
[Eisenecker, 1995]
Ulrich W. Eisenecker. Multiple inheritance in C++ - part I Overload, 3(7):28-32, April 1995. (PDF)
[Eisenecker, 1995]
Ulrich W. Eisenecker. Multiple inheritance in C++ - part II Overload, 3(9):24-27, August 1995. (PDF)
[Eisenecker, 1995]
Ulrich W. Eisenecker. Multiple inheritance in C++ - part III Overload, 3(10):5-8, October 1995. Software Development in C++ (PDF)
[Eisenecker, 1999]
Ulrich W. Eisenecker. Polymorphism In Object-Oriented Languages Overload, 7(32):, June 1999. (PDF)
[Eke, 1999]
Nigel Eke. My Pet Project - Monopoly Overload, 7(34):, December 1999. (PDF)
[Eke, 2000]
Nigel Eke. My Pet Project Monopoly 2 Overload, 8(35):, February 2000. (PDF)
[Eke, 2000]
Nigel Eke. The Pet Project - Monopoly (Part 3) Overload, 8(36):, April 2000. (PDF)
[Eke, 2000]
Nigel Eke. The Pet Project (part 4) Overload, 8(37):, June 2000. (PDF)
[Eke, 2007]
Nigel Eke. Programming - Abstraction by Design Overload, 15(77):, February 2007. Nigel Eke acts as a guide to aspect oriented programming using AspectJ as an example. (PDF)
[Fabijanic, 2008]
Aleksandar Fabijanic. DynamicAny, Part I Overload, 16(86):, August 2008. Alex Fabijanic presents a class hierarchy providing dynamic typing in standard C++. (PDF)
[Fabijanic, 2008]
Aleksandar Fabijanic. DynamicAny (Part 2) Overload, 16(87):, October 2008. Alex Fabijanic uncovers the internals of DynamicAny with some performance and size tests. (PDF)
[Fabijanic, 2013]
Alex Fabijanic. Dynamic C++, Part 1 Overload, 21(115):21-27, June 2013. Static and dynamic languages have different trade-off. Alex Fabijanic attempts to get the best of both worlds. (PDF)
[Fabijanic, 2013]
Alex Fabijanic. Dynamic C++ (Part 2) Overload, 21(116):16-20, August 2013. Previously we saw how to use some simple dynamic features in C++. Alex Fabijanic and Richard Saunders explore more powerful dynamic tools. (PDF)
[Fagg, 1994]
Mike Toms, Adrian Fagg. Letters Overload, 2(5):21, September 1994. (PDF)
[Fagg, 1994]
Adrian Fagg. Borland C++ V4.0 Overload, 2(5):14-15, September 1994. (PDF)
[Fagg, 1994]
Adrian Fagg. Microsoft Visual C++ V1.5 (16bit) Overload, 2(5):12-14, September 1994. (PDF)
[Fagg, 1997]
Adrian Fagg. Using objects for background tasks (3) Overload, 5(17/18):, January 1997. See also corrections in Overload 19, p.30 (PDF)
[Fagg, 1998]
Adrian Fagg. A Delphic Experience Overload, 6(29):, December 1998. (PDF)
[Fagg, 1999]
Adrian Fagg. An Eventful Story Overload, 7(30):, February 1999. (PDF)
[Fahller, 2010]
Björn Fahller. Making String ReTRIEval Fast Overload, 18(99):17-25, October 2010. Sometimes you really do have to optimize your code. Björn Fahller looks at a string lookup data structure. (PDF)
[Fahller, 2012]
Björn Fahller. What’s a Good Date? Overload, 20(109):6-9, June 2012. Implementing a data type seems simple at first glance. Björn Fahller investigates why you might choose a representation. (PDF)
[Fahller, 2015]
Björn Fahller. Making a Tool of Deception Overload, 23(125):7-9, February 2015. Is it possible to use modern C++ to make mocking easy? Björn Fahller introduces Trompeloeil, a header-only mocking framework for C++14. (PDF)
[Fedotov, 2004]
Giovanni Asproni, Alexander Fedotov. An Experience Report on Implementing a Custom Agile Methodology on a C++/Python Project Overload, 12(64):, December 2004. (PDF)
[Ferenc, 2016]
Deák Ferenc. Attacking Licensing Problems with C++ Overload, 24(135):20-31, October 2016. Software licenses are often crackable. Deák Ferenc presents a technique for tackling this problem. (PDF)
[Ferenc, 2017]
Deák Ferenc. Contractual Loopholes Overload, 25(138):16-19, April 2017. Compilers can optimise away functions you may want to time. Deák Ferenc explores ways to stop this happening. (PDF)
[Ferenc, 2017]
Deák Ferenc. Open Source - And Still Deceiving Programmers Overload, 25(141):18-23, October 2017. Deák Ferenc walks through the ELF format to avoid malicious code injection. (PDF)
[Ferenc, 2017]
Silas S. Brown, Deák Ferenc, Frances Buontempo. Letters to the Editor Overload, 25(141):4, October 2017. Two letters and their replies. (PDF)
[Ferenc, 2018]
Deák Ferenc. Practical Cryptographical Theory for Programmers Overload, 26(144):21-27, April 2018. Cryptography is a daunting subject. Deák Ferenc helps you get started. (PDF)
[Fertig, 2017]
Andreas Fertig. About the C++ Core Guidelines Overload, 25(140):25-27, August 2017. Andreas Fertig shows us the C++ core guidelines. (PDF)
[Field, 1998]
Paul Field. Controlling access to objects by using private interfaces Overload, 6(28):, October 1998. (PDF)
[Firth, 1995]
Bob Firth. editor << letters; Overload, 3(7):38-40, April 1995. (PDF)
[Fishburne, 2006]
William Fishburne. Comments Considered Good Overload, 14(74):, August 2006. In our last issue, we offered the case against comments; in this issue, William Fishbourne responds in defence. He argues that it is not the practice of commenting that it is evil, it is the thoughtless commenter. (PDF)
[Fishburne, 2006]
Colin Paul Gloster, William Fishburne, Seweryn Habdank-Wojewódzki, Rachel Davies. Letters Overload, 14(75):, October 2006. (PDF)
[Fletcher, 2017]
Shayne Fletcher. Implementing Type-Classes as OCaml Modules Overload, 25(142):11-13, December 2017. Type classes achieve overloading in functional paradigms. Shayne Fletcher implements some as OCaml modules. (PDF)
[Floyd, 2012]
Paul Floyd. Valgrind Part 1 - Introduction Overload, 20(108):14-15, April 2012. Good analysis tools can really help track down problems. Paul Floyd investigates the facilities from a suite of tools. (PDF)
[Floyd, 2012]
Paul Floyd. Valgrind Part 2 - Basic memcheck Overload, 20(109):24-29, June 2012. Learning how to use our tools well is a vital skill. Paul Floyd shows us how to check for memory problems. (PDF)
[Floyd, 2012]
Paul Floyd. Valgrind Part 3 Advanced memcheck Overload, 20(110):4-7, August 2012. Valgrind provides several mechanisms to locate memory problems in your code. Paul Floyd shows us how to use them. (PDF)
[Floyd, 2012]
Paul Floyd. Valgrind Part 4 Overload, 20(111):4-7, October 2012. Cachegrind and Callgrind When your application is slow, you need a profiler. Paul Floyd shows us how callgrind and cachegrind can help. (PDF)
[Floyd, 2012]
Paul Floyd. Valgrind Part 5 - Massif Overload, 20(112):20-24, December 2012. Poor performance can be caused by memory usage. Paul Floyd introduces Valgrind’s heap memory profiling tool Massif. (PDF)
[Floyd, 2013]
Paul Floyd. Valgrind Part 6 - Helgrind and DRD Overload, 21(114):6-9, April 2013. Debugging multi-threaded code is hard. Paul Floyd uses Helgrind and DRD to find deadlocks and race conditions. (PDF)
[Floyd, 2018]
Paul Floyd. No News is Good News Overload, 26(144):4-7, April 2018. Using ‘new’ without care can be slow. Paul Floyd uses Godbolt’s compiler explorer to see what happens when you do. (PDF)
[Foyle, 2010]
Walter Foyle. Bug Elimination - Defensive Agile Ruses Overload, 18(96):, April 2010. Everyone thinks they understand bug economics. Walter Foyle looks again. (PDF)
[Frogley, 2001]
Thaddaeus Frogley. An introduction to C++ Traits Overload, 9(43):, June 2001. (PDF)
[Frogley, 2004]
Thaddaeus Frogley. More is Less Overload, 12(59):, February 2004. (PDF)
[Frogley, 2005]
Thaddaeus Frogley. C Abuse Overload, 13(65):, February 2005. (PDF)
[Frogley, 2015]
Lion Gutjahr, Thaddaeus Frogley. Letter to the Editor Overload, 23(125):22-24, February 2015. With response. (PDF)
[Frogley, 2016]
Thaddaeus Frogley. Implementing SNAAAKE Overload, 24(134):11-13, August 2016. Almost everyone knows the game Snake! Thaddaeus Frogley shares a diary of how his implementation grew over time. (PDF)
[Frolov, 2015]
Pavel Frolov. Resource Management with Explicit Template Specializations Overload, 23(126):18-22, April 2015. RAII is a useful idiom. Pavel Frolov presents a powerful extension using explicit template specialization. (PDF)
[Frost, 1993]
Stuart Frost. Rumbaugh's OMT - The method behind C++ Designer Overload, 1(1):, April 1993. (PDF)
[Gibson, 2006]
Chris Gibson. How Do Those Funky Placeholders Work? Overload, 14(73):, June 2006. The current C++ standard function binders are notoriously difficult to use. Chris Gibson exposes the secret the Boost alternative, which is so much better it seems like magic. (PDF)
[Gilb, 2005]
Tom Gilb. Software Project Management: Adding Stakeholder Metrics to Agile Projects Overload, 13(68):, August 2005. Agile methods need to include stakeholder metrics in order to ensure that projects focus better on the critical requirements, and that projects are better able to measure their achievements, and to adapt to feedback. This paper presents a short, simple defined process for evolutionary project management (Evo), and discusses its key features. (PDF)
[Gilb, 2005]
Tom Gilb. How to Quantify Quality: Finding Scales of Measure Overload, 13(70):, December 2005. (PDF)
[Gilb, 2008]
Tom Gilb. Quality Manifesto Overload, 16(85):, June 2008. Software quality is a systems engineering job. Tom Gilb explains the importance of knowing where we're going. (PDF)
[Gilson, 2007]
Matthieu Gilson. The Policy Bridge Design Pattern Overload, 15(79):, June 2007. Matthieu Gilson offers some thoughts on using a policy based mechanism to build efficient classes from loosely coupled components. (PDF)
[Glasborow, 1997]
John Merrells, The Harpist, George Wendle, Francis Glasborow, Chris Southern. editor << letters; Overload, 5(22):, October 1997. (PDF)
[Glassborow, 1993]
Francis Glassborow. Some Thoughts on Writing Classes Overload, 1(1):, April 1993. (PDF)
[Glassborow, 1993]
Francis Glassborow. Some Thoughts on the Use of New Overload, 1(2):, June 1993. (PDF)
[Glassborow, 1993]
Francis Glassborow. Welcome to ECUG Overload, 1(3):, August 1993. (PDF)
[Glassborow, 1993]
Francis Glassborow. Uses of Classes with only Private and Protected Constructors Overload, 1(3):, August 1993. (PDF)
[Glassborow, 1993]
Francis Glassborow. Minimising Stack Use and Other Uses of new Overload, 1(3):, August 1993. (PDF)
[Glassborow, 1994]
Francis Glassborow. new & delete Overload, 2(4):, February 1994. (PDF)
[Glassborow, 1994]
Francis Glassborow. Operators for Arithmetic Classes Overload, 2(5):1-4, September 1994. (PDF)
[Glassborow, 1995]
Francis Glassborow. Blindspots Overload, 3(6):, March 1995. (PDF)
[Glassborow, 1995]
Francis Glassborow. C++ compilers for MSDOS / MSWindows Overload, 3(6):, March 1995. (PDF)
[Glassborow, 1995]
Francis Glassborow. Friends - who needs them? Overload, 3(6):, March 1995. (PDF)
[Glassborow, 1995]
Francis Glassborow. Related addendum Overload, 3(7):28, April 1995. (PDF)
[Glassborow, 1995]
Francis Glassborow. C++ compilers - mainly for OS/2 Overload, 3(7):4-7, April 1995. (PDF)
[Glassborow, 1995]
Francis Glassborow. Circle & Ellipse - Creating Polymorphic Objects Overload, 3(8):27-29, June 1995. (PDF)
[Glassborow, 1995]
Francis Glassborow. A Better C? Overload, 3(9):3-5, August 1995. (PDF)
[Glassborow, 1995]
Francis Glassborow. Diary of an Observer Overload, 3(9):15-17, August 1995. The Draft International C++ Standard (PDF)
[Glassborow, 1995]
Francis Glassborow. Pausing for thought Overload, 3(10):24-25, October 1995. C++ Techniques (PDF)
[Glassborow, 1995]
Francis Glassborow. Date with a Design Overload, 3(11):40-41, December 1995. ++puzzle; (PDF)
[Glassborow, 1995]
Francis Glassborow. Some thoughts on linkage Overload, 3(11):19-21, December 1995. The Draft International C++ Standard (PDF)
[Glassborow, 1996]
Francis Glassborow. Making a date Overload, 3(12):34-36, February 1996. ++puzzle; (PDF)
[Glassborow, 1996]
Francis Glassborow. We have a problem Overload, 3(12):3-7, February 1996. Guest editorial by Francis Glassborow (PDF)
[Glassborow, 1996]
Francis Glassborow. Compiler updates Overload, 3(12):9-11, February 1996. Software Development in C++ (PDF)
[Glassborow, 1996]
Francis Glassborow. Those problems revisited Overload, 4(13):6-9, April 1996. Software Development in C++ (PDF)
[Glassborow, 1996]
Francis Glassborow. Concerning values, left, right and converted Overload, 4(14):3-6, June 1996. Software Development in C++ (PDF)
[Glassborow, 1996]
Francis Glassborow. Return from a member function Overload, 4(14):16, June 1996. C++ Techniques (PDF)
[Glassborow, 1996]
Francis Glassborow. Making string literals constant - a cautionary tale Overload, 4(15):20-23, August 1996. The Draft International C++ Standard (PDF)
[Glassborow, 1996]
Francis Glassborow, Chris Southern, Klitos Kyriacou. The return type of member functions Overload, 4(15):29-33, August 1996. C++ Techniques (PDF)
[Glassborow, 1996]
Francis Glassborow, Kevlin A. P. Henney, Colin Hersom, Graham Jones, Phil Bass, Steve Mertz, Walter Brown. editor << letters; Overload, 4(16):19-24, October 1996. (PDF)
[Glassborow, 1996]
Francis Glassborow. Why is the standard C++ library value based? Overload, 4(16):18-19, October 1996. C++ Techniques (PDF)
[Glassborow, 1996]
Francis Glassborow. Mixing Java & C++ Ruminations Overload, 4(16):13-15, October 1996. Software Development in C++ (PDF)
[Glassborow, 1997]
Francis Glassborow. The uses and abuses of inheritence Overload, 5(17/18):, January 1997. (PDF)
[Glassborow, 1997]
Francis Glassborow. The Problem of Self-Assignment Overload, 5(19):8-9, April 1997. Software Development in C++ (PDF)
[Glassborow, 1997]
Francis Glassborow, Roger Lever. editor << letters; Overload, 5(19):30-31, April 1997. (PDF)
[Glassborow, 1997]
Francis Glassborow. Further Thoughts on Inheritance for Reuse Overload, 5(20):31-35, June 1997. C++ Techniques (PDF)
[Glassborow, 1997]
Francis Glassborow. Getting the Best Overload, 5(21):9-13, August 1997. The Draft International C++ Standard (PDF)
[Glassborow, 1997]
Francis Glassborow. inline delegation Overload, 5(21):21, August 1997. Whiteboard (PDF)
[Glassborow, 1997]
Francis Glassborow. Using Algorithms-Sorting Overload, 5(22):24-26, October 1997. (PDF)
[Glassborow, 1997]
Francis Glassborow. Candidates for inline Overload, 5(23):9-12, December 1997. Software Development in C++ (PDF)
[Glassborow, 1997]
Francis Glassborow. The Casting Vote Overload, 5(23):12-15, December 1997. The Draft International C++ Standard (PDF)
[Glassborow, 1997]
Francis Glassborow. The Story of auto_ptr, A Cautionary Tale Overload, 5(23):15-19, December 1997. The Draft International C++ Standard (PDF)
[Glassborow, 1998]
Francis Glassborow. STL Algorithms: Finding Overload, 6(24):18-22, February 1998. C++ Techniques (PDF)
[Glassborow, 1998]
Francis Glassborow. (Almost) No Casting Vote, Standard’s Report Overload, 6(25):, April 1998. The Draft International C++ Standard (PDF)
[Glassborow, 1998]
Francis Glassborow. Exploring Patterns: Part 1 Overload, 6(26):13-18, June 1998. Patterns in C++ (PDF)
[Glassborow, 1998]
Francis Glassborow. Exploring Patterns Part 2 Overload, 6(27):, August 1998. (PDF)
[Glassborow, 1998]
Francis Glassborow. Exploring Patterns 3 - The Adapter Overload, 6(28):, October 1998. (PDF)
[Glassborow, 1998]
Francis Glassborow. operator == () Overload, 6(29):, December 1998. (PDF)
[Glassborow, 1998]
Francis Glassborow. A Message from the ACCU Chair Overload, 6(29):, December 1998. (PDF)
[Glassborow, 1999]
Francis Glassborow. Patterns - The Abstract Factory Overload, 7(30):, February 1999. (PDF)
[Glassborow, 1999]
Francis Glassborow. Ruminations on Studying Design Patterns Overload, 7(32):, June 1999. (PDF)
[Glassborow, 1999]
Francis Glassborow. Builder & Factory Method Patterns Overload, 7(32):, June 1999. (PDF)
[Glassborow, 1999]
Francis Glassborow. Religious Issues Overload, 7(33):, October 1999. (PDF)
[Glassborow, 2000]
Francis Glassborow. A Response to the C++ SIG Organiser Overload, 8(36):, April 2000. (PDF)
[Glassborow, 2001]
Francis Glassborow. C++ Idioms: First Thoughts Overload, 9(42):, April 2001. (PDF)
[Glassborow, 2018]
Francis Glassborow. C++ with Meta-classes? Overload, 26(143):16-17, February 2018. Meta-classes will allow us to detail class requirements. Francis Glassborow compares them to developments of C++ in the 1990s. (PDF)
[Gloster, 2006]
Colin Paul Gloster, William Fishburne, Seweryn Habdank-Wojewódzki, Rachel Davies. Letters Overload, 14(75):, October 2006. (PDF)
[Goldthwaite, 1998]
Lois Goldthwaite. Static vs Member Functions Overload, 6(29):, December 1998. (PDF)
[Goldthwaite, 2000]
Lois Goldthwaite. Programming with Interfaces in C++ Overload, 8(40):, December 2000. (PDF)
[Goldthwaite, 2003]
Lois Goldthwaite. C++rossword Overload, 11(53):22, February 2003. (PDF)
[Goldthwaite, 2005]
Lois Goldthwaite. C++ Properties - a Library Solution Overload, 13(65):, February 2005. (PDF)
[Golodetz, 2007]
Stuart Golodetz. Functional Programming Using C++ Templates (Part 1) Overload, 15(81):, October 2007. Template metaprogramming can initially seem baffling, but exploring its link to functional programming helps shed some light on things. (PDF)
[Golodetz, 2008]
Stuart Golodetz. Watersheds and Waterfalls Overload, 16(83):, February 2008. An introductory look at segmenting images into regions using a landscape analogy. (PDF)
[Golodetz, 2008]
Stuart Golodetz. Watersheds and Waterfalls (Part 2) Overload, 16(84):, April 2008. Stuart Golodetz continues his survey of algorithms for segmenting images into regions. (PDF)
[Golodetz, 2008]
Stuart Golodetz. RSA Made Simple Overload, 16(85):, June 2008. RSA is a common public key cryptography algorithm. Stuart Golodetz explains the mathematics behind it and shows us how to use it in Java. (PDF)
[Golodetz, 2008]
Stuart Golodetz. Divide and Conquer: Partition Trees and Their Uses Overload, 16(86):, August 2008. The world is a complex place. Stuart Golodetz introduces a powerful technique to describe it. (PDF)
[Golodetz, 2008]
Stuart Golodetz. Seeing Things Differently Overload, 16(87):, October 2008. The Multiple Material Marching Cubes (M3C) algorithm builds 3D models from 2D slices. Stuart Golodetz introduces it and provides a C++ implementation. (PDF)
[Golodetz, 2008]
Stuart Golodetz. The Legion's Revolting! Overload, 16(88):, December 2008. 3D meshes can be too large to deal with efficiently. Stuart Golodetz applies some ancient discipline. (PDF)
[Golodetz, 2009]
Stuart Golodetz. Through The Looking Glass Overload, 17(89):, February 2009. What's happening in the next room? Stuart Golodetz has to find the door first! (PDF)
[Golodetz, 2009]
Stuart Golodetz. If You Can't See Me, I Can't See You Overload, 17(90):, April 2009. Knowing where the doors are is only the start. Stuart Golodetz works out what he can see through them. (PDF)
[Golodetz, 2009]
Stuart Golodetz. I Think I'll Parse Overload, 17(92):, August 2009. A parser is a fundamental tool in software development. Stuart Golodetz looks at how you might tackle writing one. (PDF)
[Golodetz, 2010]
Stuart Golodetz. Simplifying the C++/Angelscript Binding Process Overload, 18(95):, February 2010. Many systems provide a scripting language. Stuart Golodetz shows how to make it easier. (PDF)
[Golodetz, 2013]
Stuart Golodetz. Automatic Navigation Mesh Generation in Configuration Space Overload, 21(117):22-27, October 2013. Walkable 3D environments can be automatically navigated. Stuart Golodetz demonstrates how navigation meshes achieve this. (PDF)
[Golodetz, 2013]
Stuart Golodetz. Object-Environment Collision Detection using Onion BSPs Overload, 21(118):10-15, December 2013. Previously we considered 3D navigation. Stuart Golodetz demonstrates how to detect collisions using onion binary space partitioning. (PDF)
[Goodliffe, 2000]
Pete Goodliffe. An Application of Pointers to Members Overload, 8(36):, April 2000. (PDF)
[Goodliffe, 2000]
Pete Goodliffe. A framework for object serialization in C++ Overload, 8(37):, June 2000. (PDF)
[Goodliffe, 2000]
Pete Goodliffe. Experiences of Implementing the Observer Design Pattern (Part 1) Overload, 8(37):, June 2000. (PDF)
[Goodliffe, 2000]
Pete Goodliffe. Experiences of Implementing the Observer Design Pattern (Part 2) Overload, 8(38):, August 2000. (PDF)
[Goodliffe, 2001]
Pete Goodliffe. Experiences of Implementing the Observer Design Pattern (Part 3) Overload, 9(41):, February 2001. (PDF)
[Goodliffe, 2001]
Pete Goodliffe. Techniques for Debugging in C++ Overload, 9(46):, December 2001. (PDF)
[Goodliffe, 2002]
Pete Goodliffe. STL-style Circular Buffers By Example Overload, 10(50):, August 2002. (PDF)
[Goodliffe, 2002]
Pete Goodliffe. STL-style Circular Buffers By Example, Part Two Overload, 10(51):, October 2002. (PDF)
[Goodliffe, 2003]
Pete Goodliffe. Letters to the Editor(s) Overload, 11(57):, October 2003. (PDF)
[Goodliffe, 2005]
Pete Goodliffe. A Technique for Register Access in C++ Overload, 13(68):, August 2005. This article discusses a C++ scheme for accessing hardware registers in an optimal way. (PDF)
[Goodliffe, 2009]
Pete Goodliffe. Creating a Framework for the iPhone Overload, 17(94):7--10, December 2009. Apple’s iPhone SDK doesn’t allow you to create a Framework. Pete Goodliffe explains how to build one manually. (PDF)
[Gough, 2003]
Raoul Gough. Choosing Template Parameters Overload, 11(58):, December 2003. (PDF)
[Gough, 2007]
Raoul Gough, Hubert Matthews, Peter Sommerlad. Letters to the Editor Overload, 15(78):, April 2007. (PDF)
[Gradman, 2001]
Corwin Joy, Michael Gradman. Introduction to the Database Template Library Overload, 9(43):, June 2001. (PDF)
[Grenyer, 2004]
Paul Grenyer. All Heap No Leaks Overload, 12(60):, April 2004. (PDF)
[Grenyer, 2004]
Paul Grenyer, Jez Higgins. ACCU Mentored Developers XML Project Overload, 12(62):, August 2004. (PDF)
[Grenyer, 2005]
Paul Grenyer. Multiple Streams Going Nowhere Overload, 13(65):, February 2005. Source: C++ output streams ostream (PDF)
[Grenyer, 2005]
Paul Grenyer. Digging a Ditch Overload, 13(66):, April 2005. (PDF)
[Grenyer, 2007]
Paul Grenyer. Continuous Integration with CruiseControl.Net Overload, 15(79):, June 2007. Is CC any good? How could it be better? Did it make a real difference where it was installed? Should we all give it a go? (PDF)
[Grenyer, 2007]
Paul Grenyer. Letter to the Editor Overload, 15(80):, August 2007. (PDF)
[Grenyer, 2008]
Paul Grenyer. Testing Visiting Files and Directories in C# Overload, 16(83):, February 2008. Testing code that accesses the file system is not straightforward. Paul Grenyer looks at what is involved. (PDF)
[Grenyer, 2008]
Paul Grenyer. Model View Controller with Java Swing Overload, 16(88):, December 2008. It's recommended to keep user interface and data model separate. Paul Grenyer looks a common solution. (PDF)
[Grenyer, 2009]
Paul Grenyer. Boiler Plating Database Resource Cleanup (Part 2) Overload, 17(91):, June 2009. Timely disposal of resources is important. Paul Grenyer applies this to database access in Java. (PDF)
[Grenyer, 2011]
Paul Grenyer. An Introduction to Test Driven Development Overload, 19(104):13-20, August 2011. TDD is too often thought to be all about Unit Tests. Paul Grenyer works through an example to show the bigger picture. (PDF)
[Grenyer, 2011]
Paul Grenyer. RAII is not Garbage Overload, 19(106):14-15, December 2011. Many think that Garbage Collection frees the programmer from cleanup tasks. Paul Grenyer compares and contrasts it with a classic C++ idiom. (PDF)
[Grenyer, 2017]
Paul Grenyer. The Last Word in Patterns Overload, 25(142):10, December 2017. What can you do in a single transaction in a database? Paul Grenyer writes us his Single CrUD pattern. (PDF)
[Griffiths, 1995]
Alan Griffiths. No such thing as a free lunch Overload, 3(7):3-10, April 1995. (PDF)
[Griffiths, 1995]
Alan Griffiths. When is an “is a” not an “is a”? Overload, 3(10):11-13, October 1995. Software Development in C++ (PDF)
[Griffiths, 1996]
Alan Griffiths. Notes on Microsoft Visual C++ V4.0 Overload, 3(12):11-13, February 1996. Software Development in C++ (PDF)
[Griffiths, 1996]
Sean A. Corfield, Dave Midgley, Roger Lever, Chris Simons, Andrew King, Alan Griffiths, Jay. editor << letters; Overload, 3(12):, February 1996. (PDF)
[Griffiths, 1997]
Alan Griffiths. Editorial Overload, 5(19):3, April 1997. (PDF)
[Griffiths, 1997]
Alan Griffiths. They pursued it with forks and hope. Overload, 5(21):32-34, August 1997. News, Views, & Reviews (PDF)
[Griffiths, 1997]
Alan Griffiths. Premature Optimisation Overload, 5(22):21-23, October 1997. (PDF)
[Griffiths, 1998]
Alan Griffiths. Almost a Pattern Overload, 6(27):, August 1998. (PDF)
[Griffiths, 1999]
Alan Griffiths. Fitting in with multiple frameworks in C++ and Java Overload, 7(31):, April 1999. (PDF)
[Griffiths, 1999]
Alan Griffiths. Goodbye Overload Overload, 7(31):, April 1999. (PDF)
[Griffiths, 1999]
Alan Griffiths. The EPOC C++ API Overload, 7(32):, June 1999. (PDF)
[Griffiths, 1999]
Alan Griffiths. Uncounted pointers in C++ Overload, 7(34):, December 1999. (PDF)
[Griffiths, 2000]
Alan Griffiths. editorial Overload, 8(36):, April 2000. (PDF)
[Griffiths, 2000]
Alan Griffiths, Allan Newton. Interpreting "Supporting the 'Cheshire Cat' Idiom" Overload, 8(38):, August 2000. (PDF)
[Griffiths, 2000]
Alan Griffiths. Here be Dragons Overload, 8(40):, December 2000. (PDF)
[Griffiths, 2001]
Alan Griffiths. C++ Standards - The "swap" Problem Overload, 9(41):, February 2001. (PDF)
[Griffiths, 2001]
Alan Griffiths. Compile Time Indirection - An Unusual Template Technique Overload, 9(42):, April 2001. (PDF)
[Griffiths, 2001]
Alan Griffiths. Using Version Control Overload, 9(44):, August 2001. (PDF)
[Griffiths, 2002]
Alan Griffiths. Exceptional Java Overload, 10(48):, April 2002. (PDF)
[Griffiths, 2002]
Alan Griffiths. More Exceptional Java Overload, 10(49):, June 2002. (PDF)
[Griffiths, 2002]
Alan Griffiths. Execute Around Method and Proxy Goulash Overload, 10(50):, August 2002. (PDF)
[Griffiths, 2002]
Alan Griffiths. Mutate? or Create? Overload, 10(51):, October 2002. (PDF)
[Griffiths, 2003]
Alan Griffiths. Editorial Overload, 11(55):, June 2003. (PDF)
[Griffiths, 2003]
Alan Griffiths. Editorial Overload, 11(56):, August 2003. (PDF)
[Griffiths, 2003]
Alan Griffiths. Three Phantastic Tales Overload, 11(56):, August 2003. (PDF)
[Griffiths, 2003]
Alan Griffiths. Editorial Overload, 11(57):, October 2003. (PDF)
[Griffiths, 2003]
Alan Griffiths. Chaos Theory Overload, 11(57):, October 2003. (PDF)
[Griffiths, 2003]
Alan Griffiths. Editorial Overload, 11(58):, December 2003. (PDF)
[Griffiths, 2004]
Alan Griffiths. Heretical Java #1 Overload, 12(59):, February 2004. (PDF)
[Griffiths, 2004]
Alan Griffiths. Achieving FitNesse in C++ Overload, 12(60):, April 2004. (PDF)
[Griffiths, 2004]
Alan Griffiths. Editorial: New Things Under the Sun Overload, 12(61):, June 2004. (PDF)
[Griffiths, 2004]
Alan Griffiths. When is a "Pattern" not a "Pattern"? Overload, 12(61):, June 2004. (PDF)
[Griffiths, 2004]
Alan Griffiths. Editorial: The Value of What You Know Overload, 12(62):, August 2004. (PDF)
[Griffiths, 2004]
Alan Griffiths. Editorial: A Glimpse Behind the Scenes Overload, 12(64):, December 2004. (PDF)
[Griffiths, 2005]
Alan Griffiths. Editorial: "They" Have Their Reasons Overload, 13(65):, February 2005. (PDF)
[Griffiths, 2005]
Alan Griffiths. Letters: Encapsulate Context Overload, 13(65):, February 2005. (PDF)
[Griffiths, 2005]
Alan Griffiths, Mark Radford. Separating Interface and Implementation in C++ Overload, 13(66):, April 2005. (PDF)
[Griffiths, 2005]
Alan Griffiths. "The C++ Community" - Are We Divided by a Common Language? Overload, 13(67):, June 2005. (PDF)
[Griffiths, 2005]
Alan Griffiths. Editorial: Does all this help make better software? Overload, 13(67):, June 2005. (PDF)
[Griffiths, 2005]
Alan Griffiths. Editorial: Size Does Matter Overload, 13(68):, August 2005. The way that one goes about developing and delivering a software project depends critically on the scale of the project. Discuss. (PDF)
[Griffiths, 2005]
Alan Griffiths. Editorial: Can We Change For The Better? Overload, 13(69):, October 2005. (PDF)
[Griffiths, 2005]
Alan Griffiths. "Here be Dragons" Overload, 13(70):, December 2005. (PDF)
[Griffiths, 2005]
Alan Griffiths. Editorial: The "Safe C++ Standard Library" Overload, 13(70):, December 2005. (PDF)
[Griffiths, 2006]
Alan Griffiths. Editorial: Keeping Up Standards Overload, 14(71):4-6, February 2006. (PDF)
[Griffiths, 2006]
Alan Griffiths. C++ Best Practice - Designing Header Files Overload, 14(72):, April 2006. (PDF)
[Griffiths, 2006]
Alan Griffiths. To Grin Again Overload, 14(72):, April 2006. (PDF)
[Griffiths, 2006]
Alan Griffiths. Editorial: Doing What You Can Overload, 14(72):, April 2006. (PDF)
[Griffiths, 2006]
Alan Griffiths. Editorial Overload, 14(73):, June 2006. (PDF)
[Griffiths, 2006]
Alan Griffiths. Take a Step Forward Overload, 14(74):, August 2006. Editorial (PDF)
[Griffiths, 2006]
Alan Griffiths. Life in the Fast Lane Overload, 14(75):, October 2006. The ISO Fast-Track is paved with good intentions, but does it lead where we want to be? (PDF)
[Griffiths, 2006]
Alan Griffiths. How Overload Comes to You Overload, 14(76):, December 2006. You look forward to Overload arriving in the mail every couple of months. This time it came very close to not arriving at all. (PDF)
[Griffiths, 2007]
Alan Griffiths. The Power of Inertia Overload, 15(77):, February 2007. (PDF)
[Griffiths, 2007]
Alan Griffiths. New Tricks for an Old Dog Overload, 15(78):, April 2007. (PDF)
[Griffiths, 2007]
Alan Griffiths. Rip It Up and Start Again Overload, 15(79):, June 2007. (PDF)
[Griffiths, 2007]
Alan Griffiths. Consensus Overload, 15(80):, August 2007. It should be obvious that the process of agreeing effective standards must be dependant on attaining consensus. (PDF)
[Griffiths, 2007]
Alan Griffiths. The Essence of Success Overload, 15(82):, December 2007. (PDF)
[Griffiths, 2008]
Alan Griffiths. After Four Years Overload, 16(84):, April 2008. After four years as editor of Overload it is time for a change. (PDF)
[Griffiths, 2009]
Alan Griffiths, Marc Allan. Software Development in the 21st Century Overload, 17(90):, April 2009. What's the future of software development? Alan Griffiths and Marc Allan have a timely look at recent experiences. (PDF)
[Griffiths, 2010]
Alan Griffiths. Renovating a Legacy C++ Project Overload, 18(98):12-15, August 2010. Over time projects tend to become hard to maintain. Alan Griffiths describes how one was improved. (PDF)
[Griffiths, 2011]
Alan Griffiths. Moving with the Times Overload, 19(106):4-5, December 2011. The ACCU is primarily a way for programmers to communicate. Alan Griffiths looks at its past, and speculates on its future. (PDF)
[Griffiths, 2014]
Alan Griffiths. Designing Observers in C++11 Overload, 22(124):4-5, December 2014. The observer pattern is over two decades old. Alan Griffiths fits a venerable design pattern into a contemporary context. (PDF)
[Griffiths, 2015]
Alan Griffiths. Building and Running Software on an Ubuntu Phone Overload, 23(129):9-11, October 2015. Many of us has a smartphone. Alan Griffiths shows us how to hack an Ubuntu Touch phone. (PDF)
[Griffiths, 2016]
Alan Griffiths. The MirAL Story Overload, 24(136):4-5, December 2016. The X-Windows system is all-pervasive but struggles with security and performance graphics. Alan Griffiths introduces Mir Abstraction Layer to deal with these issues. (PDF)
[Grigoriev, 2015]
Vladimir Grigoriev. iterator_pair - A Simple and Useful Iterator Adapter Overload, 23(126):23-31, April 2015. Can you form a new container from two others? Vladimir Grigoriev reminds us how to write an iterator. (PDF)
[Guest, 2004]
Thomas Guest. A Mini-project to Decode a Mini-language - Part One Overload, 12(63):, October 2004. (PDF)
[Guest, 2004]
Thomas Guest. Mini-project to Decode A Mini-language - Part Two Overload, 12(64):, December 2004. (PDF)
[Guest, 2005]
Thomas Guest. Metaprogramming is Your Friend Overload, 13(66):, April 2005. (PDF)
[Guest, 2006]
Thomas Guest. Soft Documentation Overload, 14(71):7-12, February 2006. (PDF)
[Guest, 2006]
Thomas Guest. The Case Against TODO Overload, 14(73):, June 2006. TODO - a neat way to label work in progress or an easy way to disguise the flaws in a codebase? (PDF)
[Guest, 2006]
Thomas Guest. From CVS to Subversion Overload, 14(75):, October 2006. Thomas Guest reflects on migrating his organisation's version control system from CVS to Subversion. (PDF)
[Guest, 2007]
Thomas Guest. He Sells Shell Scripts to Intersect Sets Overload, 15(80):, August 2007. Graphical User Interfaces are in great demand but for some tasks there are better tools. Thomas Guest demonstrates the capabilities of command shells. (PDF)
[Guest, 2016]
Thomas Guest. Python Streams vs Unix Pipes Overload, 24(136):20-24, December 2016. Dealing with an infinite sequence requires some thought. Thomas Guest presents various ways to approach such a problem. (PDF)
[Guest, 2009]
Tom Guest. Code Rot Overload, 17(92):, August 2009. Maintaining code is vital to keep it working. Tom Guest explores what happens when you neglect it. (PDF)
[Gutjahr, 2015]
Lion Gutjahr, Thaddaeus Frogley. Letter to the Editor Overload, 23(125):22-24, February 2015. With response. (PDF)
[Gutson, 2012]
Hugo Arregui, Carlos Castro, Daniel Gutson. Curiously Recursive Template Problems with Aspect Oriented Programming Overload, 20(109):20-23, June 2012. (PDF)
[Gutson, 2014]
Daniel Gutson, Pablo Oliva. Minimal Overhead for Multiple Interfaces Overload, 22(121):14-16, June 2014. Using multiple interfaces can slow things down. Daniel Gutson and Pablo Oliva present an alternative. (PDF)
[Habdank-Wojewódzki, 2006]
Seweryn Habdank-Wojewódzki, Janusz Rybarski. The Kohonen Neural Network Library Overload, 14(74):, August 2006. Seweryn Habdank-Wojewódzki and Janusz Rybarski present a C++ library for users of Kohonen Neural Networks. (PDF)
[Habdank-Wojewódzki, 2006]
Colin Paul Gloster, William Fishburne, Seweryn Habdank-Wojewódzki, Rachel Davies. Letters Overload, 14(75):, October 2006. (PDF)
[Habdank-Wojewódzki, 2007]
Seweryn Habdank-Wojewódzki. C++ Trivial Logger Overload, 15(77):, February 2007. When a fully functional logging subsystem isn't the answer what does one do? Seweryn Habdank-Wojewódzki rolls his own. (PDF)
[Hagan, 1998]
Ken Hagan, The Harpist. Exception Discussion Overload, 6(29):, December 1998. (PDF)
[Hagan, 1999]
Ken Hagan, The Harpist. A Letter from Ken Hagan annotated by The Harpist Overload, 7(30):, February 1999. (PDF)
[Hagan, 2003]
Ken Hagan. Statically Checking Exception Specifications Overload, 11(57):, October 2003. (PDF)
[Hall, 1997]
Ray Hall. Whence Objects? Overload, 5(20):5-7, June 1997. Software Development in C++ (PDF)
[Hall, 1997]
Ray Hall. The C&C++ European Developers Forum Overload, 5(21):30-32, August 1997. News, Views, & Reviews (PDF)
[Hall, 1999]
Ray Hall. editor << letters; Overload, 7(30):, February 1999. (PDF)
[Hammond, 2005]
Peter Hammond. Can C++ Learn from Generics in Ada? Overload, 13(67):, June 2005. (PDF)
[Hammond, 2005]
Peter Hammond. A Framework for Generating Numerical Test Data Overload, 13(69):, October 2005. (PDF)
[Hanhinen, 2017]
Ossi Hanhinen. Space invaders in Elm Overload, 25(138):4-6, April 2017. Elm is a functional language which compiles to JavaScript. Ossi Hanhinen provides an overview. (PDF)
[Hariri, 2017]
Hadi Hariri. Kotlin for C++ Developers Overload, 25(139):16-17, June 2017. What could a language the originated on the JVM possibly offer C or C++ devs? Hadi Hariri tells us. (PDF)
[Harkness, 1996]
Sean A. Corfield, Remi Sellem, Bryan Colyer, Phil Bass, Colin Harkness, Steve Watson. editor << letters; Overload, 4(14):18-19, June 1996. (PDF)
[Harris, 2007]
Richard Harris. auto_value: Transfer Semantics for Value Types Overload, 15(79):, June 2007. std::auto_ptr has a reputation for causing problems due to its surprising copy/assignment semantics. Richard Harris tries to separate the good ideas from the bad. (PDF)
[Harris, 2007]
Richard Harris. auto_value: Transfer Semantics for Value Types Overload, 15(80):, August 2007. "Copy On Write" (COW) sounds like an ideal idiom for avoiding expensive copies. But care must be taken to avoid producing a "mad cow". (PDF)
[Harris, 2007]
Richard Harris. auto_value: Transfer Semantics for Value Types Overload, 15(81):, October 2007. In his quest to pass around values efficiently, Richard Harris concludes by looking at ways of transferring ownership, now and in the future. (PDF)
[Harris, 2007]
Richard Harris. The Model Student Overload, 15(82):, December 2007. Richard Harris begins a series of articles exploring some of the mathematics of interest to those modelling problems with computers. Part 1: The Regular Travelling Salesman. (PDF)
[Harris, 2008]
Richard Harris. The Regular Travelling Salesman, Part 2 Overload, 16(83):, February 2008. Richard Harris explores more of the mathematics of modelling problems with computers. (PDF)
[Harris, 2008]
Richard Harris. The Model Student: A Knotty Problem, Part 1 Overload, 16(84):, April 2008. Richard Harris explores more of the mathematics of modelling problems with computers. (PDF)
[Harris, 2008]
Richard Harris. The Model Student: A Knotty Problem, Part 2 Overload, 16(85):, June 2008. Tying yourself in knots is easy. Richard Harris cuts through the complexity. (PDF)
[Harris, 2008]
Richard Harris. The Model Student: Can Chance Make Fine Things? (Part 1) Overload, 16(87):, October 2008. Evolution involves a random process. Richard Harris compares the mathematics to that of blind chance. (PDF)
[Harris, 2008]
Richard Harris. The Model Student: Can Chance Make Fine Things? (Part 2) Overload, 16(88):, December 2008. How well does evolution find solutions? Richard Harris models population change. (PDF)
[Harris, 2009]
Richard Harris. The Model Student: A Rube-ish Square (Part 1) Overload, 17(89):, February 2009. We all have nostalgia for favourite childhood toys. Richard Harris looks at the maths behind a classic. (PDF)
[Harris, 2009]
Richard Harris. The Model Student: A Rube-ish Square (Part 2) Overload, 17(90):, April 2009. A rube-ish square embodies some simple group theory. Richard Harris explores its properties. (PDF)
[Harris, 2009]
Richard Harris. The Model Student: The Enigma Challenge Overload, 17(91):, June 2009. Codebreaking was instrumental to computing history. Richard Harris presents a simplified Enigma code for you to crack. (PDF)
[Harris, 2009]
Richard Harris. The Model Student: A Primal Skyline (Part 1) Overload, 17(92):, August 2009. Prime numbers are the 'building blocks' of the integers. Richard Harris investigates how they're combined. (PDF)
[Harris, 2009]
Richard Harris. The Model Student: A Primal Skyline (Part 2) Overload, 17(93):, October 2009. How do you measure the length of a curve? Richard Harris gets his ruler out. (PDF)
[Harris, 2009]
Richard Harris. The Model Student: A Primal Skyline (Part 3) Overload, 17(94):11--16, December 2009. The prime factors of the integers show some repeating patterns. Richard Harris investigates whether they have fractal properties. (PDF)
[Harris, 2010]
Richard Harris. The Model Student: A Game of Six Integers (Part 1) Overload, 18(95):, February 2010. In how many ways can you combine a set of numbers? Richard Harris gets counting. (PDF)
[Harris, 2010]
Richard Harris. The Model Student: A Game of Six Integers (Part 2) Overload, 18(96):, April 2010. What are the properties of the Numbers Game? Richard Harris continues his analysis. (PDF)
[Harris, 2010]
Richard Harris. The Model Student: A Game of Six Integers (Part 3) Overload, 18(97):, June 2010. We now have the tools to analyse the Countdown Numbers Game. Richard Harris is ready to play. (PDF)
[Harris, 2010]
Richard Harris. The Model Student: The ACCU 2010 Crypto Challenge Overload, 18(98):9-11, August 2010. Electronic computers advanced cryptography enormously. Richard Harris sets a challenge, and finds a solution. (PDF)
[Harris, 2010]
Richard Harris. You're Going To Have To Think! Overload, 18(99):4-9, October 2010. Numerical computing has many pitfalls. Richard Harris starts looking for a silver bullet. (PDF)
[Harris, 2010]
Richard Harris. Why Fixed Point Won’t Cure Your Floating Point Blues Overload, 18(100):14-21, December 2010. Numeric computing is very difficult to do properly. Richard Harris looks at whether a common technique will help. (PDF)
[Harris, 2011]
Richard Harris. Why Rationals Won’t Cure Your Floating Point Blues Overload, 19(101):8-11, February 2011. Numerical computing is still proving hard to do accurately. Richard Harris considers another number representation. (PDF)
[Harris, 2011]
Richard Harris. Why Computer Algebra Won’t Cure Your Floating Point Blues Overload, 19(102):8-13, April 2011. Numerical computing is proving quite a challenge. Richard Harris sees if a computer can do mathematics. (PDF)
[Harris, 2011]
Richard Harris. The ACCU 2011 Crypto Challenge Overload, 19(103):31-36, June 2011. Ready for the biggest challenge yet? Richard Harris throws down the gauntlet. (PDF)
[Harris, 2011]
Richard Harris. Why Interval Arithmetic Won’t Cure Your Floating Point Blues Overload, 19(103):18-23, June 2011. We’ve looked at several approaches to numeric computing. Richard Harris has a final attempt to find an accurate solution. (PDF)
[Harris, 2011]
Richard Harris. Why [Insert Algorithm Here] Won’t Cure Your Calculus Blues Overload, 19(104):21-24, August 2011. We now know that floating point arithmetic is the best we can do. Richard Harris goes back to school ready to show how to use it. (PDF)
[Harris, 2011]
Richard Harris. Why Finite Differences Won’t Cure Your Calculus Blues Overload, 19(105):4-11, October 2011. Now we know our problem in depth. Richard Harris analyses if a common technique will work adequately. (PDF)
[Harris, 2011]
Richard Harris. Why Polynomial Approximation Won't Cure Your Calculus Blues Overload, 19(106):16-24, December 2011. We’re still trying to find a good way to approach numerical computing. Richard Harris tries to get as close as possible. (PDF)
[Harris, 2012]
Richard Harris. Why Computer Algebra Won’t Cure Your Calculus Blues Overload, 20(107):14-19, February 2012. We still haven’t found how to accurately do calculus. Richard Harris revisits an algebraic technique. (PDF)
[Harris, 2012]
Richard Harris. Why Automatic Differentiation Won’t Cure Your Calculus Blues Overload, 20(108):4-11, April 2012. We’ve tried and rejected many numerical approaches to differentiation. Richard Harris has one final attempt. (PDF)
[Hastings, 2005]
William Hastings. Polynomial Classes Overload, 13(69):, October 2005. (PDF)
[Heinzmann, 2003]
Stefan Heinzmann, Phil Bass. Observer Pattern Implementation Overload, 11(54):, April 2003. (PDF)
[Heinzmann, 2004]
Stefan Heinzmann, Phil Bass. A Template Programmer’s Struggles Resolved Overload, 12(61):, June 2004. (PDF)
[Heinzmann, 2004]
Stefan Heinzmann. The Tale of a Struggling Template Programmer Overload, 12(61):, June 2004. (PDF)
[Heinzmann, 2004]
Stefan Heinzmann. Yet Another Hierarchical State Machine Overload, 12(64):, December 2004. (PDF)
[Hennessy, 2005]
Pippa Hennessy. Sheep Farming for Software Development Managers Overload, 13(66):, April 2005. (PDF)
[Henney, 1994]
Kevlin Henney. Do birds in their little nests always agree? Overload, 2(4):, February 1994. (PDF)
[Henney, 1994]
Kevlin Henney. Writing Your Own Stream Manipulators Overload, 2(5):16-18, September 1994. (PDF)
[Henney, 1995]
Kevlin Henney. An alternative to wchar_t Overload, 3(6):, March 1995. (PDF)
[Henney, 1995]
Kevlin Henney. editor << letters; Overload, 3(7):37-38, April 1995. (PDF)
[Henney, 1995]
Kevlin Henney. Overloading on const and other stories Overload, 3(7):15-17, April 1995. (PDF)
[Henney, 1995]
Kevlin Henney. Circle & Ellipse - Vicious Circles Overload, 3(8):23-27, June 1995. (PDF)
[Henney, 1995]
Kevlin Henney. cv-qualified constructors Overload, 3(8):15-18, June 1995. The Draft International C++ Standard (PDF)
[Henney, 1995]
Kevlin Henney. Seduction: The Last? - Applying the STL mindset Overload, 3(9):7-12, August 1995. (PDF)
[Henney, 1995]
Kevlin Henney. Uncontained - oddities and oversights in the standard library Overload, 3(9):21-23, August 1995. The Draft International C++ Standard (PDF)
[Henney, 1995]
Kevlin Henney. /tmp/late/* Generating constants with templates Overload, 3(11):37-39, December 1995. C++ Techniques (PDF)
[Henney, 1995]
Kevlin Henney. Change of address Overload, 3(11):34-37, December 1995. C++ Techniques (PDF)
[Henney, 1995]
Kevlin Henney. Literally yours Overload, 3(11):21-22, December 1995. The Draft International C++ Standard (PDF)
[Henney, 1995]
Kevlin Henney. Anonymously yours Overload, 3(11):22-23, December 1995. The Draft International C++ Standard (PDF)
[Henney, 1996]
Kevlin Henney. /tmp/late/* Constraining template parameter types Overload, 3(12):23-26, February 1996. C++ Techniques (PDF)
[Henney, 1996]
Kevlin Henney. Rot in L Overload, 3(12):18-19, February 1996. C++ Techniques (PDF)
[Henney, 1996]
Kevlin Henney. /tmp/late/* Specifying integer size Overload, 4(13):27-30, April 1996. C++ Techniques (PDF)
[Henney, 1996]
Kevlin Henney. questions->answers Overload, 4(13):31-33, April 1996. (PDF)
[Henney, 1996]
Kevlin Henney. /tmp/late/* Constraining template parameter values Overload, 4(15):33-35, August 1996. C++ Techniques (PDF)
[Henney, 1996]
Kevlin Henney. questions->answers Overload, 4(16):24-27, October 1996. (PDF)
[Henney, 1996]
Kevlin Henney. Some OOD answers Overload, 4(16):4-8, October 1996. Software Development in C++ (PDF)
[Henney, 1997]
Kevlin Henney. Make a date with C++: In the Beginning... Overload, 5(19):12-14, April 1997. Software Development in C++ (PDF)
[Henney, 1997]
Kevlin Henney. Make a date with C++: Typing Lessons Overload, 5(20):10-13, June 1997. C++ Techniques (PDF)
[Henney, 1997]
Kevlin Henney. Self Assignment? No Problem! Overload, 5(20):17-25, June 1997. C++ Techniques (PDF)
[Henney, 1997]
Kevlin Henney, Richard Percy, Jonathan Jagger. editor << letters; Overload, 5(20):36-37, June 1997. (PDF)
[Henney, 1997]
Kevlin Henney. Safe Assignment? No Problem! Overload, 5(21):14-17, August 1997. C++ Techniques (PDF)
[Henney, 1997]
Kevlin Henney. Make a date with C++ Independence of Declaration Overload, 5(21):18-20, August 1997. C++ Techniques (PDF)
[Henney, 1997]
Kevlin Henney. Allocation Stats Overload, 5(22):5-8, October 1997. (PDF)
[Henney, 1997]
Kevlin Henney. Make a date with C++ And so to const Overload, 5(22):15-20, October 1997. (PDF)
[Henney, 1998]
Kevlin Henney. Embed with C++ Overload, 6(24):9-13, February 1998. The Draft International C++ Standard (PDF)
[Henney, 1998]
Kevlin Henney. Counted Body Techniques Overload, 6(25):1-7, April 1998. Software Development in C++ (PDF)
[Henney, 1998]
Kevlin Henney. Make a date with C++, A Touch of Class Overload, 6(26):3-7, June 1998. Software Development in C++ (PDF)
[Henney, 1999]
Kevlin Henney. Coping with Copying in C++ Overload, 7(33):, October 1999. (PDF)
[Henney, 1999]
Kevlin Henney. The Diary of Bridget Jones the Weekend Before OT Overload, 7(34):, December 1999. (PDF)
[Henney, 2000]
Kevlin Henney. C++ Patterns Source Cohesion and Decoupling Overload, 8(39):, October 2000. (PDF)
[Henney, 2000]
Kevlin Henney. From Mechanism to Method: Substitutability Overload, 8(39):, October 2000. (PDF)
[Henney, 2000]
Kevlin Henney. From Mechanism to Method: Valued Conversions Overload, 8(40):, December 2000. (PDF)
[Henney, 2001]
Kevlin Henney. minimalism Overload, 9(45):, October 2001. (PDF)
[Henney, 2002]
Kevlin Henney. minimalism Overload, 10(47):, February 2002. (PDF)
[Henney, 2002]
Kevlin Henney. Minimalist Constructive Criticism Overload, 10(47):, February 2002. (PDF)
[Henney, 2002]
Kevlin Henney. From Mechanism to Method: Function Follows Form Overload, 10(48):, April 2002. (PDF)
[Henney, 2002]
Kevlin Henney. Letter To The Editor Overload, 10(49):, June 2002. (PDF)
[Henney, 2002]
Kevlin Henney. From Mechanism to Method: Good Qualifications Overload, 10(52):, December 2002. (PDF)
[Henney, 2003]
Kevlin Henney. From Mechanism to Method: Total Ellipse Overload, 11(53):14-18, February 2003. (PDF)
[Henney, 2003]
Kevlin Henney. From Mechanism to Method: Distinctly Qualified Overload, 11(55):, June 2003. (PDF)
[Henney, 2003]
Kevlin Henney. From Mechanism to Method: Data Abstraction and Heterarchy Overload, 11(58):, December 2003. (PDF)
[Henney, 2004]
Kevlin Henney. From Mechanism to Method: Further Qualifications Overload, 12(59):, February 2004. (PDF)
[Henney, 2004]
Kevlin Henney. From Mechanism to Method: Generic Decoupling Overload, 12(60):, April 2004. (PDF)
[Henney, 2004]
Kevlin Henney. From Mechanism to Method: The Safe Stacking of Cats Overload, 12(62):, August 2004. Source: cats, curling, exceptions (PDF)
[Henney, 2005]
Kevlin Henney. Stable Intermediate Forms Overload, 13(65):, February 2005. (PDF)
[Henney, 2005]
Kevlin Henney. C-side Re-sort Overload, 13(68):, August 2005. In spite of the attention given to object-oriented development, TDD and modern testing frameworks, it is worth understanding how and why unit testing has an important role to play in general, regardless of the technologies or broader development philosophy involved. This article walks through a simple example, highlighting some of the motivation behind basic unit testing and the practices involved but without following through into TDD. (PDF)
[Henney, 2005]
Kevlin Henney. Vorsprung Durch Testing Overload, 13(69):, October 2005. (PDF)
[Henney, 2007]
Kevlin Henney. The PfA Papers: From the Top Overload, 15(80):, August 2007. A characteristic of patterns is that experienced developers often experience a moment of recognition upon reading the write up. Sometimes the write up isn't even needed... (PDF)
[Henney, 2007]
Kevlin Henney. The PfA Papers: The Clean Dozen Overload, 15(81):, October 2007. Patterns are social animals and are often found in the company of others. This issue, Kevlin Henney looks at where 'Parameterise from Above' has been hanging out. (PDF)
[Henney, 2007]
Kevlin Henney. The PfA Papers: Context Matters Overload, 15(82):, December 2007. Continuing his history of Parameterise from Above, Kevlin Henny looks at Singletons and Context Objects. (PDF)
[Henney, 2008]
Kevlin Henney. The PfA Papers: Deglobalisation Overload, 16(83):, February 2008. More history of Parameterise from Above as Kevlin Henney looks at Simpletons and the Borg (PDF)
[Henney, 2011]
Kevlin Henney. Rise of the Machines Overload, 19(101):20, February 2011. Sometimes the world really is out to get you. Kevlin Henney identifies some culprits. (PDF)
[Henney, 2013]
Kevlin Henney. The Uncertainty Principle Overload, 21(115):29, June 2013. Not being sure of something is usually thought of as a problem. Kevlin Henney argues to the contrary. (PDF)
[Henney, 2014]
Kevlin Henney. Feeding Back Overload, 22(123):28, October 2014. Kevlin Henney contemplates how to make feedback useful. (PDF)
[Henney, 1996]
Francis Glassborow, Kevlin A. P. Henney, Colin Hersom, Graham Jones, Phil Bass, Steve Mertz, Walter Brown. editor << letters; Overload, 4(16):19-24, October 1996. (PDF)
[Henricson, 1995]
Mats Henricson, Erik Nyquist. operator= and const - a reply Overload, 3(7):18, April 1995. (PDF)
[Henricson, 1995]
Mats Henricson. Writing “Industrial Strength C++” Overload, 3(8):44-46, June 1995. Books and Journals (PDF)
[Hersom, 1996]
Francis Glassborow, Kevlin A. P. Henney, Colin Hersom, Graham Jones, Phil Bass, Steve Mertz, Walter Brown. editor << letters; Overload, 4(16):19-24, October 1996. (PDF)
[Higgins, 2004]
Paul Grenyer, Jez Higgins. ACCU Mentored Developers XML Project Overload, 12(62):, August 2004. (PDF)
[Hills, 2003]
Chris Hills. A Standard Individual: A Licensed Engineer Overload, 11(58):, December 2003. (PDF)
[Holgate, 2014]
Len Holgate. Activatable Object Overload, 22(122):11-13, August 2014. Using locks will slow down threaded code. Len Holgate demonstrates how an Activatable Object can reduce the time spent blocked. (PDF)
[Horwill, 1993]
Ian Horwill. Windows File Class Overload, 1(3):, August 1993. (PDF)
[Horwill, 1995]
Ian Horwill. Wait for me! - copying and assignment Overload, 3(7):23-24, April 1995. (PDF)
[Horwill, 1995]
Ian Horwill. editor << letters; Overload, 3(7):35-36, April 1995. (PDF)
[Horwill, 1995]
Ian Horwill. editor << letters; Overload, 3(8):40, June 1995. (PDF)
[Horwill, 1995]
Ian Horwill. Wait for me! - virtual Overload, 3(8):20-23, June 1995. (PDF)
[Houghton, 1997]
Tony Houghton. editor << letters; Overload, 5(23):38, December 1997. (PDF)
[Hughes, 2000]
Tom Hughes. editorial Overload, 8(37):, June 2000. (PDF)
[IPL Limited, 1993]
IPL Limited. Unit Testing Of C++ Classes Overload, 1(3):, August 1993. (PDF)
[Ignatchenko, 1997]
Sergey Ignatchenko. Some Opportunities to Increase STL Efficiency Overload, 5(22):30-35, October 1997. (PDF)
[Ignatchenko, 1997]
Sergey Ignatchenko, Dmitry Ligum. STL Vectors Overload, 5(23):19-23, December 1997. C++ Techniques (PDF)
[Ignatchenko, 2009]
Yaakov Belch, Sergey Ignatchenko, Dmytro Ivanchykhin. Project-Specific Language Dialects Overload, 17(94):17--25, December 2009. Today’s languages force a one-size-fits-all approach on projects. Yaakov Belch, Sergey Ignatchenko and Dmytro Ivanchykhin suggest a more flexible solution. (PDF)
[Ignatchenko, 2010]
Sergey Ignatchenko. Single-Threading: Back to the Future? Overload, 18(97):, June 2010. Dealing with multi-threading is notoriously hard. Sergey Ignatchenko learns lessons from the past. (PDF)
[Ignatchenko, 2010]
Sergey Ignatchenko. Single-Threading: Back to the Future? (Part 2) Overload, 18(98):16-19, August 2010. Multithreading can cause notoriously difficult bugs. Sergey Ignatchenko finds mitigating strategies for programs on servers. (PDF)
[Ignatchenko, 2010]
Sergey Ignatchenko. To DLL or Not To DLL Overload, 18(99):14-16, October 2010. Shared libraries provide both benefits and problems. Sergey Ignatchenko introduces a rabbit’s-eye view. (PDF)
[Ignatchenko, 2010]
Sergey Ignatchenko. From Occam’s Razor to No Bugs’ Axe Overload, 18(100):8-10, December 2010. Designing good APIs that stand the test of time is notoriously hard. Sergey Ignatchenko suggests a radical guideline. (PDF)
[Ignatchenko, 2011]
Sergey Ignatchenko. Overused Code Reuse Overload, 19(101):12-14, February 2011. It’s tempting to use someone else’s code rather than write it yourself. Sergey Ignatchenko reports that ‘No Bugs’ Bunny recommends caution. (PDF)
[Ignatchenko, 2011]
Sergey Ignatchenko. On CMM, Formalism and Creativity Overload, 19(102):18-20, April 2011. No Bugs requires us to improve software quality. Sergey Ignatchenko considers some of the potential problems. (PDF)
[Ignatchenko, 2011]
Sergey Ignatchenko. The Guy We’re All Working For Overload, 19(103):10-12, June 2011. Developers like to think they’re in control of their products. Sergey Ignatchenko reminds us who’s really in charge. (PDF)
[Ignatchenko, 2011]
Sergey Ignatchenko. Over-Generic Use of Abstractons as a Major Cause of Wasting Resources Overload, 19(104):4-6, August 2011. We often find ways to hide complexity. Sergey Ignatchenko looks at how this can be sub-optimal. (PDF)
[Ignatchenko, 2011]
Sergey Ignatchenko. Intellectual Property - a Crash Course for Developers Overload, 19(105):18-20, October 2011. Interpreting law is a tricky business. Sergey Ignatchenko introduces someone who can help you avoid expensive mistakes. (PDF)
[Ignatchenko, 2011]
Sergey Ignatchenko. From the Age of Power to the Age of Magic and beyond... Overload, 19(106):11-13, December 2011. Certain abilities allowed some societies to dominate their peers. Sergey Ignatchenko takes a historical perspective on dominant societies (PDF)
[Ignatchenko, 2012]
Sergey Ignatchenko. Memory Leaks and Memory Leaks Overload, 20(107):4-5, February 2012. Correct use of memory is a major occupation of software development. Sergey Ignatchenko considers what we mean by ‘correct’. (PDF)
[Ignatchenko, 2012]
Sergey Ignatchenko. Compiling a Static Web Site Using the C Preprocessor Overload, 20(108):33-35, April 2012. Sometimes the obvious way is still too complex. Sergey Ignatchenko relates how ‘No Bugs’ Bunny found an unexpectedly simple approach to creating a web site. (PDF)
[Ignatchenko, 2012]
Sergey Ignatchenko. Programming Darwinism Overload, 20(109):4-5, June 2012. Have you ever thought your software had a life of its own? Sergey Ignatchenko wonders whether you might be right. (PDF)
[Ignatchenko, 2012]
Sergey Ignatchenko. Replace User, Strike Any Key? Overload, 20(110):16-18, August 2012. There is a common perception in the IT industry that the user is the primary source of all the problems. Sergey Ignatchenko asks if this is true. (PDF)
[Ignatchenko, 2012]
Sergey Ignatchenko. Keep It Simple, Singleton! Overload, 20(111):19-20, October 2012. Naïve assumptions sound like a bad idea. Sergey Ignatchenko discusses how to spot good assumptions in the face of changing requirements. (PDF)
[Ignatchenko, 2012]
Sergey Ignatchenko. -640K- 2^256 Bytes of Memory is More than Anyone Would Ever -Need- Get Overload, 20(112):14-15, December 2012. How fast can computers get? Sergey Ignatchenko provides us with some upper limits. (PDF)
[Ignatchenko, 2013]
Sergey Ignatchenko. ‘No Bugs’ Top Five C++ Cooking Recipes Overload, 21(113):4-6, February 2013. Developers often have a few favourite tricks for solving problems. Sergey Ignatchenko shares his five top recipes. (PDF)
[Ignatchenko, 2013]
Sergey Ignatchenko, Dmytro Ivanchykhin. A Model for Debug Complexity Overload, 21(114):4-5, April 2013. Debugging any program can be difficult. Sergey Ignatchenko and Dmytro Ivanchykhin develop a mathematical model for its complexity. (PDF)
[Ignatchenko, 2013]
Sergey Ignatchenko. TCP/IP Explained. A Bit Overload, 21(115):8-11, June 2013. Nowadays most programmers rely on network connectivity, often without really understanding the details. Sergey Ignatchenko compares and contrasts the two main protocols. (PDF)
[Ignatchenko, 2013]
Sergey Ignatchenko. Hard Upper Limit on Memory Latency Overload, 21(116):4-5, August 2013. Achieving very low latency is important. Sergey Ignatchenko asks how low can we go. (PDF)
[Ignatchenko, 2013]
Sergey Ignatchenko. YAGNI-C as a Practical Application of YAGNI Overload, 21(117):12-14, October 2013. YAGNI can seem vague. Sergey Ignatchenko offers a more precise definition. (PDF)
[Ignatchenko, 2013]
Sergey Ignatchenko. On the Other Side of the Barricade: Job Interviewer Do’s and Don’ts Overload, 21(118):4-6, December 2013. Interviewing is an important skill which is hard to get right. Sergey Ignatchenko gives advice to get you thinking. (PDF)
[Ignatchenko, 2014]
Sergey Ignatchenko, Dmytro Ivanchykhin. Optimizing Big Number Arithmetic Without SSE Overload, 22(119):16-18, February 2014. Addition and multiplication can be slow for big numbers. Sergey Ignatchenko and Dmytro Ivanchykhin try to speed things up. (PDF)
[Ignatchenko, 2014]
Sergey Ignatchenko, Dmytro Ivanchykhin. Size Matters Overload, 22(120):4-5, April 2014. Should you target 32 or 64 bits? Sergey Ignatchenko and Dmytro Ivanchykhin consider the costs and benefits. (PDF)
[Ignatchenko, 2014]
Sergey Ignatchenko. Musings on Python - by a C++ Developer Overload, 22(122):6-10, August 2014. Python and C++ are very different languages. Sergey Ignatchenko walks through things in Python that can confuse a C++ programmer. (PDF)
[Ignatchenko, 2014]
Sergey Ignatchenko, Dmytro Ivanchykhin. Debug Complexity: How Assertions Affect Debugging Time Overload, 22(123):4-7, October 2014. Sergey Ignatchenko and Dmytro Ivanchykhin extend their mathematical model of debug complexity. (PDF)
[Ignatchenko, 2014]
Sergey Ignatchenko. Non-Superfluous People: Testers Overload, 22(124):6-8, December 2014. Software development needs a team of supporting players. Sergey Ignatchenko takes a look at the role of professional testers. (PDF)
[Ignatchenko, 2015]
Sergey Ignatchenko. Best Practices vs Witch Hunts Overload, 23(125):4-6, February 2015. Best practices can be a Good Thing. Sergey Ignatchenko considers when they can turn into Really Bad Things. (PDF)
[Ignatchenko, 2015]
Sergey Ignatchenko. Non-Superfluous People: Overload, 23(126):4-8, April 2015. UX Specialists User experience specialists are sometimes regarded as superfluous people. Sergey Ignatchenko demonstrates why they can be vital. (PDF)
[Ignatchenko, 2015]
Sergey Ignatchenko. Non-Superfluous People: Architects Overload, 23(127):12-14, June 2015. No developer is an island. Sergey Ignatchenko continues his series of non-superfluous people by looking at the role of architects. (PDF)
[Ignatchenko, 2015]
Sergey Ignatchenko. Multi-threading at Business-logic Level is Considered Harmful Overload, 23(128):4-7, August 2015. Multi-threaded code promises potential speed-up. Sergey Ignatchenko considers how it often slows things down instead. (PDF)
[Ignatchenko, 2015]
Sergey Ignatchenko. Password Hashing: Why and How Overload, 23(129):12-16, October 2015. Password hashing is important. Sergey Ignatchenko explains how to do it properly. (PDF)
[Ignatchenko, 2015]
Sergey Ignatchenko. Once Again on TCP vs UDP Overload, 23(130):4-7, December 2015. TCP and UDP have different properties. Sergey Ignatchenko weighs up their pros and cons. (PDF)
[Ignatchenko, 2016]
Sergey Ignatchenko. On Zero-Side-Effect Interactive Programming, Actors, and FSMs Overload, 24(131):9-12, February 2016. Functional programming is alien to many programmers. Sergey Ignatchenko considers parallels between actors and finite state machines. (PDF)
[Ignatchenko, 2016]
Sergey Ignatchenko. Knowledge-Sharing Architects As An Alternative to Coding Architects Overload, 24(132):8-10, April 2016. Should architects write code? Sergey Ignatchenko explores this controversial subject. (PDF)
[Ignatchenko, 2016]
Sergey Ignatchenko. Deterministic Components for Distributed Systems Overload, 24(133):12-16, June 2016. Non-deterministic data leads to unstable tests. Sergey Ignatchenko considers when this happens and how to avoid it. (PDF)
[Ignatchenko, 2016]
Sergey Ignatchenko. Some Big-Os are Bigger Than Others Overload, 24(134):4-7, August 2016. Big-O notation is often used to compare algorithms. Sergey Ignatchenko reminds us that asymptotic limits might not be generally applicable. (PDF)
[Ignatchenko, 2016]
Sergey Ignatchenko. Determinism: Requirements vs Features Overload, 24(135):4-7, October 2016. A program can easily be non-deterministic. Sergey Ignatchenko considers how to define determinism. (PDF)
[Ignatchenko, 2016]
Sergey Ignatchenko. Ultra-fast Serialization of C++ Objects Overload, 24(136):12-17, December 2016. Serialising and de-serialising is a common problem. Sergey Ignatchenko and Dmytro Ivanchykhin demonstrate one way to do this quickly. (PDF)
[Ignatchenko, 2017]
Sergey Ignatchenko. The Importance of Back-of-Envelope Estimates Overload, 25(137):8-12, February 2017. Guestimate questions make many people grumble. Sergey Ignatchenko reminds us why they matter. (PDF)
[Ignatchenko, 2017]
Sergey Ignatchenko. (Not Really So) New Niche for C++: Browser!? Overload, 25(138):12-15, April 2017. How do you run C++ in a browser? Sergey Ignatchenko demonstrates how to use Emscripten. (PDF)
[Ignatchenko, 2017]
Sergey Ignatchenko. Allocator for (Re)Actors with Optional Kinda-Safety and Relocation Overload, 25(139):4-8, June 2017. How do you deal with memory for (Re)Actors? Sergey Ignatchenko proposes an allocation scheme. (PDF)
[Ignatchenko, 2017]
Sergey Ignatchenko. A Usable C++ Dialect that is Safe Against Memory Corruption Overload, 25(140):6-9, August 2017. Sergey Ignatchenko continues his investigation of allocators for (Re)Actors. (PDF)
[Ignatchenko, 2017]
Sergey Ignatchenko. 'Speedy Gonzales' Serializing (Re)Actors via Allocators Overload, 25(141):10-13, October 2017. Sergey Ignatchenko completes his (Re)Actor allocator series. (PDF)
[Ignatchenko, 2017]
Sergey Ignatchenko. CAS (Re)Actor for Non-Blocking Multithreaded Primitives Overload, 25(142):4-6, December 2017. Lock free programming can be difficult. Sergey Ignatchenko shows how copy and swap can work for reactors. (PDF)
[Ignatchenko, 2018]
Sergey Ignatchenko. An MWSR Queue with Minimalist Locking Overload, 26(143):6-9, February 2018. Multithreaded queues come in many flavours. Sergey Ignatchenko describes his implementation of a multiple writer single reader queue. (PDF)
[Ignatchenko, 2018]
Sergey Ignatchenko. 5 Reasons NOT to Use std::ostream for Human-Readable Output Overload, 26(144):16-20, April 2018. C++’s ostream can be hard to use. Sergey Ignatchenko suggests we use the {fmt} library instead. (PDF)
[Iltchenko, 2002]
Andrei Iltchenko. The C++ Template Argument Deduction Overload, 10(48):, April 2002. (PDF)
[Ivanchykhin, 2009]
Yaakov Belch, Sergey Ignatchenko, Dmytro Ivanchykhin. Project-Specific Language Dialects Overload, 17(94):17--25, December 2009. Today’s languages force a one-size-fits-all approach on projects. Yaakov Belch, Sergey Ignatchenko and Dmytro Ivanchykhin suggest a more flexible solution. (PDF)
[Ivanchykhin, 2013]
Sergey Ignatchenko, Dmytro Ivanchykhin. A Model for Debug Complexity Overload, 21(114):4-5, April 2013. Debugging any program can be difficult. Sergey Ignatchenko and Dmytro Ivanchykhin develop a mathematical model for its complexity. (PDF)
[Ivanchykhin, 2014]
Sergey Ignatchenko, Dmytro Ivanchykhin. Optimizing Big Number Arithmetic Without SSE Overload, 22(119):16-18, February 2014. Addition and multiplication can be slow for big numbers. Sergey Ignatchenko and Dmytro Ivanchykhin try to speed things up. (PDF)
[Ivanchykhin, 2014]
Sergey Ignatchenko, Dmytro Ivanchykhin. Size Matters Overload, 22(120):4-5, April 2014. Should you target 32 or 64 bits? Sergey Ignatchenko and Dmytro Ivanchykhin consider the costs and benefits. (PDF)
[Ivanchykhin, 2014]
Sergey Ignatchenko, Dmytro Ivanchykhin. Debug Complexity: How Assertions Affect Debugging Time Overload, 22(123):4-7, October 2014. Sergey Ignatchenko and Dmytro Ivanchykhin extend their mathematical model of debug complexity. (PDF)
[Jackson, 1995]
Kenneth Jackson. ‘Individual’ Control Validation in MFC Overload, 3(8):33-36, June 1995. (PDF)
[Jagger, 1996]
Jon Jagger. Time please, ladies and gentlemen Overload, 4(14):16-18, June 1996. C++ Techniques (PDF)
[Jagger, 1996]
Jon Jagger. Functionoids Overload, 4(14):15-16, June 1996. C++ Techniques (PDF)
[Jagger, 1997]
Jon Jagger. auto_ptr || !auto_ptr Overload, 5(17/18):, January 1997. See also corrections in Overload 19, p.30 (PDF)
[Jagger, 1997]
Jon Jagger. Lessons from fixed_vector Part 1 Overload, 5(20):25-27, June 1997. C++ Techniques (PDF)
[Jagger, 1998]
Jon Jagger. pointer{type} Overload, 6(24):13-18, February 1998. C++ Techniques (PDF)
[Jagger, 1998]
Jon Jagger. counted_ptr{type} Overload, 6(25):7-13, April 1998. Software Development in C++ (PDF)
[Jagger, 1998]
Jon Jagger. counted_ptr revisited Overload, 6(29):, December 1998. (PDF)
[Jagger, 1999]
Jon Jagger. Write to Learn Overload, 7(30):, February 1999. (PDF)
[Jagger, 1999]
Jon Jagger. copy_on_write_ptr Overload, 7(31):, April 1999. (PDF)
[Jagger, 1999]
Jon Jagger. A Review of cow_ptr Overload, 7(32):, June 1999. (PDF)
[Jagger, 1999]
Jon Jagger. More cow_ptr Ruminations Overload, 7(33):, October 1999. (PDF)
[Jagger, 2002]
Jon Jagger. An Overview of C#.NET Overload, 10(49):, June 2002. (PDF)
[Jagger, 2002]
Jon Jagger. Even More Java Exceptions Overload, 10(50):, August 2002. (PDF)
[Jagger, 2002]
Jon Jagger. Exception Handling in C# Overload, 10(51):, October 2002. (PDF)
[Jagger, 2003]
Jon Jagger. A Return Type That Doesn’t Like Being Ignored Overload, 11(53):20-21, February 2003. (PDF)
[Jagger, 2003]
Jon Jagger. The Nature and Aesthetics of Design Overload, 11(54):, April 2003. (PDF)
[Jagger, 2003]
Jon Jagger. How To Write A Loop Overload, 11(55):, June 2003. (PDF)
[Jagger, 2003]
Jon Jagger. Software As Read Overload, 11(57):, October 2003. (PDF)
[Jagger, 2003]
Jon Jagger. Single Exit Overload, 11(57):, October 2003. (PDF)
[Jagger, 2009]
Jon Jagger. Shadow Data Types Overload, 17(94):4--6, December 2009. Hiding implementation details is a good idea. Jon Jagger shows a technique in C that avoids some of the common problems. (PDF)
[Jagger, 1997]
Kevlin Henney, Richard Percy, Jonathan Jagger. editor << letters; Overload, 5(20):36-37, June 1997. (PDF)
[Jay, 1996]
Sean A. Corfield, Dave Midgley, Roger Lever, Chris Simons, Andrew King, Alan Griffiths, Jay. editor << letters; Overload, 3(12):, February 1996. (PDF)
[Jay, 2009]
Rafael Jay. Complexity, Requirements and Models Overload, 17(91):, June 2009. Programs can be unnecessarily complex. Rafael Jay examines a technique for doing better. (PDF)
[Jay, 2010]
Rafael Jay. Bug Hunting and the Scientific Method Overload, 18(100):4-7, December 2010. Do you have a proper methodology when fixing bugs? Rafael Jay puts on his lab coat. (PDF)
[Jensen, 2005]
Randall W. Jensen. A Pair Programming Experience Overload, 13(65):, February 2005. (PDF)
[Johansen, 2005]
Trond Johansen. From Waterfall to EVO in a Medium Size Norwegian Software House Overload, 13(65):, February 2005. FIRM was established in 1996, and has 70 employees in 4 offices (Oslo, London, New York and San Francisco). FIRM delivers one software product: 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. (PDF)
[Johnson, 2006]
Paul Johnson. A Drop in Standards? Overload, 14(76):, December 2006. Paul Johnson asks why, with the increase in numbers of those passing school-based examinations, today's graduates are less able than in previous times. What is going wrong? (PDF)
[Jones, 2004]
Derek M. Jones. Letters: Software’s No Different... Overload, 12(61):, June 2004. (PDF)
[Jones, 1996]
Graham Jones. Some questions about OOD Overload, 4(15):4-6, August 1996. Software Development in C++ (PDF)
[Jones, 1996]
Sean A. Corfield, Allan Newton, Graham Jones, Phil Bass, Steven Youngs. editor << letters; Overload, 4(15):35-36, August 1996. (PDF)
[Jones, 1996]
Francis Glassborow, Kevlin A. P. Henney, Colin Hersom, Graham Jones, Phil Bass, Steve Mertz, Walter Brown. editor << letters; Overload, 4(16):19-24, October 1996. (PDF)
[Jones, 1997]
Graham Jones. OOD again: Some light, some shadows Overload, 5(19):22-24, April 1997. C++ Techniques (PDF)
[Jones, 1998]
Graham Jones. Rational Value Comments Overload, 6(24):22, February 1998. Whiteboard (PDF)
[Jones, 1998]
Graham Jones. Irrational Behaviour Overload, 6(25):25-26, April 1998. Whiteboard (PDF)
[Jones, 2009]
Matthew Jones. Testing State Machines Overload, 17(90):, April 2009. State machines are a common design pattern. Matthew Jones seperates their concerns to make testing easier. (PDF)
[Jones, 2010]
Matthew Jones. Debugging Run Time Memory Problems Overload, 18(98):20-27, August 2010. The C++ Standard is often silent on what happens when things go wrong. Matthew Jones looks under the bonnet to take control. (PDF)
[Jones, 2008]
Robert Jones. Generics Without Templates Overload, 16(83):, February 2008. Robert Jones presents an alternative implementation of C++'s std::vector that can be used the absence of templates and exceptions. (PDF)
[Jones, 2008]
Robert Jones. Generics without Templates - Revisited Overload, 16(88):, December 2008. Can you use the STL if your compiler lacks templates? Robert Jones implements iterators and alogorithms. (PDF)
[Josuttis, 2000]
Nicolai Josuttis. eXtreme Programming: An interview with Kent Beck Overload, 8(35):, February 2000. (PDF)
[Joy, 2001]
Corwin Joy, Michael Gradman. Introduction to the Database Template Library Overload, 9(43):, June 2001. (PDF)
[Kampjes, 2005]
Bryce Kampjes. Incremental Design: A Case Study of a Compiler Overload, 13(69):, October 2005. (PDF)
[Kaplan, 2016]
Vassili Kaplan. Programming Your Own Language in C++ Overload, 24(133):17-23, June 2016. Scripting languages allow dynamic features easily. Vassili Kaplan writes his own in C++ allowing keywords in any human language. (PDF)
[Karlsson, 2002]
Björn Karlsson. What is Boost? Overload, 10(47):, February 2002. (PDF)
[Keffer, 1994]
Dr. Thomas Keffer. Why C++ will replace FORTRAN (or, at least, why it should) Overload, 2(4):, February 1994. (PDF)
[Keir, 2015]
Paul Keir. The Universality and Expressiveness of std::accumulate Overload, 23(130):13-15, December 2015. Folding is a highly generic operation available through std::accumulate. Paul Keir goes beyond reduction, with the help of C++14’s polymorphic lambdas. (PDF)
[Kelly, 1999]
Allan Kelly. Using Templates To Handle Multi-Threading Overload, 7(31):, April 1999. (PDF)
[Kelly, 1999]
Allan Kelly. Modern Art as an Inspiration for Software Overload, 7(32):, June 1999. (PDF)
[Kelly, 1999]
Allan Kelly. More threading with templates Overload, 7(33):, October 1999. (PDF)
[Kelly, 2000]
Allan Kelly. Error handling and logging Overload, 8(35):, February 2000. (PDF)
[Kelly, 2000]
Allan Kelly. In Response to Extreme Programming Overload, 8(37):, June 2000. (PDF)
[Kelly, 2000]
Allan Kelly. Include Files Overload, 8(39):, October 2000. (PDF)
[Kelly, 2000]
Allan Kelly. More Include File Rules Overload, 8(40):, December 2000. (PDF)
[Kelly, 2001]
Allan Kelly. Source Code Modules and Layering Overload, 9(41):, February 2001. (PDF)
[Kelly, 2001]
Allan Kelly. A Deeper Look at Inline Functions Overload, 9(42):, April 2001. (PDF)
[Kelly, 2001]
Allan Kelly. Where to begin: Porting Overload, 9(43):, June 2001. (PDF)
[Kelly, 2001]
Allan Kelly. Porting (part 2) - Addressing the Differences Overload, 9(44):, August 2001. (PDF)
[Kelly, 2001]
Allan Kelly. Porting part 3: Overload, 9(45):, October 2001. (PDF)
[Kelly, 2001]
Allan Kelly. Modelling and Software Development Overload, 9(46):, December 2001. (PDF)
[Kelly, 2002]
Allan Kelly. Of Minimalism, Constructivism and Program Code Overload, 10(47):, February 2002. (PDF)
[Kelly, 2002]
Allan Kelly. How about a Turner Prize for software? Overload, 10(47):, February 2002. (PDF)
[Kelly, 2002]
Allan Kelly. Thinking about "reuse" Overload, 10(48):, April 2002. (PDF)
[Kelly, 2002]
Allan Kelly. The scoping problem Overload, 10(49):, June 2002. (PDF)
[Kelly, 2002]
Allan Kelly. Writing Extendable Software Overload, 10(49):, June 2002. (PDF)
[Kelly, 2002]
Allan Kelly. The Philosophy of Extensible Software Overload, 10(50):, August 2002. (PDF)
[Kelly, 2002]
Allan Kelly. Extendable Software and the Bigger Picture Overload, 10(51):, October 2002. (PDF)
[Kelly, 2002]
Allan Kelly. Organising Source Code Overload, 10(52):, December 2002. (PDF)
[Kelly, 2003]
Allan Kelly. Build Systems Overload, 11(53):5-9, February 2003. (PDF)
[Kelly, 2003]
Allan Kelly. Software development and the learning organisation Overload, 11(54):, April 2003. (PDF)
[Kelly, 2003]
Allan Kelly. Ruminations on Knowledge in Software Development Overload, 11(55):, June 2003. (PDF)
[Kelly, 2003]
Allan Kelly. EuroPLoP 2003 Conference Report Overload, 11(56):, August 2003. (PDF)
[Kelly, 2003]
Allan Kelly. Is IT worth it? Overload, 11(57):, October 2003. (PDF)
[Kelly, 2003]
Allan Kelly. Letters to the Editor(s) Overload, 11(57):, October 2003. (PDF)
[Kelly, 2003]
Allan Kelly. An Alternative View of design (and planning) Overload, 11(58):, December 2003. (PDF)
[Kelly, 2004]
Allan Kelly. Why do requirements change? Overload, 12(59):, February 2004. (PDF)
[Kelly, 2004]
Allan Kelly. Where Egos Dare Overload, 12(61):, June 2004. (PDF)
[Kelly, 2004]
Allan Kelly. The Encapsulate Context Pattern Overload, 12(63):, October 2004. (PDF)
[Kelly, 2005]
Allan Kelly. The Developer's New Work Overload, 13(65):, February 2005. (PDF)
[Kelly, 2005]
Allan Kelly. Editorial: Need to Unlearn Overload, 13(66):, April 2005. (PDF)
[Kelly, 2006]
Allan Kelly. The Documentation Myth Overload, 14(74):, August 2006. Allan Kelly suggests that we don't invest more in documentation for a reason: that it isn't as valuable as we claim. (PDF)
[Kelly, 2007]
Allan Kelly. Blue-White-Red, an Example Agile Process Overload, 15(81):, October 2007. When it comes to running a project, one size rarely fits all, but Allan Kelly finds that tailoring a core idea over time has led to repeated success. (PDF)
[Kelly, 2007]
Allan Kelly. Creating Awareness Overload, 15(82):, December 2007. One of the good things about presenting at the ACCU conference is what you learn there. Allan Kelly reviews the results of his last conference talk. (PDF)
[Kelly, 2008]
Allan Kelly. Future Workers (Prototype) Overload, 16(83):, February 2008. What does it mean for IT workers to be prototype knowledge workers? (PDF)
[Kelly, 2008]
Allan Kelly. On Management Overload, 16(86):, August 2008. Management is a vital part of software development. Allan Kelly starts a new series by balancing some constraints. (PDF)
[Kelly, 2008]
Allan Kelly. Focus, Quality, Time-boxes and Ducks Overload, 16(87):, October 2008. Project success depends on organisation. Allan Kelly looks at how to keep things in order. (PDF)
[Kelly, 2008]
Allan Kelly. On Management: Understanding Who Creates Software Overload, 16(88):, December 2008. Software development organizations vary greatly. Allan Kelly considers what this means for managers. (PDF)
[Kelly, 2009]
Allan Kelly. On Management: Caveat Emptor Overload, 17(89):, February 2009. There are many theories and practices of management. Allan Kelly offers some warnings. (PDF)
[Kelly, 2009]
Allan Kelly. On Management: Product Managers Overload, 17(90):, April 2009. Product Management is a poorly understood activity. Allan Kelly sheds some light on its mysteries. (PDF)
[Kelly, 2009]
Allan Kelly. On Management: The Business Analyst's Role Overload, 17(91):, June 2009. Some management titles are poorly defined. Allan Kelly disentangles a knotty one. (PDF)
[Kelly, 2010]
Allan Kelly. “I’m a Business Analyst - Get Me Out Of Here” Overload, 18(98):4-8, August 2010. Some classic roles are omitted by Agile methodologies. Allan Kelly considers how a Business Analyst fits in. (PDF)
[Kelly, 2011]
Allan Kelly. The Agile 10 Steps Model Overload, 19(101):16-19, February 2011. Technical processes have tended to dominate agile thinking. Allan Kelly looks at the wider picture. (PDF)
[Kelly, 2011]
Allan Kelly. The Agile Spectrum Overload, 19(102):14-17, April 2011. Very few teams are truly Agile. Allan Kelly looks at the range of styles. (PDF)
[Kelly, 2011]
Allan Kelly. Integrating Testers Into An Agile Team Overload, 19(104):7-9, August 2011. Agile has usually concentrated on how to organise developers. Allan Kelly shows how testers fit in. (PDF)
[Kelly, 2012]
Allan Kelly. Software Developer Business Patterns Overload, 20(111):21-24, October 2012. Patterns can be applied to business as well as software. Allan Kelly shows us how. (PDF)
[Kendall, 1995]
Graham Kendall. Putting Jack in the Box Overload, 3(6):, March 1995. (PDF)
[Kilpeläinen, 2004]
Mikael Kilpeläinen. Lvalues and Rvalues Overload, 12(61):, June 2004. (PDF)
[Kilpeläinen, 2005]
Mikael Kilpeläinen. Overload Resolution - Selecting the Function Overload, 13(66):, April 2005. (PDF)
[King, 1995]
Andrew King. editor << letters; Overload, 3(11):39-40, December 1995. (PDF)
[King, 1996]
Sean A. Corfield, Dave Midgley, Roger Lever, Chris Simons, Andrew King, Alan Griffiths, Jay. editor << letters; Overload, 3(12):, February 1996. (PDF)
[Kirilov, 2017]
Viktor Kirilov. doctest - the Lightest C++ Unit Testing Framework Overload, 25(137):16-19, February 2017. C++ has many unit testing frameworks. Viktor Kirilov introduces doctest. (PDF)
[Knabe, 2011]
Christoph Knabe. The Eternal Battle Against Redundancies, Part I Overload, 19(106):7-10, December 2011. The drive to remove redundancies is widely seen as a good thing. Christoph Knabe sees how it has influenced programming languages. (PDF)
[Knabe, 2012]
Christoph Knabe. The Eternal Battle Against Redundancies, Part 2 Overload, 20(107):20-23, February 2012. Repeated information leads to poor quality software. Christoph Knabe continues to see how removing them has influenced language design. (PDF)
[Kuehl, 2003]
Dietmar Kuehl. A bin Manipulator For IOStreams Overload, 11(55):, June 2003. (PDF)
[Kyriacou, 1996]
Francis Glassborow, Chris Southern, Klitos Kyriacou. The return type of member functions Overload, 4(15):29-33, August 1996. C++ Techniques (PDF)
[Kühl, 2011]
Dietmar Kühl. Exception Specifications in C++ 2011 Overload, 19(103):13-17, June 2011. The new standard is almost finished. Dietmar Kühl looks at the new exception features. (PDF)
[Kühl, 2015]
Dietmar Kühl. Two Daemons Overload, 23(128):8-10, August 2015. Most people have come across C++11’s forwarding references. Dietmar Kühl explains what && really means. (PDF)
[Kühl, 2015]
Patrick Martin, Dietmar Kühl. Identify your Errors better with char[] Overload, 23(130):18-22, December 2015. Error codes still get used instead of exceptions. Patrick Martin and Dietmar Kühl consider how to use char arrays for better information. (PDF)
[Law, 2016]
Greg Law. Why Collaboration is Key for QA Teams in an Agile World Overload, 24(132):12, April 2016. Agile processes can have an impact on QA departments. Greg Law considers how they can adapt to survive and even thrive. (PDF)
[Lenton, 1994]
Alan Lenton. Afterword Overload, 2(5):27, September 1994. (PDF)
[Lever, 1995]
Roger Lever. On not mixing it... Overload, 3(7):32-33, April 1995. (PDF)
[Lever, 1995]
Roger Lever. The case against learning C++ right now - right or wrong? Overload, 3(8):3-5, June 1995. (PDF)
[Lever, 1995]
Roger Lever. On not mixing it...again Overload, 3(9):30-33, August 1995. (PDF)
[Lever, 1995]
Roger Lever. Interview with Jiri Soukup by Roger Lever Overload, 3(9):36-38, August 1995. (PDF)
[Lever, 1995]
Roger Lever. Simple classes for debugging in C++ - part I Overload, 3(10):21-24, October 1995. C++ Techniques (PDF)
[Lever, 1995]
Roger Lever. Simple classes for debugging in C++ - Part 2 Overload, 3(11):23-28, December 1995. C++ Techniques (PDF)
[Lever, 1996]
Sean A. Corfield, Dave Midgley, Roger Lever, Chris Simons, Andrew King, Alan Griffiths, Jay. editor << letters; Overload, 3(12):, February 1996. (PDF)
[Lever, 1996]
Roger Lever. Simple classes for debugging in C++ - Part 3 Overload, 3(12):19-22, February 1996. C++ Techniques (PDF)
[Lever, 1996]
Roger Lever. Simple classes - Part 4: Game of Life Overload, 4(13):11-14, April 1996. Software Development in C++ (PDF)
[Lever, 1997]
Roger Lever, Mark Radford. The Uses and Abuses of Inheritance Overload, 5(19):6-8, April 1997. Software Development in C++ (PDF)
[Lever, 1997]
Francis Glassborow, Roger Lever. editor << letters; Overload, 5(19):30-31, April 1997. (PDF)
[Lever, 1998]
Roger Lever. Hotel Case Study Comments Overload, 6(27):, August 1998. (PDF)
[Lewin, 2012]
Michael Lewin. All About XOR Overload, 20(109):14-19, June 2012. Boolean operators are the bedrock of computer logic. Michael Lewin investigates a common one and shows there’s more to it than meets the eye. (PDF)
[Ligum, 1997]
Sergey Ignatchenko, Dmitry Ligum. STL Vectors Overload, 5(23):19-23, December 1997. C++ Techniques (PDF)
[Long, 2015]
Mike Long. Faking C Function with fff.h Overload, 23(125):17-19, February 2015. Faking functions for testing in C can ease testing. Mike Long overviews a micro-framework for mocking. (PDF)
[Longshaw, 2009]
Andy Longshaw, Eoin Woods. The Generation, Management and Handling of Errors (Part 1) Overload, 17(92):, August 2009. An error handling strategy is important for robustness. Andy Longshore and Eoin Woods present a pattern language. (PDF)
[Longshaw, 2009]
Andy Longshaw, Eoin Woods. The Generation, Management and Handling of Errors (Part 2) Overload, 17(93):, October 2009. Dealing with errors is a vital activity. Andy Longshaw and Eoin Woods conclude their pattern language. (PDF)
[Love, 2000]
Steve Love. A Fistful Of Idioms - Giving STL Iterators a Base Class Overload, 8(38):, August 2000. (PDF)
[Love, 2001]
Steve Love. Are You Afraid of The Dark? - Making Sense of the STL Overload, 9(43):, June 2001. (PDF)
[Love, 2001]
Steve Love. Are You Afraid of The Dark Too? Making More Sense of the STL Overload, 9(44):, August 2001. (PDF)
[Love, 2006]
Steve Love. A Fistful Of Idioms Overload, 14(72):, April 2006. (PDF)
[Love, 2006]
Steve Love. The Rise and Fall of Singleton Threaded Overload, 14(73):, June 2006. Steve Love explores how 'Singletons' in design can seem a good idea at the time, why they are generally a mistake, and what to do if you have them. (PDF)
[Love, 2006]
Steve Love. C# Generics - Beyond Containers of T Overload, 14(74):, August 2006. Steve Love takes a look at generics in C# v2.0, how to use them to simplify code and even remove dependencies. (PDF)
[Love, 2010]
Steve Love. Interface Versioning in C++ Overload, 18(100):22-31, December 2010. Interface Versioning in C++Updating a widely used DLL interface is non-trivial. Steve Love presents a practical approach. (PDF)
[Love, 2011]
Steve Love, Roger Orr. Some Objects Are More Equal Than Others Overload, 19(103):4-9, June 2011. Comparing objects is a fundamental operation. Steve Love and Roger Orr consider different language approaches. (PDF)
[Love, 2012]
Steve Love. Many Slices of Pi Overload, 20(107):6-13, February 2012. Many numberic estimation techniques are easily parallelisable. Steve Love employs multi-threading, message passing, and more in search of Pi. (PDF)
[Love, 2013]
Steve Love. Secrets of Testing WCF Services Overload, 21(113):16-23, February 2013. WCF services provide middleware for applications but can be hard to test. Steve Love describes a way to develop a testable app. (PDF)
[Love, 2013]
Steve Love. C++ Range and Elevation Overload, 21(117):28-36, October 2013. C++ provides many features for higher-level programming, but lacks some common ones present in other languages. (PDF)
[Love, 2016]
Steve Love. A Lifetime In Python Overload, 24(133):8-11, June 2016. Resource management is important in any language. Steve Love demonstrates how to use context managers in Python. (PDF)
[Macias, 2017]
Katarzyna Macias. A C++ Developer Sees Rustlang for the First Time Overload, 25(140):12-13, August 2017. Katarzyna Macias provides an introduction to Rust for a C++ developer. (PDF)
[Main, 2002]
Chris Main. Programming with Interfaces in C++ Overload, 10(49):, June 2002. (PDF)
[Main, 2003]
Chris Main. Implementing the Bridge pattern using templates with Microsoft Visual C++ 6.0 Overload, 11(54):, April 2003. (PDF)
[Main, 2004]
Chris Main. A Template Programmer's Struggles Revisited Overload, 12(62):, August 2004. (PDF)
[Main, 2007]
Chris Main. C++ Unit Test Frameworks Overload, 15(78):, April 2007. There are many Unit Testing frameworks for C++, but which one to use? Chris Main shares his experience of some of them. (PDF)
[Mancuso, 2004]
Renato Mancuso. Letters to the Editor Overload, 12(62):, August 2004. (PDF)
[Marlow, 2007]
Andrew Marlow. FRUCTOSE - a C++ Unit Test Framework Overload, 15(77):, February 2007. Andrew Marlow describes the development of FRUCTOSE and how it is different from other unit test frameworks. (PDF)
[Marquardt, 2008]
Klaus Marquardt. Performitis Overload, 16(85):, June 2008. Patterns try to solve problems. Klaus Marquardt looks at one from a medical perspective. (PDF)
[Marquardt, 2008]
Klaus Marquardt. Performitis - Part 2 Overload, 16(86):, August 2008. Software problems have much in common with diseases. Klaus Marquardt has a diagnosis and offers some treatments. (PDF)
[Marquardt, 2008]
Klaus Marquardt. Performitis (Part 3) Overload, 16(87):, October 2008. Prevention is better than cure. Klaus Marquardt suggests some treatments to avoid problems. (PDF)
[Martin, 2015]
Patrick Martin, Dietmar Kühl. Identify your Errors better with char[] Overload, 23(130):18-22, December 2015. Error codes still get used instead of exceptions. Patrick Martin and Dietmar Kühl consider how to use char arrays for better information. (PDF)
[Martin, 2016]
Patrick Martin. The Tao of Scratch Overload, 24(132):4-7, April 2016. Scratch is an environment designed to help young people learn to code. Patrick Martin walks us through it. (PDF)
[Martin, 2016]
Patrick Martin. Eight Rooty Pieces Overload, 24(135):8-12, October 2016. Finding a square root is a common interview question. Patrick Martin demonstrates eight different ways to find a root. (PDF)
[Matthews, 1999]
Hubert Matthews. When's an object not an object? Overload, 7(34):, December 1999. (PDF)
[Matthews, 2003]
Hubert Matthews. CheckedInt: A Policy-Based Range-Checked Integer Overload, 11(58):, December 2003. (PDF)
[Matthews, 2007]
Hubert Matthews. Exceptional Design Overload, 15(77):, February 2007. Hubert Matthews discusses some ways to design programs to use exceptions. (PDF)
[Matthews, 2007]
Raoul Gough, Hubert Matthews, Peter Sommerlad. Letters to the Editor Overload, 15(78):, April 2007. (PDF)
[Maudel, 2013]
Olve Maudel. Demons May Fly Out Of Your Nose Overload, 21(115):12-13, June 2013. Language standards give guarantees about valid program behaviour. Olve Maudel discovers what happens if you break your end of the bargain. (PDF)
[McArdell, 2017]
Ralph McArdell. C++11 (and beyond) Exception Support Overload, 25(141):24-31, October 2017. Ralph McArdell gives a comprehensive overview of C++ exception features. (PDF)
[McGuiness, 2012]
Jason McGuiness, Colin Egan. A DSEL for Addressing the Problems Posed by Parallel Architectures Overload, 20(111):13-18, October 2012. Programming parallel algorithms correctly is hard. Jason McGuiness and Colin Egan demonstrate how a C++ DESEL can make it simpler. (PDF)
[McHugh, 2016]
Eleanor McHugh. Hello World in Go Overload, 24(136):25-35, December 2016. Go provides a way to write efficient concurrent programs in a C-like language. Eleanor McHugh shares a "Hello, world!" tutorial. (PDF)
[Merrells, 1997]
John Merrells. Whiteboard Overload, 5(20):35-36, June 1997. (PDF)
[Merrells, 1997]
John Merrells. Editorial Overload, 5(20):3-4, June 1997. (PDF)
[Merrells, 1997]
John Merrells. Object Counting Overload, 5(21):24-27, August 1997. Whiteboard (PDF)
[Merrells, 1997]
John Merrells. Whiteboard Overload, 5(21):20-21, August 1997. Whiteboard (PDF)
[Merrells, 1997]
John Merrells. Editorial Overload, 5(21):3, August 1997. (PDF)
[Merrells, 1997]
John Merrells, The Harpist, George Wendle, Francis Glasborow, Chris Southern. editor << letters; Overload, 5(22):, October 1997. (PDF)
[Merrells, 1997]
John Merrells. Editorial Overload, 5(22):3-4, October 1997. (PDF)
[Merrells, 1998]
John Merrells. Editorial Overload, 6(25):, April 1998. (PDF)
[Merrells, 1998]
John Merrells. Broadening Overload, 6(26):1, June 1998. Editorial (PDF)
[Merrells, 1998]
John Merrells. Editorial Overload, 6(27):, August 1998. (PDF)
[Merrells, 1998]
John Merrells. Beyond ACCU... Patterns on the 'net Overload, 6(27):, August 1998. (PDF)
[Merrells, 1998]
John Merrells. Beyond ACCU... Java on the 'net Overload, 6(28):, October 1998. (PDF)
[Merrells, 1998]
John Merrells. Editorial Overload, 6(28):, October 1998. (PDF)
[Merrells, 1998]
John Merrells. Beyond ACCU... Patterns on the 'net Overload, 6(29):, December 1998. (PDF)
[Merrells, 1998]
John Merrells. Editorial Overload, 6(29):, December 1998. (PDF)
[Merrells, 1999]
John Merrells. Editorial Overload, 7(30):, February 1999. (PDF)
[Merrells, 1999]
John Merrells. Editorial Overload, 7(33):, October 1999. (PDF)
[Merrells, 1999]
John Merrells. Editorial Overload, 7(34):, December 1999. (PDF)
[Merrells, 1999]
John Merrells. XML Overload, 7(34):, December 1999. (PDF)
[Merrells, 2000]
John Merrells. editorial Overload, 8(35):, February 2000. (PDF)
[Merrells, 2000]
John Merrells. Editorial Overload, 8(38):, August 2000. (PDF)
[Merrells, 2000]
John Merrells. Editorial Overload, 8(39):, October 2000. (PDF)
[Merrells, 2000]
John Merrells. editorial: Concerning Patents Overload, 8(40):, December 2000. (PDF)
[Merrells, 2001]
John Merrells. Editorial Overload, 9(41):, February 2001. (PDF)
[Merrells, 2001]
John Merrells. Editorial Overload, 9(42):, April 2001. (PDF)
[Merrells, 2001]
John Merrells. Editorial Overload, 9(43):, June 2001. (PDF)
[Merrells, 2001]
John Merrells. Editorial Overload, 9(44):, August 2001. (PDF)
[Merrells, 2001]
John Merrells. Editorial Overload, 9(45):, October 2001. (PDF)
[Merrells, 2001]
John Merrells. Editorial - Coming Home Overload, 9(46):, December 2001. (PDF)
[Merrells, 2002]
John Merrells. Editorial: Product Definition Overload, 10(47):, February 2002. (PDF)
[Merrells, 2002]
John Merrells. Editorial Overload, 10(48):, April 2002. (PDF)
[Merrells, 2002]
John Merrells. Editorial Overload, 10(49):, June 2002. (PDF)
[Merrells, 2002]
John Merrells. Editorial Overload, 10(50):, August 2002. (PDF)
[Merrells, 2002]
John Merrells. Editorial - Software Quality Overload, 10(51):, October 2002. (PDF)
[Merrells, 2002]
John Merrells. Editorial - On Writing Overload, 10(52):, December 2002. (PDF)
[Merrells, 2003]
John Merrells. Editorial Overload, 11(54):, April 2003. (PDF)
[Mertz, 2016]
Arne Mertz. Modern C++ Features: User-Defined Literals Overload, 24(136):18-19, December 2016. User-defined literals were introduced in C++11. Arne Mertz walks us through their use. (PDF)
[Mertz, 1996]
Francis Glassborow, Kevlin A. P. Henney, Colin Hersom, Graham Jones, Phil Bass, Steve Mertz, Walter Brown. editor << letters; Overload, 4(16):19-24, October 1996. (PDF)
[Meyers, 2012]
Scott Meyers. Universal References in C++11 Overload, 20(111):8-12, October 2012. C++11 provides a new reference syntax, T&&. Scott Meyers explains that it doesn’t always mean ‘rvalue reference’. (PDF)
[Microsoft, 1994]
Microsoft. Microsoft Visual C++ Strategy Overload, 2(5):21-27, September 1994. (PDF)
[Midgley, 1995]
Dave Midgley. editor << letters; Overload, 3(7):37, April 1995. (PDF)
[Midgley, 1995]
Sean A. Corfield, Keith Derrick, George Wendle, Chris Simons, Dave Midgley, Dr. James Brennig. editor << letters; Overload, 3(10):25-28, October 1995. (PDF)
[Midgley, 1996]
Sean A. Corfield, Dave Midgley, Roger Lever, Chris Simons, Andrew King, Alan Griffiths, Jay. editor << letters; Overload, 3(12):, February 1996. (PDF)
[Midgley, 1996]
Sean A. Corfield, Peter Wippell, Dave Midgley, Roger Woollett, The Harpist. editor << letters; Overload, 4(13):30-31, April 1996. (PDF)
[Midgly, 2001]
Dave Midgly. Editor << letters; Overload, 9(42):, April 2001. (PDF)
[Mill, 2014]
Robert Mill, Jonathan Coe. Defining Visitors Inline in Modern C++ Overload, 22(123):17-19, October 2014. Robert Mill and Jonathan Coe present an inline visitor in C++. (PDF)
[Mill, 2016]
Robert Mill. Polymorphic Comparisons Overload, 24(135):13-15, October 2016. Polymorphic comparisons require much boilerplate. Robert Mill and Jonathan Coe introduce a template utility for such comparisons. (PDF)
[Miller, 2006]
Peter Miller. Recursive Make Considered Harmful Overload, 14(71):20-30, February 2006. (PDF)
[Mirwaisi, 2003]
Jeff Mirwaisi. A Policy-Driven CORBA Template Library to Facilitate the Rapid Development of DOC Middleware Overload, 11(57):, October 2003. (PDF)
[Moene, 2010]
Martin Moene. One Approach to Using Hardware Registers in C++ Overload, 18(95):, February 2010. Testing increases software reliability. Martin Moene presents a technique for checking the control of hardware. (PDF)
[Moene, 2014]
Martin Moene. Static Polymorphic Named Parameters in C++ Overload, 22(119):4-6, February 2014. Adding parameters to an object can be messy. Martin Moene demonstrates how method chaining can make code more readable. (PDF)
[Moene, 2014]
Martin Moene. Search with CppCheck Overload, 22(120):23-25, April 2014. Finding code of interest is a vital skill but our tools are often too simple. Martin Moene tries something better. (PDF)
[Moffatt, 1996]
Peter Moffatt. Explorations around a linked list Overload, 4(15):6-11, August 1996. Software Development in C++ (PDF)
[Nadle, 2003]
David L. Nadle. A C++ Petri Net Framework For Multithreaded Programming Overload, 11(54):, April 2003. (PDF)
[Nash, 2015]
Phil Nash. Modern C++ Testing Overload, 23(125):10-11, February 2015. Various C++ testing framework exist. Phil Nash compares CATCH with the competition. (PDF)
[Nasonov, 2004]
Alexander Nasonov. A Little Detail Overload, 12(60):, April 2004. (PDF)
[Nasonov, 2005]
Alexander Nasonov. Better Encapsulation for the Curiously Recurring Template Pattern Overload, 13(70):, December 2005. (PDF)
[Nasonov, 2006]
Alexander Nasonov. Fine Tuning for lexical_cast Overload, 14(74):, August 2006. Alexander Nasonov takes a look at Boost's lexical_cast and addresses a common user request: "make it go faster". (PDF)
[Nasonov, 2006]
Alexander Nasonov. The Singleton in C++ - A force for good? Overload, 14(76):, December 2006. Alexander Nasonov addresses some problems that arise when using Singleton in C++. (PDF)
[Nasonov, 2007]
Alexander Nasonov. Letter to the Editor Overload, 15(77):, February 2007. Alexander Nasonov writes more on singleton. (PDF)
[Neri, 2012]
Cassio Neri. Complex Logic in the Member Initialiser List Overload, 20(112):8-13, December 2012. The syntactic form of the member initialiser list restricts the logic that it contains. Cassio Neri presents some techniques to overcome these constraints. (PDF)
[Newton, 1996]
Sean A. Corfield, Allan Newton, Graham Jones, Phil Bass, Steven Youngs. editor << letters; Overload, 4(15):35-36, August 1996. (PDF)
[Newton, 2000]
Alan Griffiths, Allan Newton. Interpreting "Supporting the 'Cheshire Cat' Idiom" Overload, 8(38):, August 2000. (PDF)
[Nilsen-Nygaard, 1997]
Einar Nilsen-Nygaard. A Finite State Machine Design Overload, 5(21):21-24, August 1997. Whiteboard (PDF)
[Nilsen-Nygaard, 1997]
Einar Nilsen-Nygaard. A Finite State Machine Design II Overload, 5(23):28-34, December 1997. Whiteboard (PDF)
[Nilsen-Nygaard, 1999]
Einar Nilsen-Nygaard. Editorial Overload, 7(31):, April 1999. (PDF)
[Nilsen-Nygaard, 1999]
Einar Nilsen-Nygaard. Editorial Overload, 7(32):, June 1999. (PDF)
[Noyes, 2014]
Malcolm Noyes. Integrating the Catch Test Framework into Visual Studio Overload, 22(119):7-10, February 2014. Visual Studio’s Test Explorer allows native C++ tests to be run under a managed wrapper. Malcolm Noyes takes it a step further using Catch to drive the tests. (PDF)
[Noyes, 2014]
Malcolm Noyes. Alternative Overloads Overload, 22(123):8-11, October 2014. Malcolm Noyes presents ways to return a default value given a condition in C++. (PDF)
[Nyquist, 1995]
Mats Henricson, Erik Nyquist. operator= and const - a reply Overload, 3(7):18, April 1995. (PDF)
[O'Neil, 2005]
David O'Neil. Two-thirds of a Pimpl and a Grin Overload, 13(70):, December 2005. (PDF)
[Oldwood, 2013]
Chris Oldwood. Utilising More Than 4GB of Memory in 32-bit Windows Process Overload, 21(113):7-11, February 2013. Some applications require a vast amount of memory. Chris Oldwood presents techniques to provide extra memory. (PDF)
[Oldwood, 2013]
Chris Oldwood. Causality - Relating Distributed Diagnostic Contexts Overload, 21(114):18-23, April 2013. Supporting a system with many moving parts can be hard. Chris Oldwood demonstrates one way to add tags to log information to aid diagnosis. (PDF)
[Oldwood, 2013]
Chris Oldwood. Simple Instrumentation Overload, 21(116):6-10, August 2013. Programs often run out of memory or grind to a halt. Chris Oldwood demonstrates how to add instrumentation to your code to track its performance. (PDF)
[Oldwood, 2013]
Chris Oldwood. Migrating from Visual SourceSafe to Git Overload, 21(118):16-20, December 2013. Migrating from one version control system to another is a big change. Chris Oldwood records the trials and triumphs of migrating from VSS to git. (PDF)
[Oldwood, 2014]
Chris Oldwood. Static - A Force for Good and Evil Overload, 22(120):18-22, April 2014. We’ve all learnt to avoid the use of the static keyword. Chris Oldwood questions this wisdom. (PDF)
[Oldwood, 2014]
Chris Oldwood. Branching Strategies Overload, 22(121):4-7, June 2014. Branching can either be embraced or avoided. Chris Oldwood documents the pros and cons of three main branching strategies. (PDF)
[Oldwood, 2014]
Chris Oldwood. KISSing SOLID Goodbye Overload, 22(122):14-17, August 2014. Can you remember what SOLID stands for? Chris Oldwood distills it down to two easy to remember principles. (PDF)
[Oldwood, 2014]
Chris Oldwood. Testing Drives the Need for Flexible Configuration Overload, 22(124):22-24, December 2014. Inflexible configuration will cause problems. Chris Oldwood demonstrates how to support multiple configurations flexibly. (PDF)
[Oldwood, 2015]
Chris Oldwood. Terse Exception Messages Overload, 23(127):15-17, June 2015. Log files often contain ‘error’ information. Chris Oldwood suggests they rarely contain anything that could be considered helpful. (PDF)
[Oldwood, 2016]
Chris Oldwood. Afterwood Overload, 24(133):31-32, June 2016. Magazines sometimes use the back page for adverts or summaries. Chris Oldwood has decided to provide us with his afterwords, or ‘afterwood’. (PDF)
[Oldwood, 2016]
Chris Oldwood. Afterwood Overload, 24(134):28, August 2016. Barriers can cause bottlenecks. Chris Oldwood considers varying approaches to gatekeeping. (PDF)
[Oldwood, 2016]
Chris Oldwood. Afterwood Overload, 24(135):32, October 2016. Comedy partnerships have a long history. Chris Oldwood considers their lessons for programmers. (PDF)
[Oldwood, 2016]
Chris Oldwood. Afterwood Overload, 24(136):30, December 2016. One JavaScript module was removed and every Node.js build was knocked for six. Chris Oldwood fictionalises the tale. (PDF)
[Oldwood, 2017]
Chris Oldwood. Afterwood Overload, 25(137):28, February 2017. Trying to find a good candidate for a role is hard. Chris Oldwood reminisces on various factors that influence interviewers. (PDF)
[Oldwood, 2017]
Chris Oldwood. Afterwood Overload, 25(139):20, June 2017. What makes programming fun? Chris Oldwood ponders what floats his boat. (PDF)
[Oldwood, 2017]
Chris Oldwood. Afterwood Overload, 25(140):28, August 2017. Chris Oldwood reminds us to fix the problem, not to blame. (PDF)
[Oldwood, 2017]
Chris Oldwood. Afterwood Overload, 25(141):32, October 2017. Too soon! Chris Oldwood reviews optimisation in the development process. (PDF)
[Oldwood, 2017]
Chris Oldwood. Afterwood Overload, 25(142):20, December 2017. Tabs are controversial. Chris Oldwood reminds us of their many guises. (PDF)
[Oldwood, 2018]
Chris Oldwood. Afterwood Overload, 26(143):24, February 2018. Can you code on paper in an interview? Chris Oldwood recounts his attempts to write a calendar. (PDF)
[Oldwood, 2018]
Chris Oldwood. Monitoring: Turning Noise into Signal Overload, 26(144):8-11, April 2018. Creating useful logging is a constant challenge. Chris Oldwood shows us how structured logging helps. (PDF)
[Oliva, 2014]
Daniel Gutson, Pablo Oliva. Minimal Overhead for Multiple Interfaces Overload, 22(121):14-16, June 2014. Using multiple interfaces can slow things down. Daniel Gutson and Pablo Oliva present an alternative. (PDF)
[Orr, 2004]
Roger Orr. Efficient Exceptions? Overload, 12(61):, June 2004. (PDF)
[Orr, 2004]
Roger Orr. Microsoft Visual C++ and Win32 Structured Exception Handling Overload, 12(63):, October 2004. Source: Microsoft Visual c++, structured exception handling. (PDF)
[Orr, 2005]
Roger Orr. Microsoft Symbol Engine Overload, 13(67):, June 2005. (PDF)
[Orr, 2005]
Roger Orr. Investigating Java Class Loading Overload, 13(68):, August 2005. (PDF)
[Orr, 2007]
Roger Orr. Release Mode Debugging Overload, 15(80):, August 2007. Although we try not to put bugs into software, sometimes we must track them down to remove them. Roger Orr considers the difficulties when they can only be seen in release builds. (PDF)
[Orr, 2007]
Roger Orr. Java Protocol Handlers Overload, 15(82):, December 2007. Roger Orr demonstrates the use of Java's URL handling to make code independent of the source of data. (PDF)
[Orr, 2008]
Roger Orr. When Things Go Wrong Overload, 16(83):, February 2008. Can we reduce the pain of computer problems? (PDF)
[Orr, 2011]
Steve Love, Roger Orr. Some Objects Are More Equal Than Others Overload, 19(103):4-9, June 2011. Comparing objects is a fundamental operation. Steve Love and Roger Orr consider different language approaches. (PDF)
[Orr, 2013]
Roger Orr. Auto - A Necessary Evil? Overload, 21(115):4-7, June 2013. Superficially simple language features can be surprisingly complicated. Roger Orr explores a new one that is likely to be used widely. (PDF)
[Orr, 2013]
Roger Orr. Auto - a necessary evil? (Part 2) Overload, 21(116):21-24, August 2013. Should you declare (almost) everything auto? Roger Orr considers when auto is appropriate. (PDF)
[Orr, 2014]
Roger Orr. Windows 64-bit Calling Conventions Overload, 22(120):26-31, April 2014. How the stack works is useful to understanding your programs’ behaviour. Roger Orr compares and contrasts. (PDF)
[Orr, 2014]
Roger Orr. Order Notation in Practice Overload, 22(124):14-20, December 2014. What does complexity measurement mean? Roger Orr reminds us of the academic definition and looks at some real life situations. (PDF)
[Orr, 2016]
Roger Orr. Concepts Lite in Practice Overload, 24(133):24-30, June 2016. Concepts should make templates easier to use and write. Roger Orr gives a practical example to show this. (PDF)
[Orr, 2018]
Roger Orr. CTAD - What Is This New Acronym All About? Overload, 26(143):13-15, February 2018. What is class template argument deduction? Roger Orr elucidates this new C++17 feature. (PDF)
[Oualline, 1996]
Steve Oualline. Practical C++ Programming a response from Steve Oualline Overload, 4(14):20, June 1996. Reviews (PDF)
[Overload, 2007]
Overload. Guidelines for Contributors Overload, 15(80):, August 2007. Thinking of writing for us? Follow these guidelines to help smooth the way. (PDF)
[Page, 1993]
Steve Page. Starting out with OWL Overload, 1(1):, April 1993. (PDF)
[Pamudurthy, 2017]
Satprem Pamudurthy. A Functional Alternative to Dependency Injection in C++ Overload, 25(140):22-24, August 2017. Satprem Pamudurthy showcases a functional alternative to dependency injection in C++. (PDF)
[Pamudurthy, 2017]
Satprem Pamudurthy. Polymorphism in C++ - A Type Compatibility View Overload, 25(141):14-17, October 2017. Satprem Pamudurthy compiles an exhaustive matrix of polymorphism. (PDF)
[Parkin, 2004]
Ric Parkin. Garbage Collection and Object Lifetime Overload, 12(63):, October 2004. (PDF)
[Parkin, 2007]
Ric Parkin. While the Cat's Away... Overload, 15(81):, October 2007. ...instead of spending your time playing, why not learn to be multi-lingual in a multi-cultural world? (PDF)
[Parkin, 2008]
Ric Parkin. Plus ça change Overload, 16(85):, June 2008. 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. (PDF)
[Parkin, 2008]
Ric Parkin. It's good to talk... Overload, 16(86):, August 2008. Writing code is only part of developing software. (PDF)
[Parkin, 2008]
Ric Parkin. The Invisible Hand Overload, 16(87):, October 2008. Large groups can behave as one, but how predicatable are they? (PDF)
[Parkin, 2008]
Ric Parkin. The Sweet Smell of Success Overload, 16(88):, December 2008. If your last project wasn't successful, you're not alone... (PDF)
[Parkin, 2009]
Ric Parkin. Watt's going on? Overload, 17(89):, February 2009. Just how much power are you using... (PDF)
[Parkin, 2009]
Ric Parkin. Back to School Overload, 17(90):, April 2009. Much is made of the Knowledge Economy. But just how can you keep up to date? (PDF)
[Parkin, 2009]
Ric Parkin. A Good Craftsman Knows His Tools Overload, 17(91):, June 2009. Are you using the right ones? Ric Parkin looks in his toolbox... (PDF)
[Parkin, 2009]
Ric Parkin. Moments in History Overload, 17(92):, August 2009. Technology shapes our world. Ric Parkin looks back at 40 years of change. (PDF)
[Parkin, 2009]
Ric Parkin. All together now. Overload, 17(93):, October 2009. Can you do several things at once? Ric Parkin tries multi-tasking. (PDF)
[Parkin, 2010]
Ric Parkin. Back To The Future Overload, 18(95):, February 2010. The last decade has seen huge changes. Ric Parkin looks at technology and its effects. (PDF)
[Parkin, 2010]
Ric Parkin. Dealing with Growing Pains Overload, 18(96):, April 2010. Expanding your team is never easy. Ric Parkin experiences the recruiting process. (PDF)
[Parkin, 2010]
Ric Parkin. The Art of the Possible Overload, 18(97):, June 2010. In polite company you should never talk about religion or politics. Ric Parkin makes an exception. (PDF)
[Parkin, 2010]
Ric Parkin. A Little Learning Is A Dangerous Thing Overload, 18(98):2-3, August 2010. An opportunity for nostalgia triggers some musings on the value of education. Ric Parkin goes back to school. (PDF)
[Parkin, 2010]
Ric Parkin. Lies, Damn Lies, and Statistics Overload, 18(99):2-3, October 2010. Making a good decision is vital. Ric Parkin looks at what information we use. (PDF)
[Parkin, 2010]
Ric Parkin. Numbers and The Appliance of Science Overload, 18(100):2-3, December 2010. How sure are you of something? Ric Parkin considers how we build models, and celebrates a milestone. (PDF)
[Parkin, 2011]
Ric Parkin. Ah! The fog is lifting! Overload, 19(101):2-3, February 2011. Futurology has a dismal track record. Ric Parkin looks at the history of technology predictions. (PDF)
[Parkin, 2011]
Ric Parkin. This Year’s Model Overload, 19(102):2, April 2011. Design and development requires us to think about the world. Ric Parkin considers some ways of coping with the complexity. (PDF)
[Parkin, 2011]
Ric Parkin. Can you keep a secret? Overload, 19(103):2, June 2011. Privacy and security have been in the news a lot recently. Ric Parkin looks behind the curtain. (PDF)
[Parkin, 2011]
Ric Parkin. Rise of the Machines Overload, 19(104):2, August 2011. Been having trouble with technology or simple devices? Ric Parkin fears for our future (PDF)
[Parkin, 2011]
Ric Parkin. A Journey Through History Overload, 19(105):2-3, October 2011. Despite early pioneers, the computer revolution is relatively young. Ric Parkin takes a personal tour. (PDF)
[Parkin, 2011]
Ric Parkin. Patently Ridiculous! Overload, 19(106):2, December 2011. Software patents have a chequered history. Ric Parkin looks at some of the problems. (PDF)
[Parkin, 2012]
Ric Parkin. Many Hands Make Light Work Overload, 20(107):2-3, February 2012. Some people say the parallel revolution is coming. Ric Parkin argues it’s in full swing. (PDF)
[Parkin, 2012]
Ric Parkin. The Computing Revolution Will Be Televised (Again) Overload, 20(108):2-3, April 2012. 30 years ago we had to plug our first computers into the TV. Ric Parkin looks at how far we’ve come since then. (PDF)
[Parkin, 2012]
Ric Parkin. It’s Not What You Know, It’s Who You Know Most human endeavours are not solitary pursuits. Overload, 20(109):2, June 2012. Ric Parkin looks at the interconnection of everyone. (PDF)
[Parkin, 2013]
Ric Parkin. Fantasy Languages Overload, 21(115):2-3, June 2013. Software is all about describing a solution to a computer. Ric Parkin imagines what his ideal dialect would sound like. (PDF)
[Parkin, 2014]
Ric Parkin. Editorial: Your Life in Their Hands Overload, 22(120):2-3, April 2014. We leave an increasingly detailed digital footprint. Ric Parkin worries who can see it. (PDF)
[Parking, 2009]
Ric Parking. A Crack in Time Overload, 17(94):2, December 2009. Encoding messages has a long history. Ric Parking looks back at how this affected computing. (PDF)
[Peck, 2014]
Andrew Peck. People of the .Doc Overload, 22(124):21, December 2014. Technical communication is often misunderstood by the world at large. Andrew Peck breaks down the rhetoric from a technical author’s perspective. (PDF)
[Penhey, 2005]
Tim Penhey. With Spirit Overload, 13(69):, October 2005. (PDF)
[Penhey, 2006]
Tim Penhey. Dead Code Overload, 14(71):13-15, February 2006. (PDF)
[Penhey, 2006]
Tim Penhey. Multithreading 101 Overload, 14(72):, April 2006. (PDF)
[Percy, 1996]
Richard Percy. Go with the flow Overload, 4(15):11-15, August 1996. Software Development in C++ (PDF)
[Percy, 1996]
Richard Percy. Go with the flow - part II Overload, 4(16):8-13, October 1996. Software Development in C++ (PDF)
[Percy, 1997]
Richard Percy. A model for backsolving Overload, 5(19):24-29, April 1997. C++ Techniques (PDF)
[Percy, 1997]
Kevlin Henney, Richard Percy, Jonathan Jagger. editor << letters; Overload, 5(20):36-37, June 1997. (PDF)
[Petersen, 2006]
Adam Petersen. Objects for States Overload, 14(73):, June 2006. Originally captured in Design Patterns, Objects for States is described in close conjunction with the Singleton pattern. This article investigates better alternatives for implementing the pattern in C++. (PDF)
[Petersen, 2007]
Adam Petersen. Design in Test-Driven Development Overload, 15(78):, April 2007. With its roots in Japanese just-in-time manufacturing, Test-Driven Development (TDD) puts the traditional development process on its head. Adam Petersen discusses when to use TDD, how to use it successfully, and its use in up-front design. (PDF)
[Petersen, 2013]
Adam Petersen. The Signs of Trouble: On Patterns, Humbleness and Lisp Overload, 21(113):12-13, February 2013. Patterns can be a controversial topic. Adam Petersen considers their cognitive and social value. (PDF)
[Pilgrim, 1998]
Peter Pilgrim. Debuggable new and delete, Part Two Overload, 6(25):29-34, April 1998. Whiteboard (PDF)
[Pilgrim, 1997]
Peter A. Pilgrim. Debug new and delete, Preamble Overload, 5(23):34-37, December 1997. Whiteboard (PDF)
[Pilgrim, 1998]
Peter A. Pilgrim. Debug new and delete Part 3 Overload, 6(29):, December 1998. (PDF)
[Pilgrim, 2000]
Peter A. Pilgrim. An Implementation of Double Dispatch in Java Overload, 8(36):, April 2000. (PDF)
[Pinchbeck, 2001]
Antony Pinchbeck. Thread Pooling: An Investigation Overload, 9(41):, February 2001. (PDF)
[Pinchbeck, 2001]
Antony Pinchbeck. Typesafe Registry for Windows Overload, 9(42):, April 2001. (PDF)
[Polton, 2010]
Richard Polton. The Functional Student: A Game of Six Integers Overload, 18(97):, June 2010. The Countdown numbers game is a popular challenge. Richard Polton tries a new language to solve it. (PDF)
[Posul, 2000]
Waldo Posul. File Headers Overload, 8(35):, February 2000. (PDF)
[Poynter, 2004]
Ray Poynter. Letters to the Editor(s) Overload, 12(60):, April 2004. (aka Dr Ray Poynter CEng CPhys MBCS MInstP) (PDF)
[Quintel, 1999]
Henrik Quintel. Garbage Collection Implementation Considerations Overload, 7(30):, February 1999. (PDF)
[Radford, 1997]
Mark Radford. Observations on the Design of an Address Class Overload, 5(19):4-5, April 1997. Software Development in C++ (PDF)
[Radford, 1997]
Roger Lever, Mark Radford. The Uses and Abuses of Inheritance Overload, 5(19):6-8, April 1997. Software Development in C++ (PDF)
[Radford, 1998]
Mark Radford. Protecting Member Data's Right to Privacy Overload, 6(24):28-31, February 1998. Whiteboard (PDF)
[Radford, 1999]
Mark Radford. Factories in C++: Disposing of the Product Overload, 7(31):, April 1999. (PDF)
[Radford, 2001]
Mark Radford. Extensibility - A Reason For Using Streams in C++ Overload, 9(41):, February 2001. (PDF)
[Radford, 2001]
Mark Radford. Designing C++ Interfaces - Exception Safety Overload, 9(43):, June 2001. (PDF)
[Radford, 2001]
Mark Radford. Designing C++ Interfaces - Templates Overload, 9(44):, August 2001. (PDF)
[Radford, 2002]
Mark Radford. Patterns Collaborations: Observer and Composite Overload, 10(51):, October 2002. (PDF)
[Radford, 2003]
Mark Radford. Reshaping an Old Piece of Design Overload, 11(56):, August 2003. (PDF)
[Radford, 2003]
Mark Radford. SINGLETON - the anti-pattern! Overload, 11(57):, October 2003. (PDF)
[Radford, 2004]
Mark Radford. Editorial Overload, 12(59):, February 2004. (PDF)
[Radford, 2004]
Mark Radford. Editorial Overload, 12(60):, April 2004. (PDF)
[Radford, 2004]
Mark Radford. C++ Interface Classes - An Introduction Overload, 12(62):, August 2004. (PDF)
[Radford, 2004]
Mark Radford. Editorial: The Buzzword Adoption Pattern? Overload, 12(63):, October 2004. (PDF)
[Radford, 2005]
Alan Griffiths, Mark Radford. Separating Interface and Implementation in C++ Overload, 13(66):, April 2005. (PDF)
[Radford, 2005]
Mark Radford. Taming Complexity: A Class Hierarchy Tale Overload, 13(67):, June 2005. (PDF)
[Radford, 2005]
Mark Radford. C++ Interface Classes - Noise Reduction Overload, 13(68):, August 2005. Interface classes are a principle mechanism for separating a class' interface from its implementation in C++. I wrote an introduction to interface classes in a previous article. In this article, I intend to explore interface classes - and their implementation classes - further. (PDF)
[Radford, 2006]
Mark Radford. Friend or Foe! Overload, 14(71):18-19, February 2006. (PDF)
[Radford, 2006]
Mark Radford. C++ Interface Classes - Strengthening Encapsulation Overload, 14(76):, December 2006. Mark looks at the separation of interface and implementation in C++, and how the separation helps to strengthen encapsulation. (PDF)
[Rahman, 1995]
Fazl Rahman. editor << letters; Overload, 3(8):40, June 1995. (PDF)
[Rahman, 2004]
Fazl Rahman. Transforming XML with XSLT Overload, 12(60):, April 2004. (PDF)
[Ramey, 2017]
Robert Ramey. Correct Integer Operations with Minimal Runtime Penalties Overload, 25(137):20-27, February 2017. Results of C++ integer operations are not guaranteed to be arithmetically correct. Robert Ramey introduces a library to enforce correct behaviour. (PDF)
[Ramírez, 2017]
Aurora Ramírez, Chris Simons. Evolutionary Computing Frameworks for Optimisation Overload, 25(142):14-19, December 2017. Evolutionary algorithms can find optimal solutions to problems. Aurora Ramírez and Chris Simons give us an overview. (PDF)
[Reese, 2011]
Bjørn Reese. Thread-Safe Access Guards Overload, 19(104):10-12, August 2011. Ensuring safe access to shared data can be cumbersome and error-prone. Bjørn Reese presents a technique to help. (PDF)
[Richards, 1997]
Eric Richards. Borland C++ Builder for expert programmers Overload, 5(19):10-12, April 1997. Software Development in C++ (PDF)
[Ridout, 1998]
Aaron Ridout. Shallow Pointer Overload, 6(28):, October 1998. (PDF)
[Ridout, 1998]
Aaron Ridout. Editor << letters; Overload, 6(28):, October 1998. (PDF)
[Ridout, 1999]
Aaron Ridout. editor << letters; Overload, 7(33):, October 1999. (PDF)
[Ridout, 1999]
Aaron Ridout. editor << letters; Overload, 7(34):, December 1999. (PDF)
[Ridout, 2000]
Aaron Ridout. editor << letters; Overload, 8(37):, June 2000. (PDF)
[Rose, 1998]
Seb Rose. ‘There may be trouble ahead’ Overload, 6(24):31-34, February 1998. Whiteboard (PDF)
[Rose, 1999]
Seb Rose. Objects In Databases Overload, 7(31):, April 1999. (PDF)
[Rose, 2003]
Seb Rose. Labouring: An Analogy Overload, 11(54):, April 2003. (PDF)
[Rose, 2013]
Seb Rose. Executable Documentation Doesn’t Have To Slow You Down Overload, 21(114):24-26, April 2013. Comprehensibility of end-to-end scenarios and quick feedback of unit tests are competing goals. Seb Rose introduces Cucumber with tags to meet both needs. (PDF)
[Rose, 2013]
Seb Rose. Lies, Damn Lies and Estimates Overload, 21(117):9-11, October 2013. Predicting how long something will take is hard. Seb Rose takes us on a brief tour through the swamp that is estimation. (PDF)
[Rose, 2014]
Seb Rose. The Code Is Not the Most Important Thing Overload, 22(121):10-11, June 2014. Choose the right sort of problem, focus on strategies for solving it, and the code will come easily. Seb Rose teaches kids to code. (PDF)
[Rose, 2014]
Seb Rose. TDD Discussions and Disagreements Overload, 22(122):18-20, August 2014. Recently people have been arguing about the benefits and pitfalls if TDD. Seb Rose summarises the differing standpoints and presents his own. (PDF)
[Ross, 1996]
Alec Ross. Circles and ellipses revisited Overload, 4(15):24-27, August 1996. C++ Techniques (PDF)
[Ross, 1996]
Alec Ross. Circles and Ellipses revisited: coding techniques - an introduction Overload, 4(16):15-18, October 1996. C++ Techniques (PDF)
[Ross, 1997]
Alec Ross. Circles and Ellipses revisited: coding techniques - 2 Overload, 5(17/18):, January 1997. A second approach: In-store changes (PDF)
[Ross, 1997]
Alec Ross. Circles and Ellipses Revisited: Coding Techniques - 3 Overload, 5(21):4-7, August 1997. Software Development in C++ (PDF)
[Rosvall, 2004]
Sven Rosvall. C++ as a Safer C Overload, 12(59):, February 2004. (PDF)
[Rosvall, 2004]
Sven Rosvall. C++ Lookup Mysteries Overload, 12(63):, October 2004. (PDF)
[Rumsby, 1995]
Steve Rumsby. C++ - the official UK site maintained by Steve Rumsby Overload, 3(8):15, June 1995. The Draft International C++ Standard (PDF)
[Rutland, 1995]
Nicholas Rutland. editor << letters; Overload, 3(7):40, April 1995. (PDF)
[Rybarski, 2006]
Seweryn Habdank-Wojewódzki, Janusz Rybarski. The Kohonen Neural Network Library Overload, 14(74):, August 2006. Seweryn Habdank-Wojewódzki and Janusz Rybarski present a C++ library for users of Kohonen Neural Networks. (PDF)
[Rüegg, 2012]
Michael Rüegg. Refactoring Towards Seams in C++ Overload, 20(108):29-32, April 2012. Breaking dependencies in existing code is hard. Michael Rüegg explains how seams can help and provides new automated refactorings for C++ to achieve them. (PDF)
[Rüegg, 2012]
Michael Rüegg. Simple Mock Objects for C++11 Overload, 20(110):19-21, August 2012. New C++11 features can be used to implement mock objects for unit tests. Michael Rüegg shows us how he does this in Mockator. (PDF)
[Saha, 2011]
Arun Saha. Benefits of Well Known Interfaces in Closed Source Code Overload, 19(102):4-7, April 2011. Designing a good API is a significant challenge. Arun Saha suggests taking inspiration from outside. (PDF)
[Saha, 2018]
Arun Saha. Practical Scale Testing Overload, 26(143):18-20, February 2018. Everyone wants scalable systems. Arun Saha explores methods for testing scalability. (PDF)
[Scattergood, 1995]
Bryan Scattergood. From polymorphism to garbage collection Overload, 3(8):36-39, June 1995. (PDF)
[Schmidt, 2014]
Bob Schmidt. A Scheduling Technique for Small Software Projects and Teams Overload, 22(123):20-23, October 2014. Bob Schmidt presents some tips for accurate scheduling. (PDF)
[Schmidt, 2014]
Bob Schmidt. Ruminations on Self Employment and Running a Business Overload, 22(124):9-12, December 2014. Being self-employed has pros and cons. Bob Schmidt reviews what he has learnt about running your own business. (PDF)
[Schmidt, 2015]
Bob Schmidt. I Like Whitespace Overload, 23(125):12-16, February 2015. Programming style can cause endless arguments. Bob Schmidt shares why he thinks whitespace matters. (PDF)
[Schmidt, 2015]
Bob Schmidt. Alternatives to Singletons and Global Variables Overload, 23(126):9-13, April 2015. Global variables and Singletons are usually considered bad. Bob Schmidt summarises some alternatives. (PDF)
[Schmidt, 2015]
Bob Schmidt. CPU Clocks and Clock Interrupts, and Their Effects on Schedulers Overload, 23(130):23-28, December 2015. Instructions to sleep for a second almost never result in precisely one second’s sleep. Bob Schmidt walks us through the mechanics of why. (PDF)
[Schoenborn, 2001]
Oliver Schoenborn. Where is __FUNCTION__? Overload, 9(41):, February 2001. (PDF)
[Schoenborn, 2001]
Oliver Schoenborn. Editor << letters; Overload, 9(42):, April 2001. (PDF)
[Schoenborn, 2002]
Oliver Schoenborn. Tiny Template Tidbit Overload, 10(47):, February 2002. (PDF)
[Schoenborn, 2003]
Oliver Schoenborn. Addendum to "Tiny Template Tidbit" Overload, 11(54):, April 2003. (PDF)
[Sebright, 2004]
Simon Sebright. Letters to the Editor(s) Overload, 12(60):, April 2004. (PDF)
[Sebright, 2006]
Simon Sebright. Up Against the Barrier Overload, 14(75):, October 2006. A discussion of development against the odds, describing process, personal and environmental barriers between the people and the job they are trying to do. (PDF)
[Sebright, 2007]
Simon Sebright. A Perspective on Use of Conditional Statements versus Assertions Overload, 15(78):, April 2007. Simon Sebright offers us the benefit of his experience. (PDF)
[Sedge, 2011]
Tom Sedge. Systems Thinking Software Development Overload, 19(103):24-30, June 2011. Many processes cause more problems than they solve. Tom Sedge shows how to tailor your own. (PDF)
[Seifort, 1994]
Justin Seifort. Shared Memory Class Overload, 2(4):, February 1994. (PDF)
[Sellem, 1996]
Sean A. Corfield, Remi Sellem, Bryan Colyer, Phil Bass, Colin Harkness, Steve Watson. editor << letters; Overload, 4(14):18-19, June 1996. (PDF)
[Shagov, 2006]
George Shagov. Inventing a Mutex Overload, 14(75):, October 2006. A mutex is a general purpose tool - there may be better solutions in specific circumstances. George Shagov presents one such alternative. (PDF)
[Sharp, 2010]
Helen Sharp. What motivates software developers: a workshop report Overload, 18(99):10-13, October 2010. Keeping your team happy should be more than guesswork. Helen Sharp went and asked you. (PDF)
[Short, 1993]
Graham Short. A Short Exposure to C++ Overload, 1(3):, August 1993. (PDF)
[Shotton, 1995]
Phil Shotton. editor << letters; Overload, 3(7):35, April 1995. (PDF)
[Shriver, 2009]
Ryan Shriver. Measurable Value with Agile Overload, 17(89):, February 2009. Are you solving the right problem or simply solving the problem right? Ryan Shriver shows us that both are needed for value delivery. (PDF)
[Simons, 1995]
Sean A. Corfield, Keith Derrick, George Wendle, Chris Simons, Dave Midgley, Dr. James Brennig. editor << letters; Overload, 3(10):25-28, October 1995. (PDF)
[Simons, 1996]
Sean A. Corfield, Dave Midgley, Roger Lever, Chris Simons, Andrew King, Alan Griffiths, Jay. editor << letters; Overload, 3(12):, February 1996. (PDF)
[Simons, 2017]
Aurora Ramírez, Chris Simons. Evolutionary Computing Frameworks for Optimisation Overload, 25(142):14-19, December 2017. Evolutionary algorithms can find optimal solutions to problems. Aurora Ramírez and Chris Simons give us an overview. (PDF)
[Simons, 1995]
Christopher Simons. editor << letters; Overload, 3(7):36-37, April 1995. (PDF)
[Slettebø, 2005]
Terje Slettebø. Letters to the Editor Overload, 13(67):, June 2005. (PDF)
[Smart, 1995]
John Smart. A Text Formatting Class Overload, 3(6):, March 1995. (PDF)
[Smart, 1996]
John Smart. Handling dates with locale based day and month information Overload, 3(12):29-34, February 1996. ++puzzle; (PDF)
[Smith, 2001]
Julian Smith. Multimethods Overload, 9(42):, April 2001. (PDF)
[Sommerlad, 2006]
Peter Sommerlad. C++ Unit Testing Easier: CUTE Overload, 14(75):, October 2006. Peter Sommerlad presents a lightweight framework for C++ unit testing. (PDF)
[Sommerlad, 2007]
Raoul Gough, Hubert Matthews, Peter Sommerlad. Letters to the Editor Overload, 15(78):, April 2007. (PDF)
[Sommerlad, 2015]
Peter Sommerlad. Variadic and Variable Templates Overload, 23(126):14-17, April 2015. C++11 and 14 offer new features for Variadic and Variable templates. Peter Sommerlad showcases the compile-time possibilities they offer. (PDF)
[Southern, 1996]
Chris Southern. Java in a Nutshell reviewed by Chris Southern Overload, 4(15):37, August 1996. (PDF)
[Southern, 1996]
Francis Glassborow, Chris Southern, Klitos Kyriacou. The return type of member functions Overload, 4(15):29-33, August 1996. C++ Techniques (PDF)
[Southern, 1997]
John Merrells, The Harpist, George Wendle, Francis Glasborow, Chris Southern. editor << letters; Overload, 5(22):, October 1997. (PDF)
[Southern, 1999]
Chris Southern. Response To "Patterns - The Abstract Factory" (Francis Glassborow, Overload 30) Overload, 7(31):, April 1999. (PDF)
[Sposato, 2003]
Rich Sposato. A More Flexible Container Overload, 11(58):, December 2003. (PDF)
[Standish, 2016]
Russell Standish. Classdesc: A Reflection System for C++11 Overload, 24(131):18-23, February 2016. C++ lacks direct support for reflection. Russell Standish brings an automated reflection system for C++, Classdesc, up to date. (PDF)
[Stanimirov, 2018]
Borislav Stanimirov. The Interface to Component Pattern and DynaMix Overload, 26(144):12-15, April 2018. Dynamic Polymorphism is hard in C++. Borislav Stanimirov demonstrates how the DynaMix library helps. (PDF)
[Steinbach, 2013]
Alf Steinbach. Portable String Literals in C++ Overload, 21(116):11-15, August 2013. How hard can it be to make a file in C++ with international text literals in its name? Alf Steinbach shows us. (PDF)
[Steinbach, 2017]
Alf Steinbach. Portable Console I/O via iostreams Overload, 25(140):14-21, August 2017. Alf Steinbach describes how his library fixes problems streaming non-ASCII characters in Windows. (PDF)
[Strobel, 2014]
Lee Benfield, Mike Strobel. Anatomy of a Java Decompiler Overload, 22(119):11-15, February 2014. Java byte code can be reverted back into source code. Lee Benfield and Mike Strobel show how. (PDF)
[Stroustrup, 1998]
Bjarne Stroustrup. Generalizing Overloading for C++2000 Overload, 6(25):20-24, April 1998. The Draft International C++ Standard (PDF)
[Stroustrup, 2009]
Bjarne Stroustrup. No 'Concepts' in C++0x Overload, 17(92):, August 2009. There have been some major decisions made about the next C++ Standard. Bjarne Stroustrup explains what's changed and why. (PDF)
[Summerfield, 1994]
M.N. Summerfield. Are “Safe” Computer Systems Possible? Overload, 2(5):5-7, September 1994. (PDF)
[Summerfield, 2011]
Mark Summerfield. Concurrent Programming with Go Overload, 19(106):25-28, December 2011. Concurrency is becoming ever more important. Mark Summerfield looks at the approach of the new language Go. (PDF)
[Surman, 2011]
Eugene Surman. Queue with Position Reservation Overload, 19(101):4-7, February 2011. Multiple threads can make processing a message queue faster. Eugene Surman needs the right data structure. (PDF)
[Sutter, 2017]
Herb Sutter. Metaclasses: Thoughts on Generative C++ Overload, 25(140):10-11, August 2017. Herb Sutter shows how metaclasses could simplify C++ with minimal library extension. (PDF)
[Sutton, 2015]
Andrew Sutton. Introducing Concepts Overload, 23(129):4-8, October 2015. Concepts in C++11 had many false starts. Andrew Sutton show why they are a big deal now they are with us. (PDF)
[Sutton, 2015]
Jonathan Coe, Andrew Sutton. An Inline-variant-visitor with C++ Concepts Overload, 23(129):17-20, October 2015. Concepts are abstract. Jonathan Coe and Andrew Sutton provide us with a concrete example of their use. (PDF)
[Sutton, 2016]
Andrew Sutton. Defining Concepts Overload, 24(131):4-8, February 2016. Concepts provide a new way of constraining code. Andrew Sutton shows us how to define and use them. (PDF)
[Sutton, 2016]
Andrew Sutton. Overloading with Concepts Overload, 24(136):6-11, December 2016. Concepts can play a role in function overloading. Andrew Sutton shows us how. (PDF)
[Taylor, 2004]
Richard Taylor. Letters: The Invisibility of Software Design Overload, 12(61):, June 2004. (PDF)
[Terje, 2005]
Terje. Letter to the Editor Overload, 13(66):, April 2005. (PDF)
[The Harpist, 1995]
The Harpist. Related objects Overload, 3(7):24-28, April 1995. (PDF)
[The Harpist, 1995]
The Harpist. Having Multiple Personalities Overload, 3(8):30-33, June 1995. (PDF)
[The Harpist, 1995]
The Harpist. Joy Unconfined - reflections on three issues Overload, 3(9):12-14, August 1995. (PDF)
[The Harpist, 1995]
The Harpist. Addressing polymorphic types Overload, 3(10):16-21, October 1995. C++ Techniques (PDF)
[The Harpist, 1995]
The Harpist. Java? Where is that? Overload, 3(11):15-18, December 1995. Software Development in C++ (PDF)
[The Harpist, 1996]
The Harpist. The Standard Template Library - first steps: sequence containers Overload, 4(13):21-24, April 1996. C++ Techniques (PDF)
[The Harpist, 1996]
Sean A. Corfield, Peter Wippell, Dave Midgley, Roger Woollett, The Harpist. editor << letters; Overload, 4(13):30-31, April 1996. (PDF)
[The Harpist, 1996]
The Harpist. The Standard Template Library - first steps auto_ptr Overload, 4(14):12-15, June 1996. C++ Techniques (PDF)
[The Harpist, 1996]
The Harpist. The Standard Template Library - sorted associative containers part 1 set & multiset Overload, 4(15):27-29, August 1996. C++ Techniques (PDF)
[The Harpist, 1997]
The Harpist. Standard containers for polymorphic types Overload, 5(17/18):, January 1997. (PDF)
[The Harpist, 1997]
The Harpist. New Keywords For... Overload, 5(19):17-21, April 1997. The Draft International C++ Standard (PDF)
[The Harpist, 1997]
The Harpist. The Pitfall of Being Ignorant Overload, 5(20):13-17, June 1997. C++ Techniques (PDF)
[The Harpist, 1997]
The Harpist. Rational Values Overload, 5(21):27-30, August 1997. Whiteboard (PDF)
[The Harpist, 1997]
John Merrells, The Harpist, George Wendle, Francis Glasborow, Chris Southern. editor << letters; Overload, 5(22):, October 1997. (PDF)
[The Harpist, 1997]
The Harpist. Rational Values Implementation Part 1 Overload, 5(22):27-30, October 1997. (PDF)
[The Harpist, 1997]
The Harpist. Rational Values Implementation Part 2 Overload, 5(23):23-28, December 1997. Whiteboard (PDF)
[The Harpist, 1998]
The Harpist. Rational Values Part 3 Overload, 6(24):23-28, February 1998. Whiteboard (PDF)
[The Harpist, 1998]
The Harpist. Implementations & Interfaces Overload, 6(25):26-29, April 1998. Whiteboard (PDF)
[The Harpist, 1998]
The Harpist. Object Design and Implementation Overload, 6(26):22-26, June 1998. Whiteboard (PDF)
[The Harpist, 1998]
The Harpist. Object (low-level) Design and Implementation Overload, 6(27):, August 1998. (PDF)
[The Harpist, 1998]
The Harpist. Exceptions & Exception Specifications Overload, 6(28):, October 1998. (PDF)
[The Harpist, 1998]
Ken Hagan, The Harpist. Exception Discussion Overload, 6(29):, December 1998. (PDF)
[The Harpist, 1998]
The Harpist. Exception Specifications Overload, 6(29):, December 1998. (PDF)
[The Harpist, 1999]
Ken Hagan, The Harpist. A Letter from Ken Hagan annotated by The Harpist Overload, 7(30):, February 1999. (PDF)
[The Harpist, 1999]
The Harpist. Overloading Operators Overload, 7(30):, February 1999. (PDF)
[The Harpist, 1999]
The Harpist. Micro-Derivation & Related Ideas Overload, 7(32):, June 1999. (PDF)
[Thomas, 2012]
Andy Thomas. Back to School Overload, 20(108):12-13, April 2012. The Sinclair ZX Spectrum will be 30 years old in April 2012. Andy Thomas recalls how this plucky little home computer shaped his childhood. (PDF)
[Thomason, 2017]
Andy Thomason. Single Module Builds - The Fastest Heresy in Town Overload, 25(138):7-9, April 2017. Unity builds can be controversial. Andy Thomason shows how much difference they can make to build times. (PDF)
[Thomason, 2017]
Andy Thomason. Vulkan and you - Khronos’ successor to OpenGL Overload, 25(139):12-14, June 2017. Various graphics APIs exist. Andy Thomason unravels the mysteries of Vulkan, the latest 3D Graphics API from Khronos, the custodians of OpenGL. (PDF)
[Tolman, 2017]
Charles Tolman. The Path of the Programmer Overload, 25(140):4-5, August 2017. Charles Tolman provides a framework for personal development. (PDF)
[Tolman, 2017]
Charles Tolman. The Historical Context of Technology Overload, 25(141):8-9, October 2017. Charles Tolman provides a historical context for foundational thinking. (PDF)
[Tolman, 2017]
Charles Tolman. A Design Example Overload, 25(142):7-9, December 2017. Design issues cause problems. Charles Tolman considers an organising principle to get to the heart of the matter. (PDF)
[Tolman, 2018]
Charles Tolman. A Wider Vision of Software Development Overload, 26(143):4-5, February 2018. Is code a hopeful arrangement of bytes? Charles Tolman brings his Organising Principles series to a close. (PDF)
[Toms, 1993]
Mike Toms. Whingeing Session Overload, 1(1):, April 1993. (PDF)
[Toms, 1993]
Mike Toms. Dates & Times Overload, 1(1):, April 1993. (PDF)
[Toms, 1993]
Mike Toms. Class Struggle Overload, 1(1):, April 1993. A basic introduction to the uses of C++ (PDF)
[Toms, 1993]
Mike Toms. An Introduction to Object Orientation Overload, 1(1):, April 1993. (PDF)
[Toms, 1993]
Mike Toms. Templates Overload, 1(1):, April 1993. (PDF)
[Toms, 1993]
Mike Toms. C++ Streams Overload, 1(1):, April 1993. (PDF)
[Toms, 1993]
Mike Toms. Epilogue Overload, 1(1):, April 1993. (PDF)
[Toms, 1993]
Mike Toms. Editor's Ramble Overload, 1(1):, April 1993. (PDF)
[Toms, 1993]
Mike Toms. The Help Compiler Overload, 1(2):, June 1993. (PDF)
[Toms, 1993]
Mike Toms. Editor's Ramble Overload, 1(2):, June 1993. (PDF)
[Toms, 1993]
Mike Toms. Epilogue Overload, 1(2):, June 1993. (PDF)
[Toms, 1993]
Mike Toms. Class Struggle Overload, 1(2):, June 1993. (PDF)
[Toms, 1993]
Mike Toms. C++ Streams (Part 2) Overload, 1(2):, June 1993. (PDF)
[Toms, 1993]
Mike Toms. An E-mail Conversation with Bjarne Stroustrup Overload, 1(2):, June 1993. (PDF)
[Toms, 1993]
Mike Toms. Members' Letters Overload, 1(2):, June 1993. (PDF)
[Toms, 1993]
Mike Toms. The Pedant Overload, 1(2):, June 1993. (PDF)
[Toms, 1993]
Mike Toms. Class Struggle Overload, 1(3):, August 1993. (PDF)
[Toms, 1993]
Mike Toms. Editor's Ramble Overload, 1(3):, August 1993. (PDF)
[Toms, 1993]
Mike Toms. Custom Controls Overload, 1(3):, August 1993. (PDF)
[Toms, 1993]
Mike Toms. Epilogue Overload, 1(3):, August 1993. (PDF)
[Toms, 1993]
Mike Toms. C++ Strings -The ANSI Way Overload, 1(3):, August 1993. (PDF)
[Toms, 1993]
Mike Toms. Readers Letters Overload, 1(3):, August 1993. (PDF)
[Toms, 1994]
Mike Toms. Windows Waffle Overload, 2(4):, February 1994. (PDF)
[Toms, 1994]
Mike Toms. Readers Letters Overload, 2(4):, February 1994. (PDF)
[Toms, 1994]
Mike Toms. Epilogue Overload, 2(4):, February 1994. (PDF)
[Toms, 1994]
Mike Toms. char* p vs char *p Overload, 2(4):, February 1994. (PDF)
[Toms, 1994]
Mike Toms. Editor's Ramble Overload, 2(4):, February 1994. (PDF)
[Toms, 1994]
Mike Toms, Adrian Fagg. Letters Overload, 2(5):21, September 1994. (PDF)
[Tornhill, 2013]
Adam Tornhill. Code as a Crime Scene Overload, 21(117):4-8, October 2013. Forensic techniques can predict possible future crimes. Adam Tornhill shows how they can be applied to code. (PDF)
[Tornhill, 2014]
Adam Tornhill. Beauty in Code Overload, 22(121):8-9, June 2014. Attractiveness matters. Adam Tornhill uses a Clojure example to show how generalisation can be more beautiful than special cases. (PDF)
[Tornhill, 2015]
Adam Tornhill. Meet the Social Side of Your Codebase Overload, 23(127):4-7, June 2015. Programming requires collaboration. Adam Tornhill suggests some ways to uncover communication paths in your organisation. (PDF)
[Tornhill, 2016]
Adam Tornhill. Kill the Clones Overload, 24(134):8-10, August 2016. Problems in code can hide in surprising places. Adam Tornhill demonstrates how to detect software clones and uncover hidden dependencies. (PDF)
[Tripp, 2003]
Jonathan Tripp. Embedded Scripting Languages Overload, 11(55):, June 2003. (PDF)
[Uemlianin, 2004]
Ivan Uemlianin. Letters: Software Project Management Classics? Overload, 12(61):, June 2004. (PDF)
[Unknown, 1998]
Phil Bass, Unknown. editor << letters; Overload, 6(24):35-36, February 1998. (PDF)
[Vanhout, 2008]
Roel Vanhout. Iterators and Memberspaces Overload, 16(88):, December 2008. Exposing a compound object's collections can be messy. Roel Vanhout introduces a powerful idiom. (PDF)
[Vollmann, 1998]
Detlef Vollmann. Hotel Case Study Comments Overload, 6(27):, August 1998. (PDF)
[Vollmann, 1998]
Detlef Vollmann. Notes on Exceptions Overload, 6(28):, October 1998. (PDF)
[Vollmann, 1998]
Detlef Vollmann. Exception Usage Overload, 6(28):, October 1998. (PDF)
[Vollmann, 1999]
Detlef Vollmann. Exception Handling Alternatives Overload, 7(30):, February 1999. (PDF)
[Vollmann, 1999]
Detlef Vollmann. Exception Handling Alternatives (Part 2) Overload, 7(31):, April 1999. (PDF)
[Vollmann, 1999]
Detlef Vollmann. Software Architecture Overload, 7(34):, December 1999. (PDF)
[Vollmann, 2001]
Detlef Vollmann. Metaclasses and Reflection in C++ Overload, 9(45):, October 2001. (PDF)
[Vollmann, 2001]
Detlef Vollmann. Metaclasses and Reflection in C++ - Part 2 Overload, 9(46):, December 2001. (PDF)
[Vollmann, 2002]
Detlef Vollmann, Josh Walker. Letters to the Editor Overload, 10(52):, December 2002. (PDF)
[Wakeling, 2007]
Ian Wakeling. Working with GNU Export Maps Overload, 15(79):, June 2007. Taking control over the symbols exported from shared libraries built with the GNU toolchain. (PDF)
[Wakely, 2013]
Jonathan Wakely. Letter to the Editor Overload, 21(113):24, February 2013. (PDF)
[Wakely, 2014]
Jonathan Wakely. Stop the Constant Shouting Overload, 22(121):12-13, June 2014. CONSTANTS often shout. Jonathan Wakely considers why this happens in C and what the alternatives are in C++. (PDF)
[Wakely, 2015]
Jonathan Wakely. Get Debugging Better! Overload, 23(127):18-19, June 2015. The GNU debugger has several useful features you may not know. Jonathan Wakely shows us how to save time and pain with some simple tricks. (PDF)
[Wakely, 2016]
Jonathan Wakely. C++ Antipatterns Overload, 24(134):14-17, August 2016. Certain mistakes crop up frequently in C++. Jonathan Wakely offers some pro-tips to help you avoid common errors. (PDF)
[Walker, 2001]
Josh Walker. Template Metaprogramming Overload, 9(46):, December 2001. (PDF)
[Walker, 2002]
Josh Walker. Applied Reading - Taming Shared Memory Overload, 10(51):, October 2002. (PDF)
[Walker, 2002]
Detlef Vollmann, Josh Walker. Letters to the Editor Overload, 10(52):, December 2002. (PDF)
[Wang, 2013]
Nan Wang. The Open- Closed Principle (OCP) Overload, 21(113):14-15, February 2013. Changing requirements and environments can require cascading changes through software. Nan Wang demonstrates how the Open-Closed principle can minimise changes (PDF)
[Wang, 2012]
Wei Wang. Black-Scholes in Hardware Overload, 20(110):8-15, August 2012. The Black-Scholes model is a financial model. Wei Wang outlines its design and implementation for those who want to understand how algorithms can be implemented in hardware. (PDF)
[Watson, 1996]
Sean A. Corfield, Remi Sellem, Bryan Colyer, Phil Bass, Colin Harkness, Steve Watson. editor << letters; Overload, 4(14):18-19, June 1996. (PDF)
[Watts, 1998]
Will Watts. Exception Errors Overload, 6(29):, December 1998. (PDF)
[Weatherhead, 2015]
Nick Weatherhead. Template Programming Compile Time String Functions Overload, 23(128):14-17, August 2015. Practising old exercises in new ways can keep you sharp. Nick Weatherhead demonstrates some wellknown code katas using C++ compile time tricks. (PDF)
[Weatherhead, 2016]
Nick Weatherhead. Template Programming Compile Time Combinations & Sieves Overload, 24(131):13-17, February 2016. Functional style frequently uses sequences. Nick Weatherhead applies these ideas to combinations in C++. (PDF)
[Weatherhead, 2016]
Nick Weatherhead. C++ Synchronous Continuation Passing Style Overload, 24(135):16-19, October 2016. Direct and continuation passing styles differ. Nick Weatherhead explains a continuation passing style for synchronous data flow. (PDF)
[Weltman, 2001]
Rob Weltman. .NET Overload, 9(43):, June 2001. (PDF)
[Wendle, 1995]
George Wendle. Overloading on const is wrong Overload, 3(6):, March 1995. (PDF)
[Wendle, 1995]
George Wendle. Operators - an overloaded menace Overload, 3(7):12-14, April 1995. (PDF)
[Wendle, 1995]
George Wendle. Quantum Chromo Typology Overload, 3(9):5-7, August 1995. (PDF)
[Wendle, 1995]
Sean A. Corfield, Keith Derrick, George Wendle, Chris Simons, Dave Midgley, Dr. James Brennig. editor << letters; Overload, 3(10):25-28, October 1995. (PDF)
[Wendle, 1997]
George Wendle. Painting the Bicycle Shed Overload, 5(20):8-10, June 1997. The Draft International C++ Standard (PDF)
[Wendle, 1997]
George Wendle. extern "X" and namespaces Overload, 5(22):12-15, October 1997. (PDF)
[Wendle, 1997]
John Merrells, The Harpist, George Wendle, Francis Glasborow, Chris Southern. editor << letters; Overload, 5(22):, October 1997. (PDF)
[White, 2002]
Steve White. Introduction to WOC: Abstracting OpenGL 3-D Model Definition and Rendering with C++. Overload, 10(47):, February 2002. (PDF)
[Wigley, 2002]
Oliver Wigley. Alternatives for Partial Template Function Specialisation Overload, 10(50):, August 2002. (PDF)
[Wild III, 1993]
Frederic H. Wild III. Managing Class Coupling Overload, 1(3):, August 1993. (PDF)
[Williams, 2001]
Anthony Williams. A Generic Non-intrusive Smart Pointer Implementation Overload, 9(42):, April 2001. (PDF)
[Williams, 2001]
Anthony Williams. Flexible Functors and Binders Overload, 9(44):, August 2001. (PDF)
[Williams, 2001]
Anthony Williams. Introduction to C++ Templates Overload, 9(45):, October 2001. (PDF)
[Williams, 2002]
Anthony Williams. Pairing Off Iterators Overload, 10(51):, October 2002. (PDF)
[Williams, 2003]
Anthony Williams. EXPR_TYPE - An Implementation of typeof Using Current Standard C++ Overload, 11(54):, April 2003. (PDF)
[Williams, 2005]
Anthony Williams. Letter to the Editor Overload, 13(70):, December 2005. (PDF)
[Williams, 2006]
Anthony Williams. Implementing drop-down menus in pure CSS (no JavaScript) Overload, 14(73):, June 2006. Implementing drop-down menus to aid website navigation is usually thought to require lots of JavaScript. This article shows how to do it using just CSS. (PDF)
[Williams, 2007]
Anthony Williams. Implementing Synchronization Primitives for Boost on Windows Platforms Overload, 15(78):, April 2007. Anthony Williams on the popular Boost library. (PDF)
[Williams, 2008]
Anthony Williams. Exceptions Make for Elegant Code Overload, 16(86):, August 2008. Anything that can go wrong, will go wrong. Anthony Williams compares ways of dealing with errors. (PDF)
[Williams, 2009]
Anthony Williams. Multi-threading in C++0x Overload, 17(93):11--17, October 2009. Threading support is being added to C++. Anthony Williams introduces us to the new facilities. (PDF)
[Williams, 2011]
Anthony Williams. Picking Patterns for Parallel Programs (Part 1) Overload, 19(105):15-17, October 2011. Designing programs for multi-core systems can be extremely complex. Anthony Williams suggests some patterns to keep things under control. (PDF)
[Williams, 2015]
Anthony Williams. Numbers in JavaScript Overload, 23(128):19-20, August 2015. JavaScript floating point numbers can confuse C++ programmers. Anthony Williams draws our attention to some surprising behaviour. (PDF)
[Williams, 2016]
Anthony Williams. Using Enum Classes as Bitfields Overload, 24(132):22-23, April 2016. Scope enums have many advantages over standard enums. Anthony Williams shows how to use them as bitmasks. (PDF)
[Williams, 2017]
Anthony Williams. Getting Tuple Elements with a Runtime Index Overload, 25(139):18-19, June 2017. Accessing a tuple with a runtime index is a challenge. Anthony Williams shows us his approach. (PDF)
[Wilson, 2009]
Matthew Wilson. An Introduction to Fast Format (Part 1): The State of the Art Overload, 17(89):, February 2009. Writing a good library is hard. Matthew Wilson compares some existing formatting libraries, and promises to do better. (PDF)
[Wilson, 2009]
Matthew Wilson. An Introduction to FastFormat (Part 2): Custom Argument and Sink Types Overload, 17(90):, April 2009. A library should be customisable and have good performance. Matthew Wilson shows how to achieve both. (PDF)
[Wilson, 2009]
Matthew Wilson. An Introduction to FastFormat (Part 3): Solving Real Problems, Quickly Overload, 17(91):, June 2009. A good library must be useful in practice. Matthew Wilson looks at usability and extendability. (PDF)
[Wilson, 2009]
Matthew Wilson. Quality Matters: Introductions, and Nomenclature Overload, 17(92):, August 2009. There are many aspects of Software Quality. Matthew Wilson introduces us to some of the concepts. (PDF)
[Wilson, 2009]
Matthew Wilson. Quality Matters: Correctness, Robustness and Reliability Overload, 17(93):, October 2009. What do we mean by quality? Matthew Wilson considers some definitions. (PDF)
[Wilson, 2009]
Matthew Wilson. Quality Matters: A Case Study in Quality Overload, 17(94):26--32, December 2009. How do we assess quality? Matthew Wilson takes a look at the design of one library. (PDF)
[Wilson, 2010]
Matthew Wilson. Quality Matters: Diagnostic Measures Overload, 18(95):, February 2010. How do we catch problems early? Matthew Wilson investigates the recls library. (PDF)
[Wilson, 2010]
Matthew Wilson. Quality Matters: The Worst Form of ‘Error’ Overload, 18(98):28-32, August 2010. Handling Except For All The Others Dealing with errors is a vital part of good programming. Matthew Wilson specifies a taxonomy. (PDF)
[Wilson, 2010]
Matthew Wilson. Quality Matters #6: Exceptions for Practically-Unrecoverable Conditions Overload, 18(99):26-36, October 2010. Being robust is harder than you think. Matthew Wilson analyses a classic program. (PDF)
[Wilson, 2010]
Matthew Wilson. Quality Matters Christmas Intermezzo Overload, 18(100):32, December 2010. Sometimes it’s good to reflect. Matthew Wilson considers what he’s learnt so far. (PDF)
[Wilson, 2013]
Matthew Wilson. Quality Matters #7 Exceptions: the story so far Overload, 21(114):10-17, April 2013. Exception handling is difficult to get right. Matthew Wilson recaps the story so far. (PDF)
[Wilson, 2014]
Matthew Wilson. Quality Matters #8: Exceptions for Recoverable Conditions Overload, 22(120):9-17, April 2014. Too many programs deal with exceptions incorrectly. Matthew Wilson suggests practical steps to improve your code. (PDF)
[Wilson, 2015]
Matthew Wilson. QM Bites - The two sides of Boolean Parameters Overload, 23(130):16-17, December 2015. Boolean parameters are tempting but make life difficult. Matthew Wilson advises us to avoid them (almost) all the time. (PDF)
[Wilson, 2016]
Matthew Wilson. QM Bites : Maximising Discoverability of Virtual Methods Overload, 24(131):24-25, February 2016. C++11 introduced override as a contextual keyword. Matthew Wilson encourages us to use it. (PDF)
[Wilson, 2016]
Matthew Wilson. QM Bites: looping for-ever Overload, 24(132):21, April 2016. Never-ending loop constructs can confound user and compiler in subtle ways. Matthew Wilson offers advice to maximise portability and transparency. (PDF)
[Wilson, 2016]
Matthew Wilson. QM Bites: Understand Windows OS Identification Preprocessor Macros Overload, 24(132):11, April 2016. There’s confusion between user-defined and predefined Windows 32/64-bit operating-system identification macros. Matthew Wilson shines light on the issue. (PDF)
[Wilson, 2016]
Matthew Wilson. QM Bites - Order Your Includes (Twice Over) Overload, 24(133):7, June 2016. Header includes can be a shambles. Matthew Wilson encourages us to bring some order to the chaos. (PDF)
[Wilson, 2001]
Simon Wilson. String Tokenization - A Programmer's Odyssey Overload, 9(44):, August 2001. (PDF)
[Winder, 2016]
Russel Winder. So Why is Spock Such a Big Deal? Overload, 24(131):26-32, February 2016. Spock testing in a Java environment is all the rage. Russel Winder talks through the history of testing on the JVM and demonstrates why Spock is so groovy. (PDF)
[Winder, 2016]
Russel Winder. Testing Propositions Overload, 24(134):17-27, August 2016. Is testing propositions more important than having examples as exemplars? Russel Winder considers this hypothesis. (PDF)
[Winder, 2017]
Russel Winder. Mean Properties Overload, 25(137):4-7, February 2017. Property based testing is all the rage. Russel Winder walks us through an example of properties an arithmetic mean function should have. (PDF)
[Winder, 2017]
Russel Winder. Marking Benches Overload, 25(141):5-7, October 2017. Russel Winder reminds us that benchmarking code performance is a complicated issue. (PDF)
[Wippell, 1995]
Peter Wippell. editor << letters; Overload, 3(8):42, June 1995. (PDF)
[Wippell, 1995]
Peter Wippell. A “too-many-objects” lesson Overload, 3(8):39-40, June 1995. (PDF)
[Wippell, 1995]
Peter Wippell. Another “too-many-objects” lesson Overload, 3(9):33, August 1995. (PDF)
[Wippell, 1996]
Peter Wippell. I do not love thee, STL! Overload, 4(13):18-20, April 1996. C++ Techniques (PDF)
[Wippell, 1996]
Sean A. Corfield, Peter Wippell, Dave Midgley, Roger Woollett, The Harpist. editor << letters; Overload, 4(13):30-31, April 1996. (PDF)
[Woods, 2009]
Andy Longshaw, Eoin Woods. The Generation, Management and Handling of Errors (Part 1) Overload, 17(92):, August 2009. An error handling strategy is important for robustness. Andy Longshore and Eoin Woods present a pattern language. (PDF)
[Woods, 2009]
Andy Longshaw, Eoin Woods. The Generation, Management and Handling of Errors (Part 2) Overload, 17(93):, October 2009. Dealing with errors is a vital activity. Andy Longshaw and Eoin Woods conclude their pattern language. (PDF)
[Woollett, 1996]
Sean A. Corfield, Peter Wippell, Dave Midgley, Roger Woollett, The Harpist. editor << letters; Overload, 4(13):30-31, April 1996. (PDF)
[Yakyma, 2011]
Alex Yakyma. Refactoring and Software Complexity Variability Overload, 19(102):21-23, April 2011. Most code bases could have their complexity improved. Alex Yakyma presents a model that suggests how to do this. (PDF)
[Youngs, 1996]
Sean A. Corfield, Allan Newton, Graham Jones, Phil Bass, Steven Youngs. editor << letters; Overload, 4(15):35-36, August 1996. (PDF)
[van Laenen, 2011]
Filip van Laenen. Outsource Your Self-Discipline Overload, 19(105):12-14, October 2011. It’s all too easy to skip those tedious but vital steps towards code quality. Filip van Laenen suggests getting someone else to do them. (PDF)
[van Laenen, 2012]
Filip van Laenen. Mutation Testing Overload, 20(108):16-22, April 2012. We all know that testing improves our code, guarding against errors. Filip van Laenen asks how we know that the tests are comprehensive? (PDF)
[van Laenen, 2013]
Filip van Laenen. Wallpaper Rotation on Ubuntu using Ruby and Flickr Overload, 21(115):14-20, June 2013. Repetitive tasks are ideal candidates for scripting. Filip van Laenen walks us through a simple example. (PDF)