Advertisement
Advertisement
Membership
Login
ACCU Buttons
Add them to your site:
| Browse in : | > Journals > Overload > 37 |
• Programming
+
- Jumping around in Emacs
- The Global Lockdown of Locks
- C++20: A Simple Math Module
- Agile Manchester 2020: Testers Edition
- Static Analysis in GCC and Clang
- Comment Only What The Code Cannot Say
- Some Objects Are More Equal Than Others
- Reviews
- Pass the Parcel
- Using Compile Time Maps for Sorting
- Profiting from the Folly of Others
- Adding Python 3 Compatibility to Python 2 Code
- Making a Linux Desktop – Launching Applications
- Reviews
- A line-to-line conversion from Node.js to Node.cpp
- Quick Modular Calculations(Part 2)
- Restaurant C++ and Pidgin Python
- Python has setdefault
- Static C library and GNU Make
- Reviews
- Non-Recursive Compile Time Sort
- we they do better? Cassio Neri shows they can.">Quick Modular Calculations (Part 1)
- Exodep : A Simple External Dependency Refresher
- The Standard Report
- Scenarios Using Custom DSLs
- I Come Here Not to Bury Delphi, But to Praise It
- Attitude, Accomplishment, Artistry
- Empty Scoped Enums as Strong Aliases for Integral Types
- C++ Reflection for Python Binding
- A Case for Code Reuse
- Who Are You Calling Weak?
- Do Repeat Yourself
- Use UTF-16 Interfaces to Ship Windows Code
- Building C#/.NET, Go, and Ruby Programs with libCLImate – Part 1: Ruby
- Assembly Club
- Challenges
- NullableAttribute and C# 8
- lvalues, rvalues, glvalues, prvalues, xvalues, help!
- The Duality…
- Blockchain-Structured Programming
- QM Bites: Understand Windows Operating-System Identification Preprocessor Macros
- C++ Tagged Reference Types
- When Will Python 2 End?
- Code Critique Competition 115
- Report on Challenge 5
- Algol 68 – A Retrospective
- Improve Code by Removing It
- How to Write a Programming Language: Part 3, The Evaluator
- P1063 vs Coroutines TS: Consensus on High-Level Semantics
- Implementing the Spaceship Operator for Optional
- Compile-time Data Structures in C++17: Part 2, Map of Types
- The Ghost of a Codebase Past
- On Francis’s Challenge #4
- ACCU Standards Report
- Code Critique Competition
- Challenge 4 Report & Outlining Challenge 5
- Cache-Line Aware Data Structures
- miso: Micro Signal/Slot Implementation
- (Re)Actor Allocation at 15 CPU Cycles
- How to Write a Programming Language: Part 2, The Parser
- Compile-time Data Structures in C++17: Part 1, Set of Types
- Don’t Assume Any Non-Zero exit() Will Fail!
- Everyday Coding Habits for Safety and Simplicity
- Code Critique Competition 112
- Program Challenge Report 3 and Challenge 4
- Type-agnostic Tracing Using {fmt}
- A Short Overview of Object Oriented Software Design
- Libraries, Console Apps and GUIs
- The New C++ Interview
- Code Critique Competition 111
- No News is Good News
- 5 Reasons NOT to Use std::ostream for Human-Readable Output
- The Expressive C++ Coding Challenge in D
- Code Critique Competition 110 Part II
- CTAD – What Is This New Acronym All About?
- Functional Error-Handling with Optional and Expected
- Testing Times (Part 1)
- The Last Word in Patterns
- Implementing Type-Classes as OCaml Modules
- Afterwood
- Code Aesthetics
- A Brief Introduction to Docker
- ‘Speedy Gonzales’ Serializing (Re)Actors via Allocators
- Polymorphism in C++ – A Type Compatibility View
- C++11 (and beyond) Exception Support
- Thonny: Python IDE for Beginners
- A Glint of Ruby
- Why I Avoid PHP
- Code Critique Competition 107
- A C++ Developer Sees Rustlang for the First Time
- Portable Console I/O via iostreams
- Afterwood
- Living Within Constraints
- In Java I Wish I Could...
- Learning Other Languages
- Code Critique Competition 106
- Allocator for (Re)Actors with Optional Kinda-Safety and Relocation
- Initialization in C++ is Bonkers
- Vulkan and you – Khronos’ successor to OpenGL
- Kotlin for C++ Developers
- Getting Tuple Elements with a Runtime Index
- An Ode to Code
- Myths about ‘Big Data’
- On Turnabout is Fair Play
- A Hollywood Take on Dangling Pointers?
- Code Critique Competition 105
- Space invaders in Elm
- Single Module Builds – The Fastest Heresy in Town
- (Not Really So) New Niche for C++: Browser!?
- Contractual Loopholes
- On the Defensive
- Beyond Functional Programming: Manipulate Functions with the J Language
- Mean Properties
- The Importance of Back-of-Envelope Estimates
- Multiprocessing and Clusters in Python
- doctest – the Lightest C++ Unit Testing Framewor
- Correct Integer Operations with Minimal Runtime Penalties
- Afterwood
- A Case of Mistaken Identity
- Turnabout is Fair Play
- A Class What I Wrote
- Kate Gregory: An Interview
- Code Critique Competition 103
- The MirAL Story
- Overloading with Concepts
- Ultra-fast Serialization of C++ Objects
- Modern C++ Features: User-Defined Literals
- Python Streams vs Unix Pipes
- Hello World in Go
- Afterwood
- Commit Checklist
- On High Rollers
- A Commoner’s Response
- Determinism: Requirements vs Features
- Eight Rooty Pieces
- Polymorphic Comparisons
- C++ Synchronous Continuation Passing Style
- Attacking Licensing Problems with C++
- Home-Grown Tools
- Why Floats Are Never Equal
- Smarter, Not Harder
- An Introduction to OpenMP
- Random Confusion
- High Rollers
- Standards Report
- Some Big-Os are Bigger Than Others
- Kill the Clones
- Implementing SNAAAKE
- C++ Antipatterns
- Testing Propositions
- Testing Private
- The Codealow
- Debugging – What Has Changed in the Last Decade?
- Code Critique Competition 100
- Dogen: The Package Management Saga
- QM Bites – Order Your Includes (Twice Over)
- A Lifetime In Python
- Deterministic Components for Distributed Systems
- Programming Your Own Language in C++
- Concepts Lite in Practice
- Encryption
- Come Code With Me
- On Fifteen Love
- Standards Report
- Code Critique Competition 99
- The Tao of Scratch
- Knowledge-Sharing Architects As An Alternative to Coding Architects
- QM Bites: Understand Windows OS Identification Preprocessor Macros
- How to Diffuse Your Way Out of a Paper Bag
- Stufftar
- QM Bites: looping for-ever
- Using Enum Classes as Bitfields
- 9.7 Things Every Programmer Really, Really Should Know
- Sliding Window Filters : A Set-based Implementation
- An Open Question (or How I Learned To Stop Worrying And Love Public Wi-Fi)
- Groovy and Grails eXchange 2015
- Fifteen Love
- Using Clara to Parse Command Lines in C++
- Software Development Is...
- Defining Concepts
- On Zero-Side-Effect Interactive Programming, Actors, and FSMs
- Template Programming Compile Time Combinations & Sieves
- Classdesc: A Reflection System for C++11
- QM Bites : Maximising Discoverability of Virtual Methods
- So Why is Spock Such a Big Deal?
- Bug Hunting
- Finding Text
- in vivo, in vitro, in silico
- "HTTPS Everywhere" considered harmful
- Once Again on TCP vs UDP
- Type Mosaicing with Consultables and Delegates
- The Universality and Expressiveness of std::accumulate
- QM Bites – The two sides of Boolean Parameters
- Identify your Errors better with char[]
- CPU Clocks and Clock Interrupts, and Their Effects on Schedulers
- Bug Hunting
- Building C & C++ CLI Programs with the libCLImate Mini-framework
- Raspberry Pi Linux User Mode GPIO in C++ (Part 3)
- One Definition Rule
- Functional Programming in C++
- Code Critique Competition 96
- Introducing Concepts
- Building and Running Software on an Ubuntu Phone
- Password Hashing: Why and How
- An Inline-variant-visitor with C++ Concepts
- Refactoring Guided by Duplo
- Ode to the BBDB
- Anatomy of a CLI Program written in C++
- The Cat’s Meow
- Raspberry Pi Linux User Mode GPIO in C++ (Part 2)
- Standards Report
- Code Critique Competition 95
- Multi-threading at Business-logic Level is Considered Harmful
- Two Daemons
- Don’t Design for Performance Until It’s Too Late
- Template Programming Compile Time String Functions
- Numbers in JavaScript
- Are we nearly there yet? Refactoring C++
- Golang programming on AppEngine
- Split and Merge Revisited
- Meet the Social Side of Your Codebase
- Mocks are Bad, Layers are Bad
- Non-Superfluous People: Architects
- Terse Exception Messages
- Get Debugging Better!
- Make and Forward Consultables and Delegates
- Wallowing in Filth
- Writing Good C++ APIs
- Split and Merge – Another Algorithm for Parsing Mathematical Expressions
- Using 32-bit COM Objects from 64-bit Programs
- Raspberry Pi Linux User Mode GPIO in C++ – Part 1
- Standards Report
- Code Critique Competition 93
- Alternatives to Singletons and Global Variables
- Resource Management with Explicit Template Specializations
- Variadic and Variable Templates
- iterator_pair – A Simple and Useful Iterator Adapter
- Seeing the Wood for the Trees
- Using ACCU Membership for Unique IDs
- LAMP on Ubuntu
- The Developer’s Sandbox
- Simple Android programming with WebKit
- Raspberry Pi Linux User Mode GPIO in Python
- Code Critique Competition 92
- Standards Report
- Best Practices vs Witch Hunts
- Making a Tool of Deception
- Modern C++ Testing
- I Like Whitespace
- Faking C Function with fff.h
- Letter to the Editor
- Simplicity Through Immutability
- Advice for the Young at Heart
- Delayed Copy Pattern
- Const and Concurrency (part 2)
- Non-Superfluous People: Testers
- Designing Observers in C++11
- Order Notation in Practice
- Testing Drives the Need for Flexible Configuration
- Const and Concurrency (Part 1)
- Parsing Configuration Files in C++ with Boost
- Perl is a Better Sed, and Python 2 is Good
- Debuggers Are Still For Wimps
- Debug Complexity: How Assertions Affect Debugging Time
- Alternative Overloads
- Everyone Hates build.xml
- Defining Visitors Inline in Modern C++
- Paper Bag Escapology Using Particle Swarm Optimisation
- Does Test-Driven Development Harm Clarity?
- Musings on Python – by a C++ Developer
- Activatable Object
- KISSing SOLID Goodbye
- TDD Discussions and Disagreements
- Branching Strategies
- Beauty in Code
- The Code Is Not the Most Important Thing
- Stop the Constant Shouting
- Minimal Overhead for Multiple Interfaces
- Size Matters
- Enforcing the Rule of Zero
- Quality Matters #8: Exceptions for Recoverable Conditions
- Static – A Force for Good and Evil
- Search with CppCheck
- Windows 64-bit Calling Conventions
- Static Polymorphic Named Parameters in C++
- Integrating the Catch Test Framework into Visual Studio
- Anatomy of a Java Decompiler
- Optimizing Big Number Arithmetic Without SSE
- Capturing lvalue References in C++11 Lambdas
- How to Program Your Way Out of a Paper Bag Using Genetic Algorithms
- Object-Environment Collision Detection using Onion BSPs
- Migrating from Visual SourceSafe to Git
- Code as a Crime Scene
- YAGNI-C as a Practical Application of YAGNI
- Has the Singleton Not Suffered Enough
- Automatic Navigation Mesh Generation in Configuration Space
- C++ Range and Elevation
- Hard Upper Limit on Memory Latency
- Simple Instrumentation
- Portable String Literals in C++
- Dynamic C++ (Part 2)
- Auto – a necessary evil? (Part 2)
- Auto – A Necessary Evil?
- TCP/IP Explained. A Bit
- Demons May Fly Out Of Your Nose
- Wallpaper Rotation on Ubuntu using Ruby and Flickr
- Dynamic C++, Part 1
- A Model for Debug Complexity
- Valgrind Part 6 – Helgrind and DRD
- Quality Matters #7 Exceptions: the story so far
- Causality – Relating Distributed Diagnostic Contexts
- Executable Documentation Doesn’t Have To Slow You Down
- Why Dysfunctional Programming Matters
- ‘No Bugs’ Top Five C++ Cooking Recipes
- Utilising More Than 4GB of Memory in 32-bit Windows Process
- The Signs of Trouble: On Patterns, Humbleness and Lisp
- The Open–Closed Principle (OCP)
- Secrets of Testing WCF Services
- Web Annotation with Modified-Yarowsky and Other Algorithms
- Complex Logic in the Member Initialiser List
- -640K- 2^256 Bytes of Memory is More than Anyone Would Ever -Need- Get
- Footprint on Modify
- Valgrind Part 5 – Massif
- Valgrind Part 4: Cachegrind and Callgrind
- Universal References in C++11
- A DSEL for Addressing the Problems Posed by Parallel Architectures
- Keep It Simple, Singleton!
- Valgrind Part 3: Advanced memcheck
- Black-Scholes in Hardware
- Replace User, Strike Any Key?
- Simple Mock Objects for C++11
- Large Objects and Iterator Blocks
- Programming Darwinism
- What’s a Good Date?
- Tail Call Optimisation in C++
- All About XOR
- Curiously Recursive Template Problems with Aspect Oriented Programming
- Valgrind Part 2 – Basic memcheck
- The Virtual Interview
- Operators for Arithmetic Classes
- Are “Safe†Computer Systems Possible?
- So you want to be a cOOmpiler writer?
- Microsoft Visual C++ V1.5 (16bit)
- Borland C++ V4.
- Writing Your Own Stream Manipulators
- The Casting Vote
- Microsoft Visual C++ Strategy
- Letters
- Why Automatic Differentiation Won’t Cure Your Calculus Blues
- Back to School
- Valgrind Part 1 – Introduction
- Mutation Testing
- Unit Testing Compilation Failure
- Refactoring Towards Seams in C++
- Compiling a Static Web Site Using the C Preprocessor
- Memory Leaks and Memory Leaks
- Many Slices of π
- Why Computer Algebra Won’t Cure Your Calculus Blues
- The Eternal Battle Against Redundancies, Part 2
- A Practical Introduction to Erlang
- The Eternal Battle Against Redundancies, Part I
- RAII is not Garbage
- Why Polynomial Approximation Won't Cure Your Calculus Blues
- Concurrent Programming with Go
- Why Finite Differences Won’t Cure Your Calculus Blues
- Outsource Your Self-Discipline
- Picking Patterns for Parallel Programs (Part 1)
- Intellectual Property – a Crash Course for Developers
- Over-Generic Use of Abstractons as a Major Cause of Wasting Resources
- Thread-Safe Access Guards
- An Introduction to Test Driven Development
- Why [Insert Algorithm Here] Won’t Cure Your Calculus Blues
- Some Objects Are More Equal Than Others
- Exception Specifications in C++ 2011
- Why Interval Arithmetic Won’t Cure Your Floating Point Blues
- The ACCU 2011 Crypto Challenge
- Benefits of Well Known Interfaces in Closed Source Code
- Why Computer Algebra Won’t Cure Your Floating Point Blues
- Refactoring and Software Complexity Variability
- Queue with Position Reservation
- Why Rationals Won’t Cure Your Floating Point Blues
- Overused Code Reuse
- From Occam's Razor to No Bugs' Axe
- Why Fixed Point Won't Cure Your Floating Point Blues
- Interface Versioning in C++
- Quality Matters Christmas Intermezzo
- You're Going To Have To Think!
- To DLL or Not To DLL
- Making String ReTRIEval Fast
- Quality Matters #6: Exceptions for Practically-Unrecoverable Conditions
- The Model Student: The ACCU 2010 Crypto Challenge
- Debugging Run Time Memory Problems
- The ANSI Standard For C
- Defining New Data Types In C++
- Notes from the Ultra-Conservative Right Wing
- Debugging with the Macro Processor
- Commenting programs, how and why
- Everything You Wanted To Know About C ......
- Structure, Part 2
- Everything You Wanted To Know About C ......
- An introduction to ADVSYS
- Structure, Part 1
- Adventures In C
- Scalable Graph Coverage
- Single-Threading: Back to the Future?
- The Functional Student: A Game of Six Integers
- The Predicate Student: A Game of Six Integers
- One Approach to Using Hardware Registers in C++
- The Model Student: A Game of Six Integers (Part 1)
- Simplifying the C++/Angelscript Binding Process
- Quality Matters: Diagnostic Measures
- Quality Matters: Diagnostic Measures (Listings)
- Shadow Data Types
- Creating a Framework for the iPhone
- The Model Student: A Primal Skyline (Part 3)
- The Model Student: A Primal Skyline (Part 2)
- Multi-threading in C++0x
- I Think I'll Parse
- Quality Matters: Introductions, and Nomenclature
- Code Rot
- Floating Point Fun and Frolics
- Complexity, Requirement and Modules
- An Introduction to FastFormat (Part 3): Solving Real Problems, Quickly
- Boiler Plating Database Resource Cleanup (Part 2)
- Testing State Machines
- The Model Student: A Rube-ish Square (Part 2)
- An Introduction to FastFormat (Part 2): Custom Argument and Sink Types
- Through The Looking Glass
- Orderly Termination of Programs
- An Introduction to Fast Format (Part 1): The State of the Art
- Model View Controller with Java Swing
- The Legion's Revolting!
- Iterators and Memberspaces
- Generics without Templates - Revisited
- Seeing Things Differently
- DynamicAny (Part 2)
- DynamicAny, Part I
- Globals, Singletons and Parameters
- Exceptions Make for Elegant Code
- The Model Student: A Knotty Problem, Part 2
- Watersheds and Waterfalls (Part 2)
- The Model Student: A Knotty Problem, Part 1
- Watersheds and Waterfalls
- Testing Visiting Files and Directories in C#
- Generics Without Templates
- C++0x An Overview
- Functional Programming Using C++ Templates (Part 2)
- Java Protocol Handlers
- Software Product Lines
- Code Generation Network
- The PfA Papers: The Clean Dozen
- Functional Programming Using C++ Templates (Part 1)
- auto_value: Transfer Semantics for Value Types
- He Sells Shell Scripts to Intersect Sets
- Release Mode Debugging
- auto_value: Transfer Semantics for Value Types
- The Policy Bridge Design Pattern
- Continuous Integration with CruiseControl.Net
- Working with GNU Export Maps
- auto_value: Transfer Semantics for Value Types
- A Perspective on Use of Conditional Statements versus Assertions
- Implementing Synchronization Primitives for Boost on Windows Platforms
- Design in Test-Driven Development
- C++ Unit Test Frameworks
- Programming - Abstraction by Design
- C++ Trivial Logger
- FRUCTOSE - a C++ Unit Test Framework
- Letter to the Editor
- Pooled Lists
- The Singleton in C++ - A force for good?
- C++ Interface Classes - Strengthening Encapsulation
- Inventing a Mutex
- C++ Unit Testing Easier: CUTE
- From CVS to Subversion
- Comments Considered Good
- Introducing CODEF/CML
- Fine Tuning for lexical_cast
- C# Generics - Beyond Containers of T
- The Kohonen Neural Network Library
- Comments Considered Evil
- How Do Those Funky Placeholders Work?
- Implementing drop-down menus in pure CSS (no JavaScript)
- The Rise and Fall of Singleton Threaded
- The Case Against TODO
- Objects for States
- Multithreading 101
- To Grin Again
- A Fistful Of Idioms
- C++ Best Practice – Designing Header Files
- Visiting Alice
- Boost C++ Libraries
- STLFilt
- Effective STL Example Source Code
- C++ Archive
- Scott Meyers
- Lisp
- Accelerated C++
- Don Knuth's Home Page
- WTL Quick Reference
- WTL
- Subversion
- Compilers and Compiler Generators
- Perl
- PHP Resource Center
- KDB (Built-in Kernel Debugger)
- Blitz
- Microsoft Press Books
- Microsoft Visual C++
- Microsoft Developers Network
- Andrei Alexandrescu
- Cross-Referencing Linux
- Linux Assembly
- Building and Testing gcc/glibc cross toolchains
- Apache Tomcat
- Apache Struts
- Apache Maven
- Apache Lucene
- Logging Services Project @ Apache
- Apache Gump
- Excalibur
- Apache Ant
- JSP Taglibs
- Jakarta Slide
- Jakarta Regexp
- Jakarta POI
- Jakarta-ORO
- Java Caching System
- Element Construction Set
- Cactus
- Bean Scripting Framework
- BCEL
- Turbine
- Velocity
- Jakarta Commons
- Tapestry
- Hive Mind
- The Apache Jakarta Project
- LinuxMM
- Haskell
- GCC online documentation
- GCC Home Page
- Trolltech Online Reference Documentation
- KDE 3.0 API Reference
- Java Technology Articles by Category
- Java Tech Tips
- Java Technology
- The GNOME development site.
- Borland Developer Network
- The development of the C language
- The C Programming Language
- The Practise of Programming
- Objective Caml
- The Caml Language
- BitKeeper configuration management system.
- Borland C++Builder Devlopers Journal
- The Decompilation Wiki
- Soft Documentation
- Dead Code
- Friend or Foe!
- Recursive Make Considered Harmful
- Let's Do C# and MySQL - Part 2 - A Beginning
- Two-thirds of a Pimpl and a Grin
- The Curate's Wobbly Desk
- "Here be Dragons"
- Better Encapsulation for the Curiously Recurring Template Pattern
- db4objects - Innovating Object Databases with Open Source
- Pointer Reversal: An Algorithm Design Technique
- Let's Do C# and MySQL - Part 1 - MySQL
- J2SE 5.0 New Features
- With Spirit
- Polynomial Classes
- Incremental Design: A Case Study of a Compiler
- A Framework for Generating Numerical Test Data
- Transactions with Delegates in C#
- Sharp as C
- Qt 4.0 is Out!
- Investigating Java Class Loading
- C-side Re-sort
- C++ Interface Classes - Noise Reduction
- A Technique for Register Access in C++
- Welcome to the Wonderful World of Porting!
- Silas's Corner
- New Container Classes in Qt 4
- Introduction to Tcl/Tk: Part 2
- The Trial of the Reckless Coder
- Taming Complexity: A Class Hierarchy Tale
- Microsoft Symbol Engine
- Separating Interface and Implementation in C++
- Overload Resolution - Selecting the Function
- Metaprogramming is Your Friend
- Digging a Ditch
- I Wish Programming Was Easy Again
- Using Qt's Non-GUI Classes
- Introduction to Tcl/Tk
- Forgetting the ABC
- An Introduction to Objective-C
- Multiple Streams Going Nowhere
- C++ Properties - a Library Solution
- C Abuse
- Wx - A Live Port - Part 3
- Patterns in C - Part 1
- Memory For a Short Sequence of Assignment Statements
- Elephant - A C++ Memory Observer
- An Introduction to Programming with GTK+ and Glade in ISO C and ISO C++ - Part 4
- An Introduction to Objective-C
- Mini-project to Decode A Mini-language - Part Two
- An Experience Report on Implementing a Custom Agile Methodology on a C++/Python Project
- Wx - A Live Port
- ">Writing Custom Widgets in Qt
- What's in a Namespace?
- An Introduction to Programming with GTK+ and Glade in ISO C and ISO C++ - Part 3
- An Introduction to Objective-C
- Wx - A Live Port
- ">Rapid Dialog Design Using Qt
- Introduction to STL (Standard Template Library)
- An Introduction to Programming with GTK+ and Glade - Part 2
- An Introduction to Objective-C
- The Encapsulate Context Pattern
- Microsoft Visual C++ and Win32 Structured Exception Handling
- Garbage Collection and Object Lifetime
- C++ Lookup Mysteries
- A Mini-project to Decode a Mini-language - Part One
- XML as a Model-View-Controller System for Documents
- Introduction to C# - Part 2
- Creating Standard GUI Applications
- C++ Templates - A Simple Example
- An Introduction to Programming with GTK+ and Glade in ISO C and ISO C++
- An Introduction to Objective-C
- The Curious Case of the Compile-Time Function
- ACCU Mentored Developers XML Project
- Letters to the Editor
- Handling Exceptions in finally
- C++ Interface Classes - An Introduction
- A Template Programmer's Struggles Revisited
- Introduction To C#
- Going GUI with Qt
- Functional Programming in Python: An Introduction by Example
- When is a "Pattern" not a "Pattern"?
- The Tale of a Struggling Template Programmer
- Lvalues and Rvalues
- Efficient Exceptions?
- A Template Programmer’s Struggles Resolved
- Transforming XML with XSLT
- From Mechanism to Method: Generic Decoupling
- All Heap No Leaks
- Achieving FitNesse in C++
- A Little Detail
- Writing Maintainable Code
- I_mean_something_to_somebody, Part Two
- Francis' Scribbles
- http://www.ecma-international.org/publications/standards/Ecma-335.htm. ">C++/CLI, Ecma TC39/TG5,and SC22/WG21
- A Python Script to Relocate Source Trees
- There is more to life than increasing its speed” - Mahatma Gandhi
We live in a fast food culture. Not only must our dinner arrive yesterday, our car should be fast, and our entertainment instant. Our code should also run like lightning. I want my result. And I want it now.
Ironically, writing fast programs takes a long time.
Optimisation is a spectre hanging over software development, as W.A. Wulf observed. “More computing sins are committed in the name of efficiency (without necessarily achieving it) than for any other single reason – including blind stupidity”.
It’s a well-worn subject, with plenty of trite soundbites bounding around, and the same advice being served time and time again. But despite this, a lot of code is still not developed sensibly. Programmers get sidetracked by the lure of efficiency and write bad code in the name of performance.
In these articles we’ll address this. We’ll tread some familiar ground and wander well-worn paths, but look out for some new views on the way. Don’t worry – if the subject’s optimisation it shouldn’t take too long...
">Professionalism in Programming #24 - do...while loop? It just does something while some condition holds. End of story, right?
No, of course not. That would make the title of this small article silly, so let’s cover two topics.
">do...while - Letters to the Editor(s)
- From Mechanism to Method:
- C++ as a Safer C
- Example 0
for (Surfaces::iterator sf = surfaces.begin(); sf != surfaces.end(); ++sf) { // std::cout << "Drawing: " << *sf << "\n"; sf->draw(); }OK, I’m being disingenuous. I’m aware that the comment isn’t really a comment, it’s commented-out code. And, like any tolerant and capable programmer, by examining the surrounding context I can guess why this code has been commented out.
This article examines how to comment out code, then describes various problems which lead to code being commented out, before finally arguing that there’s often a better solution to these problems.
">Code in Comments - Comment on “Problem 11”
- Student Code Critique Competition 26
- Maintaining Context for Exceptions (Alternative)
- BRACKETS OFF!
- From Mechanism to Method:
- Choosing Template Parameters
- CheckedInt: A Policy-Based Range-Checked Integer
- A More Flexible Container
- Copy on Write
- Combining the STL with SAX and XPath for Effective XML Parsing
- Statically Checking Exception Specifications
- Software As Read
- Single Exit
- Error and Exception Handling
- Chaos Theory
- A Policy-Driven CORBA Template Library to Facilitate the Rapid Development of DOC Middleware
- Mixing Strings in C++
- Maintaining Context for Exceptions
- A Polygon Seed Fill Algorithm
- Quick Guide to MinGW (GCC for Windows)
- Stream-Based Parsing in C++
- Learning C++: A Student's Perspective
- Intrusive Identifiers
- Generating Lists for C++ in Python
- A Python project (2)
- How To Write A Loop
- From Mechanism to Method
- Embedded Scripting Languages
- A bin Manipulator For IOStreams
- Non-Standard Code
- A Python Project
- 10 Things You Always Wanted to Know About Assert (But Were Afraid to Ask)
- Implementing the Bridge pattern using templates with Microsoft Visual C++ 6.0
- EXPR_TYPE - An Implementation of typeof Using Current Standard C++
- Addendum to "Tiny Template Tidbit"
- A C++ Petri Net Framework For Multithreaded Programming
- Implementing the Observer Pattern in C++ - Part 2
- From Mechanism to Method ÂTotal Ellipse
- Build Systems
- Indexing STL lists with maps
- A Return Type That Doesn’t Like Being Ignored
- C++rossword
- C++ Standards Library Report
- C++ Templates
- Implementing the Observer Pattern in C++ - Part 1
- From Mechanism to Method - Good Qualifications
- File Format Conversion Using Templates and Type Collections
- XML Parsing with the Document Object Model
- What is a Hash Table?
- Enlarging on "A Problem of Access" in C Vu December 2001 Volume 13 Number 6
- 4DML Revisited
- Pairing Off Iterators
- Mutate? or Create?
- Exception Handling in C#
- Some Personal Reflections on C++ and Java
- My First Steps in Java Web Development
- Examining C++
- A Little String Thing
- Template Metaprogramming: Shifting Down a Gear
- STL-style Circular Buffers By Example
- Even More Java Exceptions
- Alternatives for Partial Template Function Specialisation
- Applied Reading - Taming Shared Memory
- Developing a C++ Unit Testing Framework
- Programming with Interfaces in C++
- More Exceptional Java
- An Overview of C#.NET
- Introduction to XML and C++
- The C++ Template Argument Deduction
- Template Titbit - A Different Perspective
- From Mechanism to Method - Function Follows Form
- Exceptional Java
- C++ Exceptions and Linux Dynamic Libraries
- ">If Problems Arise
- Applying OO to C
- What is Boost?
- Tiny Template Tidbit
- Introduction to WOC:
- String Comparison with Wild Characters.
- Template Metaprogramming
- Techniques for Debugging in C++
- Metaclasses and Reflection in C++ - Part 2
- Summing Arrays
- An Introduction to Personal Java
- minimalism
- Metaclasses and Reflection in C++
- Introduction to C++ Templates
- Introducing JUnit
- A Little Class
- Using Version Control
- String Tokenization - A Programmer's Odyssey
- Porting (part 2) - Addressing the Differences
- Flexible Functors and Binders
- Designing C++ Interfaces - Templates
- Are You Afraid of The Dark Too? Making More Sense of the STL
- What Is Swing?
- Where to begin: Porting
- Introduction to the Database Template Library
- Designing C++ Interfaces - Exception Safety
- Are You Afraid of The Dark? - Making Sense of the STL
- An introduction to C++ Traits
- What Is Swing?
- Some Thoughts on Java
- Getting Started with J2EE
- Typesafe Registry for Windows
- Multimethods
- Editor << letters;
- Editor << letters;
- Compile Time Indirection - An Unusual Template Technique
- C++ Idioms: First Thoughts
- A Generic Non-intrusive Smart Pointer Implementation
- A Deeper Look at Inline Functions
- Members' Experiences
- Gotcha(); // describe some bugs
- Ada Overview - Part 2
- Editorial
- Where is __FUNCTION__?
- Thread Pooling: An Investigation
- Extensibility - A Reason For Using Streams in C++
- Questions and Answers
- Swamp Fever
- Ada Overview - Part 1
- Here be Dragons
- From Mechanism to Method
- Questions and Answers
- OOD and Testing using the Dependency Inversion Principle
- User Defined Types: Qualities, Principles and Archetypes.
- Include Files
- From Mechanism to Method: Substitutability
- C++ Patterns Source Cohesion and Decoupling
- Undefined vs. Implementation Defined
- Building the Board (part II)
- Supporting Threads in Standard C++ (Addendum)
- Intuitive Multi-Paradigm Design:
- A Fistful Of Idioms - Giving STL Iterators a Base Class
- ">What's An Implerface?
- Servlets
- Reading Integers Revisited
- Reading C & C++ Variable Declarations
- Java Parameter Semantics
- ISO 8601: A Standard You Should Know About
- Building the Board
- editor << letters;
- Supporting Threads in Standard C++ (Part 3)
- A framework for object serialization in C++
- Questions and Answers
- Mostly Comments
- Java Q & A
- Building the Hexes
- An Introduction to Fuzzy Logic
- Adding Enumerators
- A Tale of Old Java
- Supporting Threads in Standard C++ (Part 2)
- An Implementation of Double Dispatch in Java
- An Application of Pointers to Members
- Questions and Answers
- Reading Integers
- Pure, functional, lazy ISBNs
- Buffer Overflows and the Standard C Library
- Adding Polymorphic Classes to the Anthem 'threads' Model
- Standard C++
- Exceptions - Guidance
- Error handling and logging
- Automatic Object Versioning for Forward and Backward File Format Compatibility
- Questions & Answers
- Learning Standard C++ as a New Language
- operator == ()
- counted_ptr<type> revisited
- Static vs Member Functions
- Exception Errors
- Debug new and delete Part 3
- Data Attribute Notation - Part 2
- A Delphic Experience
- Notes on Exceptions
- Exception Usage
- Editor << letters;
- Controlling access to objects by using private interfaces
- Broadvision - Part 3
- Object (low-level) Design and Implementation
- Hotel Case Study Comments
- editor << letters;
- Uncounted pointers in C++
- SAX - A Simple API for XML
- Exceptions - The Details
- File Positioning
- Anonymous Code Exercise Rewrite
- The Journey is a reduction of the postings to accu-general compiled every month. ACCU general provides an opportunity for members to discuss, share, educate and be educated.">The Journey
- Seductive Tips
- Questions & Answers
- Members Experiences
- If your going to use it, learn it!
- We very rarely publish material that is not original. However I thought that readers might enjoy this item from one of the great programmers of any time. Please note that this was first presented 25 years ago. I think it is worth reflecting on what we have and have not learnt since. ">1974 ACM Turing Award Lecture
- Hotel Case Study Comments
- Exploring Patterns Part 2
- More threading with templates
- More cow_ptr<type> Ruminations
- Exceptions - The Basics
- Coping with Copying in C++
- Syntax v Semantics Part 1
- ISBN Numbers
- Compile Time Assertions in C Revisited
- COMMENTS- A Personal Perspective
- An Exercise - Source unknown
- The EPOC C++ API
- Ruminations on Studying Design Patterns
- Micro-Derivation & Related Ideas
- A Review of cow_ptr<type>
- What's In a Struct?
- Pointers in Hyperspace
- Compile Time Assertions in C Revisited
- Code Review - A Big Number Class
- A Software Probe
- Using Templates To Handle Multi-Threading
- copy_on_write_ptr<type>
- Thoughts on Functoids
- Fitting in with multiple frameworks in C++ and Java
- Software Development with Java User Interfaces II
- Questions & Answers
- More Thoughts About Hungarian Notation
- Java Style & Idioms : exceptions are fun
- Compile Time Assertions in C
- Being Silly?
- All You Need to Know About enums
- Write to Learn
- Overloading Operators
- Exception Handling Alternatives
- Data Attribute Notation - Part 3
- An Eventful Story
- A Letter from Ken Hagan annotated by The Harpist
- Naming Conventions for Spoken Readability
- Multithreading (2)
- ">Java Style & Idioms
- Software Development with Java User Interfaces
- Multithreading
- Java Idioms
- Hungarian Notation- Another View
- Close Encounters with Internationalisation
- Life Stories
- A Little Bit of Humour for a Monday Morning
- The uses and abuses of inheritence
- The Casting Vote I
- The Casting Vote II
- Circles and Ellipses revisited: coding techniques - 2
- Standard containers for polymorphic types
- auto_ptr || !auto_ptr
- Using objects for background tasks (3)
- Understanding Windows (9)
- String Theory
- MSDOS Interrupts
- Understanding Windows (8)
- String Theory
- Software Engineers Toolbox
- Sets a-la Pascal
- Increase your Program's Execution Speed?
- The Casting Vote
- Putting Jack in the Box
- Overloading on const is wrong
- Friends - who needs them?
- C++ compilers for MSDOS / MSWindows
- Blindspots
- An alternative to wchar_t
- A Text Formatting Class
- The Casting Vote
- Do birds in their little nests always agree?
- new & delete
- Shared Memory Class
- Run-time checking for C++
- Why C++ will replace FORTRAN (or, at least, why it should)
- char* p vs char *p
- Minimising Stack Use and Other Uses of new
- C++ Strings -The ANSI Way
- Custom Controls
- Windows File Class
- Unit Testing Of C++ Classes
- Uses of Classes with only Private and Protected Constructors
- A Short Exposure to C++
- C++ Streams (Part 2)
- Class Struggle
- The Help Compiler
- Some Thoughts on the Use of New
- C++ Streams
- Make...or Break?
- Templates
- An Introduction to Object Orientation
- Class Struggle
- Dates & Times
- Starting out with OWL
- Whingeing Session
- The Ethical Programmer
- Coding Accountability
- Afterwood
- An Interview Icebreaker
- Are we nearly there yet?
- Ruminations on Self Employment and Running a Business
- On the Other Side of the Barricade: Job Interviewer Do’s and Don’ts
- Software Developer Business Patterns
- Moving with the Times
- The Guy We’re All Working For
- What motivates software developers: a workshop report
- "I'm a Business Analyst - Get Me Out Of Here"
- Renovating a Legacy C++ Project
- Socially Responsible Recruitment
- On Management: The Business Analyst's Role
- Software Development in the 21st Century
- On Management: Product Managers
- WRESTLE: Aggressive and Unprincipled Agile Development in the Small
- On Management: Caveat Emptor
- On Management: Understanding Who Creates Software
- On Management: Focus, Quality, Time-boxes and Ducks
- Performitis (Part 3)
- On Management
- Quality Manifesto
- Creating Awareness
- Managing Technical Debt
- Effective Software Testing
- Atlantic Systems Guild
- Open Source Development with CVS, 3rd Edition
- The Risks Digest
- The Agile Manifesto Explained (and a First Amendment)
- Setting up a Subversion Server for Remote Use
- Editorial: Size Does Matter
- Becoming and Being Agile
- Software Project Management: Adding Stakeholder Metrics to Agile Projects
- Professionalism in Programming #32
- Are Certificates Worth the Paper they are Written On?
- "The C++ Community" - Are We Divided by a Common Language?
- Grain Storage MIS: A Failure of Communications (27 March 1998)
- Editorial: Need to Unlearn
- Sheep Farming for Software Development Managers
- Automatically Generating Word Documents
- A Subversion Primer
- The Developer's New Work
- Confirmit. Confirmit is a web-based application which enables organizations to gather, analyze and report key business information across a broad range of commercial applications.">From Waterfall to EVO in a Medium Size Norwegian Software House
- A Pair Programming Experience
- Memory for a Short Sequence of Assignment Statements
- Blue Fountain Systems - An Open Source Company
- Where Egos Dare
- Editorial
- Letters to the Editor(s)
- Why do requirements change?
- An Alternative View of design (and planning)
- A Standard Individual: A Licensed Engineer
- Editorial
- Is IT worth it?
- On Not Being a Software Engineer
- Three Phantastic Tales
- EuroPLoP 2003 Conference Report
- Ruminations on Knowledge in Software Development
- Software development and the learning organisation
- Labouring: An Analogy
- Extendable Software and the Bigger Picture
- Editorial - Software Quality
- Building Java Applications
- Thinking about "reuse"
- Editorial
- How to Raise the Dead
- Editorial: Product Definition
- How about a Turner Prize for software?
- Using CVS (A Beginner's Guide)
- A Personal View: Computing Anywhere
- In Defense of Sys Admins
- From the Coalface
- Editorial
- .NET
- Editorial
- Members' Experiences
- To Certify or not to Certify?
- Thinking Aloud
- Some Thoughts on Academic Papers
- editorial: Concerning Patents
- Pros and Cons of Contracting
- Editorial
- Visual Control and COM
- In Response to Extreme Programming
- What Use is a Degree?
- Iteractive Development - Prologue
- eXtreme Programming An interview with Kent Beck
- File Headers
- So Your Code is NOT Critical?
- Recent Interview Experiences (and Other Gripes)
- From the Coalface
- Exception Discussion
- A Message from the ACCU Chair
- From the Academic Coalface
- Religious Issues
- From the Academic Coalface
- C minus
- Making a Linux Desktop
- Piping Software for Less
- An Example Confined User Shell
- The Standard Report
- Refocusing Amdahl’s Law
- Expect the Unexpected (Part 1)
- What Is Your Name?
- Quick Modular Calculations (Part 3)
- Deconstructing Inheritance
- It’s About Time
- The Standard Report
- The Path of Least Resistance
- A Secure Environment for Running Apps?
- Afterwood
- Making a Linux Desktop: Painting Some Wallpaper
- OOP Is not Essential
- C++ Pipes
- Making a Linux Desktop
- A Low-Latency Logging Framework
- On IT and... CO2 Footprints
- Modern SAT solvers: fast, neat and underused (part 1 of N)
- The Simple Life
- 5 Big Fat Reasons Why Mutexes Suck Big Time
- A Small Universe
- A Small Universe Part II
- A Thorough Introduction to Distributed Systems
- Don’t Use std::endl
- China’s New AI School Textbooks
- Diseconomies of Scale
- Flip Model: A Design Pattern
- Memory Management Patterns in Business-Level Programs
- Compile-time Data Structures in C++17: Part 3, Map of Values
- Measuring Throughput and the Impact of Cache-line Awareness
- Afterwood
- Write Less Code!
- The Half-Domain/Half-Primitive Proxy
- How to Write a Programming Language: Part 1, The Lexer
- Writing a Wayland Server Using Mir
- Monitoring: Turning Noise into Signal
- The Interface to Component Pattern and DynaMix
- Practical Cryptographical Theory for Programmers
- A Wider Vision of Software Development
- An MWSR Queue with Minimalist Locking
- Testing: Choose the Right Level
- C++ with Meta-classes?
- Practical Scale Testing
- Visualisation of Multidimensional Data
- Programmers’ Puzzles
- CAS (Re)Actor for Non-Blocking Multithreaded Primitives
- A Design Example
- Evolutionary Computing Frameworks for Optimisation
- Marking Benches
- A New Competition
- A Usable C++ Dialect that is Safe Against Memory Corruption
- Metaclasses: Thoughts on Generative C++
- A Functional Alternative to Dependency Injection in C++
- Rip It Up and Start Again
- Non-Superfluous People: UX Specialists
- Does Test-Driven Development Harm Clarity?
- KISSing SOLID Goodbye
- TDD Discussions and Disagreements
- Object-Environment Collision Detection using Onion BSPs
- YAGNI-C as a Practical Application of YAGNI
- Has the Singleton Not Suffered Enough
- C++ Range and Elevation
- Executable Documentation Doesn’t Have To Slow You Down
- Systems Thinking Software Development
- Rise of the Machines
- Quality Matters Christmas Intermezzo
- You're Going To Have To Think!
- To DLL or Not To DLL
- Renovating a Legacy C++ Project
- Single-Threading: Back to the Future? (Part 2)
- Quality Matters: The Worst Form of 'Error' Handling Except For All The Others
- Scalable Graph Coverage
- Single-Threading: Back to the Future?
- The Model Student: A Game of Six Integers (Part 3)
- The Functional Student: A Game of Six Integers
- The Model Student: A Game of Six Integers (Part 2)
- Using Design Patterns to Manage Complexity
- The Predicate Student: A Game of Six Integers
- The Model Student: A Game of Six Integers (Part 1)
- Quality Matters: Diagnostic Measures
- Quality Matters: Diagnostic Measures (Listings)
- Creating a Framework for the iPhone
- Project-Specific Language Dialects
- The Generation, Management and Handling of Errors (Part 2)
- I Think I'll Parse
- Quality Matters: Introductions, and Nomenclature
- The Model Student: A Primal Skyline (Part 1)
- The Generation, Management and Handling of Errors (Part 1)
- Complexity, Requirement and Modules
- An Introduction to FastFormat (Part 3): Solving Real Problems, Quickly
- Testing State Machines
- If You Can't See Me, I Can't See You
- The Model Student: A Rube-ish Square (Part 2)
- An Introduction to FastFormat (Part 2): Custom Argument and Sink Types
- Through The Looking Glass
- The Model Student: A Rube-ish Square (Part 1)
- An Introduction to Fast Format (Part 1): The State of the Art
- The Model Student: Can Chance Make Fine Things? (Part 2)
- Model View Controller with Java Swing
- The Legion's Revolting!
- Iterators and Memberspaces
- Generics without Templates - Revisited
- Seeing Things Differently
- DynamicAny (Part 2)
- The Model Student: Can Chance Make Fine Things? (Part 1)
- DynamicAny, Part I
- Performitis - Part 2
- Globals, Singletons and Parameters
- Exceptions Make for Elegant Code
- Divide and Conquer: Partition Trees and Their Uses
- Performitis
- The Model Student: A Knotty Problem, Part 2
- RSA Made Simple
- Watersheds and Waterfalls (Part 2)
- The Model Student: A Knotty Problem, Part 1
- Watersheds and Waterfalls
- The PfA Papers: Deglobalisation
- The Regular Travelling Salesman, Part 2
- The PfA Papers: Context Matters
- The Model Student
- Upgrading Legacy Software in Data Communications Systems
- The PfA Papers: The Clean Dozen
- Functional Programming Using C++ Templates (Part 1)
- auto_value: Transfer Semantics for Value Types
- The PfA Papers: From the Top
- auto_value: Transfer Semantics for Value Types
- The Policy Bridge Design Pattern
- Software Product Line Engineering with Feature Models
- A Perspective on Use of Conditional Statements versus Assertions
- Design in Test-Driven Development
- C++ Unit Test Frameworks
- A Practical Form of OO Layering
- Programming - Abstraction by Design
- Exceptional Design
- The Singleton in C++ - A force for good?
- C++ Interface Classes - Strengthening Encapsulation
- The Rise and Fall of Singleton Threaded
- James O. Coplien
- Test Driven Development of C# User Interfaces
- ">Debuggers Should Go Backwards
- Cryptographic Mistakes Made in Programming
- A Reflection on Defensive Programming
- Patterns in C - Part 5: REACTOR
- Vorsprung Durch Testing
- Patterns in C - Part 4: OBSERVER
- Patterns in C - Part 3: Strategy
- Can C++ Learn from Generics in Ada?
- Metaprogramming is Your Friend
- Patterns in C - Part 2: State
- Stable Intermediate Forms
- Yet Another Hierarchical State Machine
- Evolution of the Observer Pattern
- From Mechanism to Method: The Safe Stacking of Cats
- More is Less
- Heretical Java #1
- I_mean_something_to_somebody
- An Alternative View of design (and planning)
- SINGLETON - the anti-pattern!
- Reshaping an Old Piece of Design
- A Unified Singleton Framework
- Members' experiences
- The Nature and Aesthetics of Design
- Observer Pattern Implementation
- Exported Templates
- Organising Source Code
- STL-style Circular Buffers By Example, Part Two
- Patterns Collaborations: Observer and Composite
- An Introduction to 4DML
- The Philosophy of Extensible Software
- Execute Around Method and Proxy Goulash
- Writing Extendable Software
- The scoping problem
- A Short History of Character Sets
- Porting part 3 :
- What is Boost?
- Of Minimalism, Constructivism and Program Code
- minimalism
- Minimalist Constructive Criticism
- Modelling and Software Development
- Metaclasses and Reflection in C++
- Designing C++ Interfaces - Templates
- C++ Standards - The "swap" Problem
- Experiences of Implementing the Observer Design Pattern (Part 3)
- Source Code Modules and Layering
- A Touch Of Abstraction
- Programming with Interfaces in C++
- More Include File Rules
- Interpreting "Supporting the 'Cheshire Cat' Idiom"
- Experiences of Implementing the Observer Design Pattern (Part 2)
- The Pet Project (part 4)
- Experiences of Implementing the Observer Design Pattern (Part 1)
- XML in Applications II DOM - the Document Object Model
- The Pet Project - Monopoly (Part 3)
- An Implementation of Double Dispatch in Java
- My Pet Project Monopoly 2
- Shallow Pointer
- Exploring Patterns 3 - The Adapter
- Exceptions & Exception Specifications
- XML
- When's an object not an object?
- The Diary of Bridget Jones the Weekend Before OT
- Software Architecture
- My Pet Project - Monopoly
- Error logging and patterns
- UML Interactions & Collaborations
- Self Registering Classes - Taking polymorphism to the limit
- Broadvision - Part 2
- The State Pattern - A New Implementation
- The Journey - from accu.general May 1999
- Polymorphism In Object-Oriented Languages
- Builder & Factory Method Patterns
- BroadVision, Part 4
- A Simple Model for Object Persistence Using the Standard Library
- Response To "Patterns - The Abstract Factory" (Francis Glassborow, Overload 30)
- Objects In Databases
- Factories in C++: Disposing of the Product
- Exception Handling Alternatives (Part 2)
- Impression of C++ for Embedded Systems
- UML Relationships and Associations, Aggregation and Composition
- Patterns - The Abstract Factory
- Garbage Collection Implementation Considerations
- Exception Handling Alternatives
- Abstraction, Syntax, Intent
- Waterfall versus RAD
- Almost a Pattern
- Caught in the pattern web
- Windows Waffle
- Run-time checking for C++
- C++ Strings -The ANSI Way
- Managing Class Coupling
- Class Struggle
- An Introduction to Object Orientation
- Rumbaugh's OMT - The method behind C++ Designer
- Some Thoughts on Writing Classes
- Afterwood
- When Will Python 2 End: An Update
- Diving into the ACCU Website
- ‘HTTPS Everywhere’ Less Harmful Now
- Why I Don’t Develop for iOS
- How to Stay Out of a Webmaster’s Bad Books
- GitHub’s Crazy Contribution-Graph Game
- One SSH Key Per Machine!
- Planet Code
- Open Source – And Still Deceiving Programmers
- How to Block Russia From Your Website (and why you might want to)
- Inspirational (P)articles: Use the DOM Inspector
- Web Annotation with Modified-Yarowsky and Other Algorithms
- Implementing drop-down menus in pure CSS (no JavaScript)
- Apache Week
- The Apache Software Foundation
- Java Lobby
- Apache Portals
- Apache James Mail and News Server
- JMeter
- How to Quantify Quality: Finding Scales of Measure
- When Worlds Collide 2 - Circuit Switch Telephony and Packet Switch Networks
- Tracking Exceptions in Web Services with GUIDs
- Patterns in the Web
- I Wish They'd Use the Standard
- Editorial
- Editorial
- Conference: ACM CHI 2001
- Editorial
- An Introduction to CGI Programming
- Beyond ACCU... Patterns on the 'net
- Beyond ACCU... Java on the 'net
- Beyond ACCU... Patterns on the 'net
- Beyond ACCU
- Web Sites to Review
- Web Sites to Review
- Sources on the Internet
- Home, Home on the Web...
- Security Implications of Running a Web Gateway
- Onward to American Online...
- Common Gateway Interface Program Testing
- The Standards Report
- A Thorough Introduction to Apache Kafka
- Expect the Unexpected (Part 2)
- Greenback Backup
- The Trouble with GitHub Forks
- Afterwood
- Thoughts on ‘Computational Thinking’
- The Standard Report
- A Day in the Life of a Full-Stack Developer
- Afterwood
- The Refactor Part of TDD – Reducing to the Min with FizzBuzz
- A Case Against the Use of Code ‘Smells’
- Afterwood
- Avoid Stagnation
- Afterwood
- Effective Software Testing
- DIY Technical Authoring
- Afterwood
- Don’t Brush Bugs Under The Carpet
- To Mob, Pair, or Fly Solo
- A Guide to Group Decision Making
- Afterwood
- Testing Times (Part 2)
- Getting Personal
- Afterwood
- Afterwood
- Navigating a Route
- The Path of the Programmer
- About the C++ Core Guidelines
- Afterwood
- I Can't Think Fast Enough in a Coding Interview
- Be Available, Not Busy
- The Importance of Back-of-Envelope Estimates
- Speak Up! (Part 2)
- A Case of Mistaken Identity
- How Do You Read?
- Speak Up!
- Delivering Bad News from QA
- Smarter, Not Harder
- Whiteboards
- Organised Chaos
- Why Collaboration is Key for QA Teams in an Agile World
- The Very Model of a Model Modern Programmer
- The Cat’s Meow
- Writing a Technical Book
- What Do People Do All Day?
- Standards Report
- Playing By The Rules
- Taming the Inbox
- Standards Report
- A Scheduling Technique for Small Software Projects and Teams
- Feeding Back
- Branching Strategies
- Lies, Damn Lies and Estimates
- The Uncertainty Principle
- Software Developer Business Patterns
- The Virtual Interview
- Moving with the Times
- From the Age of Power to the Age of Magic and beyond...
- Integrating Testers Into An Agile Team
- Systems Thinking Software Development
- The Agile Spectrum
- On CMM, Formalism and Creativity
- Despair Programming
- The Agile 10 Steps Model
- Bug Hunting and the Scientific Method
- From Occam's Razor to No Bugs' Axe
- Bug Elimination - Defensive Agile Ruses
- Quality Matters: A Case Study in Quality
- Quality Matters: Correctness, Robustness and Reliability
- Software Development in the 21st Century
- Measurable Value with Agile
- On Management: Focus, Quality, Time-boxes and Ducks
- Performitis (Part 3)
- Future Workers (Prototype)
- Creating Awareness
- Software Product Lines
- Blue-White-Red, an Example Agile Process
- Live and Learn with Retrospectives
- Continuous Integration with CruiseControl.Net
- Up Against the Barrier
- The Documentation Myth
- Pair Programming Explained
- How to Shoot Yourself in the Foot. In an Agile Way.
- Overload 158 ePub
- Overload 158 PDF
- RE:Purpose FWD:Thinking
- The Global Lockdown of Locks
- C++20: A Simple Math Module
- A Thorough Introduction to Apache Kafka
- An Example Confined User Shell
- Agile Manchester 2020: Testers Edition
- Afterwood
- Overload 157 ePub
- Overload 157 PDF
- Rainclouds and Olive Branches
- Comment Only What The Code Cannot Say
- Refocusing Amdahl’s Law
- Some Objects Are More Equal Than Others
- Afterwood
- Overload 156 ePub
- Overload 156 PDF
- R.E.S.P.E.C.T.
- Pass the Parcel
- Quick Modular Calculations (Part 3)
- Deconstructing Inheritance
- Using Compile Time Maps for Sorting
- Profiting from the Folly of Others
- It’s About Time
- A Day in the Life of a Full-Stack Developer
- Overload 155 ePub
- Overload 155 PDF
- Members and Remembrances
- A line-to-line conversion from Node.js to Node.cpp
- The Path of Least Resistance
- Quick Modular Calculations(Part 2)
- A Secure Environment for Running Apps?
- Afterwood
- Overload 154 ePub
- Overload 154 PDF
- Inside-Out
- Trip Reports: Meeting C++ 2019 and Embedded C++ 2019
- Non-Recursive Compile Time Sort
- we they do better? Cassio Neri shows they can.">Quick Modular Calculations (Part 1)
- Afterwood
- Overload 153 ePub
- Overload 153 PDF
- Predictions and Predilections
- Scenarios Using Custom DSLs
- OOP Is not Essential
- I Come Here Not to Bury Delphi, But to Praise It
- C++ Pipes
- Afterwood
- Overload 152 ePub
- Overload 152 PDF
- Reactive or Proactive
- A Low-Latency Logging Framework
- Empty Scoped Enums as Strong Aliases for Integral Types
- C++ Reflection for Python Binding
- Trip Report: Italian C++ 2019
- Afterwood
- Overload 151 ePub
- Overload 151 PDF
- How Hard Can It Be?
- Do Repeat Yourself
- On IT and... CO2 Footprints
- Use UTF-16 Interfaces to Ship Windows Code
- ACCU Conference 2019: Reports
- Afterwood
- Overload 150 ePub
- Overload 150 PDF
- This means war!
- NullableAttribute and C# 8
- lvalues, rvalues, glvalues, prvalues, xvalues, help!
- Modern SAT solvers: fast, neat and underused (part 1 of N)
- The Duality…
- Blockchain-Structured Programming
- Overload 149 ePub
- Overload 149 PDF
- Rip It Up and Start Again
- 5 Big Fat Reasons Why Mutexes Suck Big Time
- A Small Universe
- A Small Universe Part II
- QM Bites: Understand Windows Operating-System Identification Preprocessor Macros
- A Thorough Introduction to Distributed Systems
- Don’t Use std::endl
- Afterwood
- Overload 148 ePub
- Overload 148 PDF
- Revolution, Restoration and Revival
- Diseconomies of Scale
- Flip Model: A Design Pattern
- Memory Management Patterns in Business-Level Programs
- Compile-time Data Structures in C++17: Part 3, Map of Values
- Algol 68 – A Retrospective
- Measuring Throughput and the Impact of Cache-line Awareness
- Afterwood
- Overload 147 ePub
- Overload 147 PDF
- Are we nearly there yet?
- How to Write a Programming Language: Part 3, The Evaluator
- P1063 vs Coroutines TS: Consensus on High-Level Semantics
- Implementing the Spaceship Operator for Optional
- Compile-time Data Structures in C++17: Part 2, Map of Types
- Overload 146 ePub
- Overload 146 PDF
- Should I Lead by Example?
- Cache-Line Aware Data Structures
- miso: Micro Signal/Slot Implementation
- (Re)Actor Allocation at 15 CPU Cycles
- How to Write a Programming Language: Part 2, The Parser
- Compile-time Data Structures in C++17: Part 1, Set of Types
- Afterwood
- Overload 145 ePub
- Overload 145 PDF
- Automate all the things
- How to Write a Programming Language: Part 1, The Lexer
- Type-agnostic Tracing Using {fmt}
- A Short Overview of Object Oriented Software Design
- Afterwood
- Overload 144 ePub
- Overload 144 PDF
- Deeds not words
- No News is Good News
- Monitoring: Turning Noise into Signal
- The Interface to Component Pattern and DynaMix
- 5 Reasons NOT to Use std::ostream for Human-Readable Output
- Practical Cryptographical Theory for Programmers
- Ex Hackina
- Overload 143 ePub
- Overload 143 PDF
- Hapaxes, Singletons and Anomalies
- A Wider Vision of Software Development
- An MWSR Queue with Minimalist Locking
- Testing: Choose the Right Level
- CTAD – What Is This New Acronym All About?
- C++ with Meta-classes?
- Practical Scale Testing
- Functional Error-Handling with Optional and Expected
- Afterwood
- Overload 142 ePub
- Overload 142 PDF
- Too Fast! Too slow! Too right!!
- CAS (Re)Actor for Non-Blocking Multithreaded Primitives
- A Design Example
- The Last Word in Patterns
- Implementing Type-Classes as OCaml Modules
- Evolutionary Computing Frameworks for Optimisation
- Afterwood
- Overload 141 ePub
- Overload 141 PDF
- This way up!
- Letters to the Editor
- Marking Benches
- The Historical Context of Technology
- ‘Speedy Gonzales’ Serializing (Re)Actors via Allocators
- Polymorphism in C++ – A Type Compatibility View
- Open Source – And Still Deceiving Programmers
- C++11 (and beyond) Exception Support
- Afterwood
- Overload 140 ePub
- Overload 140 PDF
- Gnomes and Misnomers
- The Path of the Programmer
- A Usable C++ Dialect that is Safe Against Memory Corruption
- Metaclasses: Thoughts on Generative C++
- A C++ Developer Sees Rustlang for the First Time
- Portable Console I/O via iostreams
- A Functional Alternative to Dependency Injection in C++
- About the C++ Core Guidelines
- Afterwood
- Overload 139 ePub
- Overload 139 PDF
- I am not a number
- Allocator for (Re)Actors with Optional Kinda-Safety and Relocation
- Initialization in C++ is Bonkers
- Vulkan and you – Khronos’ successor to OpenGL
- Kotlin for C++ Developers
- Getting Tuple Elements with a Runtime Index
- Afterwood
- Overload 138 ePub
- Overload 138 PDF
- Breadth First, Depth First, Test First
- Space invaders in Elm
- Single Module Builds – The Fastest Heresy in Town
- An Interview: Emyr Williams
- (Not Really So) New Niche for C++: Browser!?
- Contractual Loopholes
- All About the Base
- Overload 137 ePub
- Overload 137 PDF
- Editorial: The Uncertainty Guidelines
- Mean Properties
- The Importance of Back-of-Envelope Estimates
- Multiprocessing and Clusters in Python
- doctest – the Lightest C++ Unit Testing Framewor
- Correct Integer Operations with Minimal Runtime Penalties
- Afterwood
- Overload 136 ePub
- Overload 136 PDF
- Editorial: The Font of Wisdom
- The MirAL Story
- Overloading with Concepts
- Ultra-fast Serialization of C++ Objects
- Modern C++ Features: User-Defined Literals
- Python Streams vs Unix Pipes
- Letter
- Hello World in Go
- Afterwood
- Overload 135 ePub
- Overload 135 PDF
- Editorial: Ain’t that the truth?!
- Determinism: Requirements vs Features
- Eight Rooty Pieces
- Polymorphic Comparisons
- C++ Synchronous Continuation Passing Style
- Attacking Licensing Problems with C++
- Afterwood
- Overload 134 ePub
- Overload 134 PDF
- Editorial: Just a minute
- Some Big-Os are Bigger Than Others
- Kill the Clones
- Implementing SNAAAKE
- C++ Antipatterns
- Testing Propositions
- Afterwood
- Overload 133 ePub
- Overload 133 PDF
- Editorial: Metrics and Imperialism
- Dogen: The Package Management Saga
- QM Bites – Order Your Includes (Twice Over)
- A Lifetime In Python
- Deterministic Components for Distributed Systems
- Programming Your Own Language in C++
- Concepts Lite in Practice
- Afterwood
- Overload 132 ePub
- Overload 132 PDF
- Editorial: Where Does All The Time Go?
- The Tao of Scratch
- Knowledge-Sharing Architects As An Alternative to Coding Architects
- QM Bites: Understand Windows OS Identification Preprocessor Macros
- Why Collaboration is Key for QA Teams in an Agile World
- How to Diffuse Your Way Out of a Paper Bag
- Stufftar
- QM Bites: looping for-ever
- Using Enum Classes as Bitfields
- 9.7 Things Every Programmer Really, Really Should Know
- Overload 131 ePub
- Overload 131 PDF
- Editorial: Be lucky
- Defining Concepts
- On Zero-Side-Effect Interactive Programming, Actors, and FSMs
- Template Programming Compile Time Combinations & Sieves
- Classdesc: A Reflection System for C++11
- QM Bites : Maximising Discoverability of Virtual Methods
- So Why is Spock Such a Big Deal?
- Overload 130 PDF
- Editorial: Reduce, reuse, recycle
- Once Again on TCP vs UDP
- Type Mosaicing with Consultables and Delegates
- The Universality and Expressiveness of std::accumulate
- QM Bites – The two sides of Boolean Parameters
- Identify your Errors better with char[]
- CPU Clocks and Clock Interrupts, and Their Effects on Schedulers
- Overload 129 PDF
- Failure is an option
- Introducing Concepts
- Building and Running Software on an Ubuntu Phone
- Password Hashing: Why and How
- An Inline-variant-visitor with C++ Concepts
- Overload 128 PDF
- Semi-automatic Weapons
- Multi-threading at Business-logic Level is Considered Harmful
- Two Daemons
- Don’t Design for Performance Until It’s Too Late
- Template Programming Compile Time String Functions
- Numbers in JavaScript
- Overload 127 PDF
- Editorial: A little more conversation, a little less action
- Meet the Social Side of Your Codebase
- Mocks are Bad, Layers are Bad
- Non-Superfluous People: Architects
- Terse Exception Messages
- Get Debugging Better!
- Make and Forward Consultables and Delegates
- Overload 126 PDF
- Editorial: Where was I?
- Non-Superfluous People: UX Specialists
- Alternatives to Singletons and Global Variables
- Resource Management with Explicit Template Specializations
- Variadic and Variable Templates
- iterator_pair – A Simple and Useful Iterator Adapter
- Seeing the Wood for the Trees
- Overload 125 PDF
- Editorial: FUD – Fear, uncertainty and doubt
- Best Practices vs Witch Hunts
- Making a Tool of Deception
- Modern C++ Testing
- I Like Whitespace
- Faking C Function with fff.h
- How to Write an Article
- Letter to the Editor
- Overload 124 PDF
- Ruminations on Self Employment and Running a Business
- Non-Superfluous People: Testers
- Designing Observers in C++11
- Editorial: Finding your muse
- Order Notation in Practice
- People of the .Doc
- Testing Drives the Need for Flexible Configuration
- Overload 123 PDF
- Editorial: Peer Reviewed
- Debug Complexity: How Assertions Affect Debugging Time
- Alternative Overloads
- Everyone Hates build.xml
- Defining Visitors Inline in Modern C++
- A Scheduling Technique for Small Software Projects and Teams
- Paper Bag Escapology Using Particle Swarm Optimisation
- Feeding Back
- Overload 122 PDF
- Editorial: Shop ’til you Drop
- Does Test-Driven Development Harm Clarity?
- Musings on Python – by a C++ Developer
- Activatable Object
- KISSing SOLID Goodbye
- TDD Discussions and Disagreements
- Overload 121 PDF
- Editorial: Very small or very far away:A sense of perspective
- Branching Strategies
- Beauty in Code
- The Code Is Not the Most Important Thing
- Stop the Constant Shouting
- Minimal Overhead for Multiple Interfaces
- Overload 120 PDF
- Your Life in Their Hands
- Size Matters
- Enforcing the Rule of Zero
- Quality Matters #8: Exceptions for Recoverable Conditions
- Static – A Force for Good and Evil
- Search with CppCheck
- Windows 64-bit Calling Conventions
- Teenage Hex
- Overload 119 PDF
- Editorial: Random (non)sense
- Static Polymorphic Named Parameters in C++
- Integrating the Catch Test Framework into Visual Studio
- Anatomy of a Java Decompiler
- Optimizing Big Number Arithmetic Without SSE
- Capturing lvalue References in C++11 Lambdas
- Overload 118 PDF
- Editorial: Not So Much a Program, More a Way of Life
- On the Other Side of the Barricade: Job Interviewer Do’s and Don’ts
- How to Program Your Way Out of a Paper Bag Using Genetic Algorithms
- Object-Environment Collision Detection using Onion BSPs
- Migrating from Visual SourceSafe to Git
- Overload 117 PDF
- Editorial: Decisions, Decisions
- Code as a Crime Scene
- Lies, Damn Lies and Estimates
- YAGNI-C as a Practical Application of YAGNI
- Has the Singleton Not Suffered Enough
- Automatic Navigation Mesh Generation in Configuration Space
- C++ Range and Elevation
- Overload 116 PDF
- Editorial: Learning Fantasy Languages
- Hard Upper Limit on Memory Latency
- Simple Instrumentation
- Portable String Literals in C++
- Dynamic C++ (Part 2)
- Auto – a necessary evil? (Part 2)
- Overload 115 PDF
- Editorial: Fantasy Languages
- Auto – A Necessary Evil?
- TCP/IP Explained. A Bit
- Demons May Fly Out Of Your Nose
- Wallpaper Rotation on Ubuntu using Ruby and Flickr
- Dynamic C++, Part 1
- The Uncertainty Principle
- Overload 114 PDF
- Editorial: Knitting Needles and Keyboards
- A Model for Debug Complexity
- Valgrind Part 6 – Helgrind and DRD
- Quality Matters #7 Exceptions: the story so far
- Causality – Relating Distributed Diagnostic Contexts
- Executable Documentation Doesn’t Have To Slow You Down
- Why Dysfunctional Programming Matters
- Overload 113 PDF
- Editorial: The Good, The Bad and The Discordant
- ‘No Bugs’ Top Five C++ Cooking Recipes
- Utilising More Than 4GB of Memory in 32-bit Windows Process
- The Signs of Trouble: On Patterns, Humbleness and Lisp
- The Open–Closed Principle (OCP)
- Secrets of Testing WCF Services
- Letter to the Editor
- Overload 112 PDF
- Editorial: Originally, Overload Didn’t Have an Editorial
- Web Annotation with Modified-Yarowsky and Other Algorithms
- Complex Logic in the Member Initialiser List
- -640K- 2^256 Bytes of Memory is More than Anyone Would Ever -Need- Get
- Footprint on Modify
- Valgrind Part 5 – Massif
- Overload 111 PDF
- Editorial: Too Much Information
- Valgrind Part 4: Cachegrind and Callgrind
- Universal References in C++11
- A DSEL for Addressing the Problems Posed by Parallel Architectures
- Keep It Simple, Singleton!
- Software Developer Business Patterns
- Overload 110 PDF
- Editorial: Allow Me To Introduce Myself
- Valgrind Part 3: Advanced memcheck
- Black-Scholes in Hardware
- Replace User, Strike Any Key?
- Simple Mock Objects for C++11
- Large Objects and Iterator Blocks
- Overload 109 PDF
- Editorial: It’s Not What You Know, It’s Who You Know
- Programming Darwinism
- What’s a Good Date?
- Tail Call Optimisation in C++
- All About XOR
- Curiously Recursive Template Problems with Aspect Oriented Programming
- Valgrind Part 2 – Basic memcheck
- Overload 108 PDF
- Editorial: The Computing Revolution Will Be Televised (Again)
- Why Automatic Differentiation Won’t Cure Your Calculus Blues
- Back to School
- Valgrind Part 1 – Introduction
- Mutation Testing
- Unit Testing Compilation Failure
- Refactoring Towards Seams in C++
- Compiling a Static Web Site Using the C Preprocessor
- A Position on Running Interference in Languages
- Overload 107 PDF
- Memory Leaks and Memory Leaks
- Editorial: Many Hands Make Light Work
- Many Slices of π
- Why Computer Algebra Won’t Cure Your Calculus Blues
- The Eternal Battle Against Redundancies, Part 2
- A Practical Introduction to Erlang
- Editorial: Patently Ridiculous!
- Overload 106 PDF
- Moving with the Times
- The Eternal Battle Against Redundancies, Part I
- From the Age of Power to the Age of Magic and beyond...
- RAII is not Garbage
- Why Polynomial Approximation Won't Cure Your Calculus Blues
- Concurrent Programming with Go
- Overload 105 PDF
- Editorial: A Journey Through History
- Why Finite Differences Won’t Cure Your Calculus Blues
- Outsource Your Self-Discipline
- Picking Patterns for Parallel Programs (Part 1)
- Intellectual Property – a Crash Course for Developers
- Overload 104 PDF
- Editoral: Rise of the Machines
- Over-Generic Use of Abstractons as a Major Cause of Wasting Resources
- Integrating Testers Into An Agile Team
- Thread-Safe Access Guards
- An Introduction to Test Driven Development
- Why [Insert Algorithm Here] Won’t Cure Your Calculus Blues
- Overload 103 PDF
- Editorial: Can you keep a secret?
- Some Objects Are More Equal Than Others
- The Guy We’re All Working For
- Exception Specifications in C++ 2011
- Why Interval Arithmetic Won’t Cure Your Floating Point Blues
- Systems Thinking Software Development
- The ACCU 2011 Crypto Challenge
- Overload 102 PDF
- Editorial: This Year’s Model
- Benefits of Well Known Interfaces in Closed Source Code
- Why Computer Algebra Won’t Cure Your Floating Point Blues
- The Agile Spectrum
- On CMM, Formalism and Creativity
- Refactoring and Software Complexity Variability
- Despair Programming
- Overload 101 PDF
- Editorial: Ah! The fog is lifting!
- Queue with Position Reservation
- Why Rationals Won’t Cure Your Floating Point Blues
- Overused Code Reuse
- The Agile 10 Steps Model
- Rise of the Machines
- Numbers and The Appliance of Science
- Bug Hunting and the Scientific Method
- From Occam's Razor to No Bugs' Axe
- The Quartermaster's Store
- Why Fixed Point Won't Cure Your Floating Point Blues
- Interface Versioning in C++
- Quality Matters Christmas Intermezzo
- Overload 100 PDF
- Overload 99 PDF
- Lies, Damn Lies, and Statistics
- You're Going To Have To Think!
- What motivates software developers: a workshop report
- To DLL or Not To DLL
- Making String ReTRIEval Fast
- Quality Matters #6: Exceptions for Practically-Unrecoverable Conditions
- A Little Learning Is A Dangerous Thing
- "I'm a Business Analyst - Get Me Out Of Here"
- The Model Student: The ACCU 2010 Crypto Challenge
- Renovating a Legacy C++ Project
- Single-Threading: Back to the Future? (Part 2)
- Debugging Run Time Memory Problems
- Quality Matters: The Worst Form of 'Error' Handling Except For All The Others
- Overload 98 PDF
- The Art of the Possible
- Scalable Graph Coverage
- Socially Responsible Recruitment
- Single-Threading: Back to the Future?
- The Model Student: A Game of Six Integers (Part 3)
- The Functional Student: A Game of Six Integers
- Overload 97 PDF
- Dealing with Growing Pains
- The Model Student: A Game of Six Integers (Part 2)
- Using Design Patterns to Manage Complexity
- Bug Elimination - Defensive Agile Ruses
- A Practical, Reasoned and Inciteful Lemma for Overworked and Overlooked Loners
- Overload 96 PDF
- Overload 95 PDF
- Back To The Future
- One Approach to Using Hardware Registers in C++
- The Model Student: A Game of Six Integers (Part 1)
- Simplifying the C++/Angelscript Binding Process
- Quality Matters: Diagnostic Measures
- Quality Matters: Diagnostic Measures (Listings)
- A Crack in Time
- Shadow Data Types
- Creating a Framework for the iPhone
- The Model Student: A Primal Skyline (Part 3)
- Project-Specific Language Dialects
- Quality Matters: A Case Study in Quality
- Overload 94 PDF
- All together now.
- The Model Student: A Primal Skyline (Part 2)
- Multi-threading in C++0x
- Quality Matters: Correctness, Robustness and Reliability
- The Generation, Management and Handling of Errors (Part 2)
- Overload 93 PDF
- Moments in History
- I Think I'll Parse
- Quality Matters: Introductions, and Nomenclature
- Code Rot
- The Model Student: A Primal Skyline (Part 1)
- The Generation, Management and Handling of Errors (Part 1)
- No 'Concepts' in C++0x
- Overload 92 PDF
- A Good Craftsman Knows His Tools
- Floating Point Fun and Frolics
- On Management: The Business Analyst's Role
- Complexity, Requirement and Modules
- An Introduction to FastFormat (Part 3): Solving Real Problems, Quickly
- The Model Student: The Enigma Challenge
- Boiler Plating Database Resource Cleanup (Part 2)
- ACCU 2009
- Overload 91 PDF
- Back to School
- Software Development in the 21st Century
- Testing State Machines
- If You Can't See Me, I Can't See You
- The Model Student: A Rube-ish Square (Part 2)
- On Management: Product Managers
- An Introduction to FastFormat (Part 2): Custom Argument and Sink Types
- WRESTLE: Aggressive and Unprincipled Agile Development in the Small
- Overload 90 PDF
- Watt's going on?
- Measurable Value with Agile
- Through The Looking Glass
- Orderly Termination of Programs
- On Management: Caveat Emptor
- The Model Student: A Rube-ish Square (Part 1)
- An Introduction to Fast Format (Part 1): The State of the Art
- Overload 89 PDF
- The Sweet Smell of Success
- The Model Student: Can Chance Make Fine Things? (Part 2)
- Model View Controller with Java Swing
- On Management: Understanding Who Creates Software
- The Legion's Revolting!
- Iterators and Memberspaces
- Generics without Templates - Revisited
- Overload 88 PDF
- The Invisible Hand
- Seeing Things Differently
- DynamicAny (Part 2)
- On Management: Focus, Quality, Time-boxes and Ducks
- The Model Student: Can Chance Make Fine Things? (Part 1)
- Performitis (Part 3)
- Overload 87 PDF
- It's good to talk...
- DynamicAny, Part I
- Performitis - Part 2
- Globals, Singletons and Parameters
- Exceptions Make for Elegant Code
- Divide and Conquer: Partition Trees and Their Uses
- On Management
- Overload 86 PDF
- Plus ça change
- Performitis
- The Model Student: A Knotty Problem, Part 2
- Overload 85 PDF
- RSA Made Simple
- Quality Manifesto
- After Four Years
- Watersheds and Waterfalls (Part 2)
- The Model Student: A Knotty Problem, Part 1
- The Way of the Consultant
- Overload 84 PDF
- When Things Go Wrong
- Letter to the Editor
- Watersheds and Waterfalls
- The PfA Papers: Deglobalisation
- The Regular Travelling Salesman, Part 2
- Testing Visiting Files and Directories in C#
- Generics Without Templates
- Future Workers (Prototype)
- Overload 83 PDF
- Overload 82 PDF
- The Essence of Success
- The PfA Papers: Context Matters
- The Model Student
- Functional Programming Using C++ Templates (Part 2)
- Java Protocol Handlers
- Upgrading Legacy Software in Data Communications Systems
- Creating Awareness
- Overload 81 PDF
- While the Cat's Away...
- The PfA Papers: The Clean Dozen
- Blue-White-Red, an Example Agile Process
- Functional Programming Using C++ Templates (Part 1)
- auto_value: Transfer Semantics for Value Types
- Consensus
- Letter to the Editor
- He Sells Shell Scripts to Intersect Sets
- The PfA Papers: From the Top
- Release Mode Debugging
- auto_value: Transfer Semantics for Value Types
- Guidelines for Contributors
- Overload 80 PDF
- Overload 79 PDF
- Rip It Up and Start Again
- The Policy Bridge Design Pattern
- Live and Learn with Retrospectives
- Continuous Integration with CruiseControl.Net
- Working with GNU Export Maps
- auto_value: Transfer Semantics for Value Types
- New Tricks for an Old Dog
- Letters to the Editor
- Software Product Line Engineering with Feature Models
- A Perspective on Use of Conditional Statements versus Assertions
- Implementing Synchronization Primitives for Boost on Windows Platforms
- Design in Test-Driven Development
- C++ Unit Test Frameworks
- A Practical Form of OO Layering
- Overload 78 PDF
- Overload 77 PDF
- The Power of Inertia
- Managing Technical Debt
- Programming - Abstraction by Design
- Exceptional Design
- C++ Trivial Logger
- FRUCTOSE - a C++ Unit Test Framework
- Letter to the Editor
- Overload 76 PDF
- How Overload Comes to You
- Pooled Lists
- The Singleton in C++ - A force for good?
- C++ Interface Classes - Strengthening Encapsulation
- A Drop in Standards?
- Overload 75 PDF
- Life in the Fast Lane
- Letters
- Up Against the Barrier
- Inventing a Mutex
- C++ Unit Testing Easier: CUTE
- From CVS to Subversion
- Overload 74 PDF
- Take a Step Forward
- Comments Considered Good
- Introducing CODEF/CML
- Fine Tuning for lexical_cast
- C# Generics - Beyond Containers of T
- The Kohonen Neural Network Library
- The Documentation Myth
- Overload 73 PDF
- Editorial
- Pair Programming Explained
- Comments Considered Evil
- How Do Those Funky Placeholders Work?
- Implementing drop-down menus in pure CSS (no JavaScript)
- The Rise and Fall of Singleton Threaded
- The Case Against TODO
- Objects for States
- Overload 72 PDF
- Editorial: Doing What You Can
- Multithreading 101
- To Grin Again
- A Fistful Of Idioms
- C++ Best Practice – Designing Header Files
- Visiting Alice
- Overload 71 PDF
- Editorial: Keeping Up Standards
- Soft Documentation
- Dead Code
- How to Shoot Yourself in the Foot. In an Agile Way.
- Friend or Foe!
- Recursive Make Considered Harmful
- Overload 70 PDF
- Editorial: The "Safe C++ Standard Library"
- Two-thirds of a Pimpl and a Grin
- The Curate's Wobbly Desk
- Letter to the Editor
- How to Quantify Quality: Finding Scales of Measure
- "Here be Dragons"
- Better Encapsulation for the Curiously Recurring Template Pattern
- Overload 69 PDF
- Editorial: Can We Change For The Better?
- With Spirit
- Vorsprung Durch Testing
- Polynomial Classes
- Incremental Design: A Case Study of a Compiler
- A Framework for Generating Numerical Test Data
- Overload 68 PDF
- Editorial: Size Does Matter
- Software Project Management: Adding Stakeholder Metrics to Agile Projects
- Investigating Java Class Loading
- C-side Re-sort
- C++ Interface Classes - Noise Reduction
- A Technique for Register Access in C++
- Overload 67 PDF
- Editorial: Does all this help make better software?
- The Trial of the Reckless Coder
- "The C++ Community" - Are We Divided by a Common Language?
- Taming Complexity: A Class Hierarchy Tale
- Microsoft Symbol Engine
- Letters to the Editor
- Grain Storage MIS: A Failure of Communications (27 March 1998)
- Can C++ Learn from Generics in Ada?
- Overload 66 PDF
- Editorial: Need to Unlearn
- Sheep Farming for Software Development Managers
- Separating Interface and Implementation in C++
- Overload Resolution - Selecting the Function
- Metaprogramming is Your Friend
- Letter to the Editor
- Digging a Ditch
- Overload 65 PDF
- Editorial: "They" Have Their Reasons
- The Developer's New Work
- Stable Intermediate Forms
- Multiple Streams Going Nowhere
- Letters: Encapsulate Context
- Confirmit. Confirmit is a web-based application which enables organizations to gather, analyze and report key business information across a broad range of commercial applications.">From Waterfall to EVO in a Medium Size Norwegian Software House
- C++ Properties - a Library Solution
- C Abuse
- A Pair Programming Experience
- Overload 64 PDF
- Editorial: A Glimpse Behind the Scenes
- Yet Another Hierarchical State Machine
- Mini-project to Decode A Mini-language - Part Two
- Evolution of the Observer Pattern
- An Experience Report on Implementing a Custom Agile Methodology on a C++/Python Project
- Overload 63 PDF
- Editorial: The Buzzword Adoption Pattern?
- The Encapsulate Context Pattern
- Microsoft Visual C++ and Win32 Structured Exception Handling
- Garbage Collection and Object Lifetime
- C++ Lookup Mysteries
- A Mini-project to Decode a Mini-language - Part One
- Overload 62 PDF
- Editorial: The Value of What You Know
- The Curious Case of the Compile-Time Function
- ACCU Mentored Developers XML Project
- Letters to the Editor
- Handling Exceptions in finally
- From Mechanism to Method: The Safe Stacking of Cats
- C++ Interface Classes - An Introduction
- A Template Programmer's Struggles Revisited
- Overload 61 PDF
- Editorial: New Things Under the Sun
- Letters: Software’s No Different...
- Where Egos Dare
- When is a "Pattern" not a "Pattern"?
- The Tale of a Struggling Template Programmer
- Lvalues and Rvalues
- Efficient Exceptions?
- Letters: The Invisibility of Software Design
- Letters: Software Project Management Classics?
- A Template Programmer’s Struggles Resolved
- Overload 60 PDF
- Editorial
- Transforming XML with XSLT
- Letters to the Editor(s)
- Letters to the Editor(s)
- From Mechanism to Method: Generic Decoupling
- All Heap No Leaks
- Achieving FitNesse in C++
- A Little Detail
- Overload 59 PDF
- Editorial
- Why do requirements change?
- More is Less
- Letters to the Editor(s)
- Heretical Java #1
- From Mechanism to Method:
- C++ as a Safer C
- Overload 58 PDF
- Editorial
- From Mechanism to Method:
- Choosing Template Parameters
- CheckedInt: A Policy-Based Range-Checked Integer
- An Alternative View of design (and planning)
- A Standard Individual: A Licensed Engineer
- A More Flexible Container
- Letter to the Editor(s)
- Overload 57 PDF
- Statically Checking Exception Specifications
- Editorial
- Software As Read
- Single Exit
- SINGLETON - the anti-pattern!
- Letters to the Editor(s)
- Letters to the Editor(s)
- Letters to the Editor(s)
- Is IT worth it?
- Error and Exception Handling
- Chaos Theory
- A Policy-Driven CORBA Template Library to Facilitate the Rapid Development of DOC Middleware
- Overload 56 PDF
- Editorial
- Three Phantastic Tales
- Stream-Based Parsing in C++
- Reshaping an Old Piece of Design
- EuroPLoP 2003 Conference Report
- A Unified Singleton Framework
- Overload 55 PDF
- Editorial
- Ruminations on Knowledge in Software Development
- How To Write A Loop
- From Mechanism to Method
- Embedded Scripting Languages
- A bin Manipulator For IOStreams
- Overload 54 PDF
- Editorial
- The Nature and Aesthetics of Design
- Software development and the learning organisation
- Observer Pattern Implementation
- Labouring: An Analogy
- Implementing the Bridge pattern using templates with Microsoft Visual C++ 6.0
- Exported Templates
- EXPR_TYPE - An Implementation of typeof Using Current Standard C++
- Addendum to "Tiny Template Tidbit"
- A C++ Petri Net Framework For Multithreaded Programming
- Overload 53 PDF
- Editorial
- Implementing the Observer Pattern in C++ - Part 2
- From Mechanism to Method ÂTotal Ellipse
- Build Systems
- Indexing STL lists with maps
- A Return Type That Doesn’t Like Being Ignored
- C++rossword
- C++ Standards Library Report
- C++ Templates
- Overload 52 PDF
- Organising Source Code
- Letters to the Editor
- Implementing the Observer Pattern in C++ - Part 1
- From Mechanism to Method - Good Qualifications
- File Format Conversion Using Templates and Type Collections
- Editorial - On Writing
- Developing a C++ Unit Testing Framework
- Overload 51 PDF
- STL-style Circular Buffers By Example, Part Two
- Patterns Collaborations: Observer and Composite
- Pairing Off Iterators
- Mutate? or Create?
- Extendable Software and the Bigger Picture
- Exception Handling in C#
- Editorial - Software Quality
- Applied Reading - Taming Shared Memory
- Overload 50 PDF
- The Philosophy of Extensible Software
- Template Metaprogramming: Shifting Down a Gear
- STL-style Circular Buffers By Example
- Execute Around Method and Proxy Goulash
- Even More Java Exceptions
- Editorial
- Alternatives for Partial Template Function Specialisation
- Overload 49 PDF
- Writing Extendable Software
- The scoping problem
- Programming with Interfaces in C++
- More Exceptional Java
- Letter To The Editor
- Editorial
- Building Java Applications
- An Overview of C#.NET
- Overload 48 PDF
- Thinking about "reuse"
- The C++ Template Argument Deduction
- Template Titbit - A Different Perspective
- From Mechanism to Method - Function Follows Form
- Exceptional Java
- Editorial
- C++ Exceptions and Linux Dynamic Libraries
- Overload 47 PDF
- What is Boost?
- Tiny Template Tidbit
- Of Minimalism, Constructivism and Program Code
- minimalism
- Editorial: Product Definition
- Minimalist Constructive Criticism
- Introduction to WOC:
- How about a Turner Prize for software?
- Editorial - Coming Home
- Template Metaprogramming
- Techniques for Debugging in C++
- Modelling and Software Development
- Metaclasses and Reflection in C++ - Part 2
- Porting part 3 :
- minimalism
- Editorial
- Metaclasses and Reflection in C++
- Introduction to C++ Templates
- Using Version Control
- String Tokenization - A Programmer's Odyssey
- Porting (part 2) - Addressing the Differences
- Flexible Functors and Binders
- Editorial
- Designing C++ Interfaces - Templates
- Are You Afraid of The Dark Too? Making More Sense of the STL
- Editorial
- Where to begin: Porting
- Introduction to the Database Template Library
- Designing C++ Interfaces - Exception Safety
- Are You Afraid of The Dark? - Making Sense of the STL
- An introduction to C++ Traits
- .NET
- Typesafe Registry for Windows
- Multimethods
- Editor << letters;
- Editor << letters;
- Editorial
- Compile Time Indirection - An Unusual Template Technique
- C++ Idioms: First Thoughts
- A Generic Non-intrusive Smart Pointer Implementation
- A Deeper Look at Inline Functions
- C++ Standards - The "swap" Problem
- Experiences of Implementing the Observer Design Pattern (Part 3)
- Editorial
- Where is __FUNCTION__?
- Thread Pooling: An Investigation
- Source Code Modules and Layering
- Extensibility - A Reason For Using Streams in C++
- Programming with Interfaces in C++
- More Include File Rules
- Here be Dragons
- From Mechanism to Method
- editorial: Concerning Patents
- User Defined Types: Qualities, Principles and Archetypes.
- Include Files
- From Mechanism to Method: Substitutability
- Editorial
- C++ Patterns Source Cohesion and Decoupling
- Supporting Threads in Standard C++ (Addendum)
- Intuitive Multi-Paradigm Design:
- Interpreting "Supporting the 'Cheshire Cat' Idiom"
- Experiences of Implementing the Observer Design Pattern (Part 2)
- Editorial
- A Fistful Of Idioms - Giving STL Iterators a Base Class
• 37
+
- editor << letters;
- The Pet Project (part 4)
- Supporting Threads in Standard C++ (Part 3)
- editorial
- A framework for object serialization in C++
- In Response to Extreme Programming
- Experiences of Implementing the Observer Design Pattern (Part 1)
- XML in Applications II DOM - the Document Object Model
- The Pet Project - Monopoly (Part 3)
- Supporting Threads in Standard C++ (Part 2)
- editorial
- An Implementation of Double Dispatch in Java
- An Application of Pointers to Members
- A Response to the C++ SIG Organiser
- Standard C++
- My Pet Project Monopoly 2
- eXtreme Programming An interview with Kent Beck
- File Headers
- Exceptions - Guidance
- Error handling and logging
- editorial
- Automatic Object Versioning for Forward and Backward File Format Compatibility
- editor << letters;
- XML
- When's an object not an object?
- Uncounted pointers in C++
- The Diary of Bridget Jones the Weekend Before OT
- Software Architecture
- SAX - A Simple API for XML
- My Pet Project - Monopoly
- Exceptions - The Details
- Error logging and patterns
- Editorial
- editor << letters;
- The State Pattern - A New Implementation
- Religious Issues
- More threading with templates
- More cow_ptr<type> Ruminations
- Exceptions - The Basics
- Editorial
- Coping with Copying in C++
- The EPOC C++ API
- Ruminations on Studying Design Patterns
- Polymorphism In Object-Oriented Languages
- Modern Art as an Inspiration for Software
- Micro-Derivation & Related Ideas
- Editorial
- Builder & Factory Method Patterns
- BroadVision, Part 4
- Beyond ACCU
- A Simple Model for Object Persistence Using the Standard Library
- A Review of cow_ptr<type>
- Using Templates To Handle Multi-Threading
- copy_on_write_ptr<type>
- Thoughts on Functoids
- Response To "Patterns - The Abstract Factory" (Francis Glassborow, Overload 30)
- Objects In Databases
- Goodbye Overload
- Fitting in with multiple frameworks in C++ and Java
- Factories in C++: Disposing of the Product
- Exception Handling Alternatives (Part 2)
- Editorial
- Write to Learn
- UML Relationships and Associations, Aggregation and Composition
- Patterns - The Abstract Factory
- Overloading Operators
- editor << letters;
- Garbage Collection Implementation Considerations
- Exception Handling Alternatives
- Editorial
- Data Attribute Notation - Part 3
- An Eventful Story
- A Letter from Ken Hagan annotated by The Harpist
- operator == ()
- counted_ptr<type> revisited
- Static vs Member Functions
- Exception Specifications
- Exception Errors
- Exception Discussion
- Editorial
- Debug new and delete Part 3
- Data Attribute Notation - Part 2
- Beyond ACCU... Patterns on the 'net
- A Message from the ACCU Chair
- A Delphic Experience
- Shallow Pointer
- Notes on Exceptions
- Exploring Patterns 3 - The Adapter
- Exceptions & Exception Specifications
- Exception Usage
- Editor << letters;
- Editorial
- Controlling access to objects by using private interfaces
- Broadvision - Part 3
- Beyond ACCU... Java on the 'net
- Overload 27 PDF
- Object (low-level) Design and Implementation
- Hotel Case Study Comments
- UML Interactions & Collaborations
- Self Registering Classes - Taking polymorphism to the limit
- Hotel Case Study Comments
- Exploring Patterns Part 2
- Editorial
- Broadvision - Part 2
- Beyond ACCU... Patterns on the 'net
- Almost a Pattern
- Overload 26 PDF
- Overload 25 PDF
- Overload 24 PDF
- Overload 23 PDF
- Overload 22 PDF
- Overload 21 PDF
- Overload 20 PDF
- Overload 19 PDF
- Editorial
- The uses and abuses of inheritence
- Caught in the pattern web
- The Casting Vote I
- The Casting Vote II
- Circles and Ellipses revisited: coding techniques - 2
- Standard containers for polymorphic types
- auto_ptr || !auto_ptr
- Using objects for background tasks (3)
- Overload 16 PDF
- Overload 15 PDF
- Overload 14 PDF
- Overload 13 PDF
- Overload 12 PDF
- Overload 11 PDF
- Overload 10 PDF
- Overload 9 PDF
- Overload 8 PDF
- Overload 7 PDF
- The Casting Vote
- Putting Jack in the Box
- Overloading on const is wrong
- Friends - who needs them?
- C++ compilers for MSDOS / MSWindows
- Blindspots
- An alternative to wchar_t
- A Text Formatting Class
- The Virtual Interview
- Operators for Arithmetic Classes
- Are “Safe†Computer Systems Possible?
- So you want to be a cOOmpiler writer?
- Microsoft Visual C++ V1.5 (16bit)
- Borland C++ V4.
- Writing Your Own Stream Manipulators
- The Casting Vote
- Microsoft Visual C++ Strategy
- Letters
- Afterword
- Editor's Ramble
- The Casting Vote
- Windows Waffle
- Do birds in their little nests always agree?
- new & delete
- Shared Memory Class
- Run-time checking for C++
- Why C++ will replace FORTRAN (or, at least, why it should)
- char* p vs char *p
- Readers Letters
- Epilogue
- Editor's Ramble
- Welcome to ECUG
- Minimising Stack Use and Other Uses of new
- C++ Strings -The ANSI Way
- Managing Class Coupling
- Custom Controls
- Windows File Class
- Class Struggle
- Unit Testing Of C++ Classes
- Uses of Classes with only Private and Protected Constructors
- A Short Exposure to C++
- Readers Letters
- Epilogue
- Editor's Ramble
- C++ Streams (Part 2)
- Class Struggle
- The Help Compiler
- Some Thoughts on the Use of New
- An E-mail Conversation with Bjarne Stroustrup
- Members' Letters
- The Pedant
- Epilogue
- Editor's Ramble
- C++ Streams
- Make...or Break?
- Templates
- An Introduction to Object Orientation
- Class Struggle
- Rumbaugh's OMT - The method behind C++ Designer
- Dates & Times
- Starting out with OWL
- Some Thoughts on Writing Classes
- Whingeing Session
- Epilogue
- On the Other Side of the Barricade: Job Interviewer Do’s and Don’ts
- Object-Environment Collision Detection using Onion BSPs
- How to Program Your Way Out of a Paper Bag Using Genetic Algorithms [XML/HTML]
- Hand edited from Test-HTML-1. Last changed: 10 July 2013, Martin Moene]">Executable Documentation Doesn’t Have To Slow You Down [Test-HTML-2]
- Sample Overload Article (title)
- Executable Documentation Doesn’t Have To Slow You Down [Test-XML-1]
- HTML generated by Alison Peck. A hand edited version is at Test-HTML-2 by Martin Moene]">Executable Documentation Doesn’t Have To Slow You Down [Test-HTML-1]
What's in a Namespace?
Description :
Category: [ CVu Journal Vol 16, #6 - Dec 2004 | Programming Topics ]
Description :
In this article I will visit the mechanics of namespaces and anonymous namespaces and explain how they are used to solve some of the problems associated with linking C++ programs. Then I will move on to explain how they can also be used to provide context.
by Paul GrenyerCategory: [ CVu Journal Vol 16, #6 - Dec 2004 | Programming Topics ]
An Introduction to Programming with GTK+ and Glade in ISO C
and ISO C++ - Part 3
by Roger Leigh
Category: [ CVu Journal Vol 16, #6 - Dec 2004 | Programming Topics ]
by Roger Leigh
Category: [ CVu Journal Vol 16, #6 - Dec 2004 | Programming Topics ]
An Introduction to Objective-C
Description :
Category: [ CVu Journal Vol 16, #6 - Dec 2004 | Programming Topics ]
Description :
Part 3 - An Example Using Foundation
by D. A. ThomasCategory: [ CVu Journal Vol 16, #6 - Dec 2004 | Programming Topics ]
Wx - A Live Port
Description :
Category: [ CVu Journal Vol 16, #5 - Oct 2004 | Programming Topics ]
Description :
This is a collection of notes I have made while porting an application from MFC to wxWidgets. It is intended partly as a tutorial and partly to document some of the roadblocks I met on the way.
by Jonathan SelbyCategory: [ CVu Journal Vol 16, #5 - Oct 2004 | Programming Topics ]
Rapid Dialog Design Using Qt
Description :
Category: [ CVu Journal Vol 16, #5 - Oct 2004 | Programming Topics ]
Description :
In this third installment of our series on GUI programming with the Qt C++ toolkit, we're going to show how to design dialog boxes (or "dialogs") using Qt.
by Jasmin BlanchetteCategory: [ CVu Journal Vol 16, #5 - Oct 2004 | Programming Topics ]
Introduction to STL (Standard Template Library)
Description :
Category: [ CVu Journal Vol 16, #5 - Oct 2004 | Programming Topics ]
Description :
Since STL is a very large topic to be covered in an article or two, we will focus on the most commonly used generic classes: vector and string.
by Rajanikanth JammalamadakaCategory: [ CVu Journal Vol 16, #5 - Oct 2004 | Programming Topics ]
An Introduction to Programming with GTK+ and Glade - Part
2
Description :
Category: [ CVu Journal Vol 16, #5 - Oct 2004 | Programming Topics ]
Description :
In this part, I will be showing how to use the Glade application for rapid window creation.
by Roger LeighCategory: [ CVu Journal Vol 16, #5 - Oct 2004 | Programming Topics ]
An Introduction to Objective-C
by D. A. Thomas
Category: [ CVu Journal Vol 16, #5 - Oct 2004 | Programming Topics ]
by D. A. Thomas
Category: [ CVu Journal Vol 16, #5 - Oct 2004 | Programming Topics ]
The Encapsulate Context Pattern
by Allan Kelly
Category: [ Overload Journal #63 - Oct 2004 | Programming Topics ]
by Allan Kelly
Category: [ Overload Journal #63 - Oct 2004 | Programming Topics ]
Microsoft Visual C++ and Win32 Structured Exception
Handling
by Roger Orr
Source : microsoft visual c++, structured exception handling.
Category: [ Overload Journal #63 - Oct 2004 | Programming Topics ]
by Roger Orr
Source : microsoft visual c++, structured exception handling.
Category: [ Overload Journal #63 - Oct 2004 | Programming Topics ]
Garbage Collection and Object Lifetime
by Ric Parkin
Category: [ Overload Journal #63 - Oct 2004 | Programming Topics ]
by Ric Parkin
Category: [ Overload Journal #63 - Oct 2004 | Programming Topics ]
C++ Lookup Mysteries
by Sven Rosvall
Category: [ Overload Journal #63 - Oct 2004 | Programming Topics ]
by Sven Rosvall
Category: [ Overload Journal #63 - Oct 2004 | Programming Topics ]
A Mini-project to Decode a Mini-language - Part One
by Thomas Guest
Category: [ Overload Journal #63 - Oct 2004 | Programming Topics ]
by Thomas Guest
Category: [ Overload Journal #63 - Oct 2004 | Programming Topics ]
XML as a Model-View-Controller System for Documents
Description :
Category: [ CVu Journal Vol 16, #4 - Aug 2004 | Programming Topics ]
Description :
In this article I will describe how an MVC approach to the generation of documents can yield the same benefits that are traditionally seen with this approach to software design, and will introduce some XML [XML][Harold-] tools that can support this method. Finally, I will look at some of the alternatives to XML that could achieve the same separation of concerns.
by Matthew StrawbridgeCategory: [ CVu Journal Vol 16, #4 - Aug 2004 | Programming Topics ]
Introduction to C# - Part 2
Description :
Category: [ CVu Journal Vol 16, #4 - Aug 2004 | Programming Topics ]
Description :
Welcome to the second in a series of articles introducing the C# programming language. In the previous issue the basics of the language such as variables, methods and classes were covered. In this issue classes are covered in more detail highlighting an important feature called inheritance.
by Mike BerginCategory: [ CVu Journal Vol 16, #4 - Aug 2004 | Programming Topics ]
Creating Standard GUI Applications
Description :
Category: [ CVu Journal Vol 16, #4 - Aug 2004 | Programming Topics ]
Description :
In this second installment of our series on GUI programming with the Qt C++ toolkit, we're going to see how to create a standard GUI application, with a menu, toolbar, status bar, and a central area.
by Mark Summerfield , Jasmin BlanchetteCategory: [ CVu Journal Vol 16, #4 - Aug 2004 | Programming Topics ]
C++ Templates - A Simple Example
Description : p>This article describes the C++ code for performing basic operations on matrices using templates. by Rajanikanth Jammalamadaka
Category: [ CVu Journal Vol 16, #4 - Aug 2004 | Programming Topics ]
Description : p>This article describes the C++ code for performing basic operations on matrices using templates. by Rajanikanth Jammalamadaka
Category: [ CVu Journal Vol 16, #4 - Aug 2004 | Programming Topics ]
An Introduction to Programming with GTK+ and Glade in ISO C
and ISO C++
Description :
Category: [ CVu Journal Vol 16, #4 - Aug 2004 | Programming Topics ]
Description :
This short tutorial is intended as a simple introduction to writing GTK+ applications in C and C++, using the current 2.0/2.2 version of libgtk. It also covers the use of the Glade user interface designer for rapid application development (RAD).
by Roger LeighCategory: [ CVu Journal Vol 16, #4 - Aug 2004 | Programming Topics ]
An Introduction to Objective-C
Description :
Category: [ CVu Journal Vol 16, #4 - Aug 2004 | Programming Topics ]
Description :
This series of articles aims to introduce the Objective-C programming language to readers of C Vu, who are users of C and C++. I will try to show how the language manages to add object-oriented facilities to the low-level features of C in a way that is radically different from that of C++.
by D. A. ThomasCategory: [ CVu Journal Vol 16, #4 - Aug 2004 | Programming Topics ]
The Curious Case of the Compile-Time Function
by Phil Bass
Category: [ Overload Journal #62 - Aug 2004 | Programming Topics ]
by Phil Bass
Category: [ Overload Journal #62 - Aug 2004 | Programming Topics ]