Advertisement
Advertisement
Membership
Login
ACCU Buttons
Add them to your site:
| Browse in : | > Topics > Management |
- 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
• Management
+
- 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.
- 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
• Design
+
- Making a Linux Desktop
- Piping Software for Less
- An Example Confined User Shell
- The Standard Report
- Refocusing Amdahl’s Law
- Expect the Unexpected (Part 1)
- What Is Your Name?
- Quick Modular Calculations (Part 3)
- Deconstructing Inheritance
- It’s About Time
- The Standard Report
- The Path of Least Resistance
- A Secure Environment for Running Apps?
- Afterwood
- Making a Linux Desktop: Painting Some Wallpaper
- OOP Is not Essential
- C++ Pipes
- Making a Linux Desktop
- A Low-Latency Logging Framework
- On IT and... 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.
Programming - Abstraction by Design
Description : Nigel Eke acts as a guide to aspect oriented programming using AspectJ as an example. by Nigel Eke
Category: [ Overload Journal #77 - Feb 2007 | Programming Topics | Design of applications and programs ]
Description : Nigel Eke acts as a guide to aspect oriented programming using AspectJ as an example. by Nigel Eke
Category: [ Overload Journal #77 - Feb 2007 | Programming Topics | Design of applications and programs ]
Exceptional Design
Description : Hubert Matthews discusses some ways to design programs to use exceptions. by Hubert Matthews
Category: [ Overload Journal #77 - Feb 2007 | Design of applications and programs ]
Description : Hubert Matthews discusses some ways to design programs to use exceptions. by Hubert Matthews
Category: [ Overload Journal #77 - Feb 2007 | Design of applications and programs ]
The Singleton in C++ - A force for good?
Description : Alexander Nasonov addresses some problems that arise when using Singleton in C++. by Alexander Nasonov
Category: [ Overload Journal #76 - Dec 2006 | Programming Topics | Design of applications and programs ]
Description : Alexander Nasonov addresses some problems that arise when using Singleton in C++. by Alexander Nasonov
Category: [ Overload Journal #76 - Dec 2006 | Programming Topics | Design of applications and programs ]
C++ Interface Classes - Strengthening Encapsulation
Description : Mark looks at the separation of interface and implementation in C++, and how the separation helps to strengthen encapsulation. by Mark Radford
Category: [ Overload Journal #76 - Dec 2006 | Programming Topics | Design of applications and programs ]
Description : Mark looks at the separation of interface and implementation in C++, and how the separation helps to strengthen encapsulation. by Mark Radford
Category: [ Overload Journal #76 - Dec 2006 | Programming Topics | Design of applications and programs ]
The Rise and Fall of Singleton Threaded
Description : Steve Love explores how 'Singletons' in design can seem a good idea at the time, why they are generally a mistake, and what to do if you have them. by Steve Love
Category: [ Overload Journal #73 - Jun 2006 | Programming Topics | Design of applications and programs ]
Description : Steve Love explores how 'Singletons' in design can seem a good idea at the time, why they are generally a mistake, and what to do if you have them. by Steve Love
Category: [ Overload Journal #73 - Jun 2006 | Programming Topics | Design of applications and programs ]
Test Driven Development of C# User Interfaces
Description :
Category: [ CVu Journal Vol 17, #6 - Dec 2005 | Design of applications and programs ]
Description :
In my last article I discussed the values in the Agile Manifesto and what they mean to mean. There are many practices that can be used to make yourself more agile. Short iterations, the planning game, pair programming, and refactoring are a few of the practices present in eXtreme programming. The practice of most value to me, and the practice that many recommend to use as a starting point, is Test Driven Development - TDD.
by Phran RyderCategory: [ CVu Journal Vol 17, #6 - Dec 2005 | Design of applications and programs ]
Debuggers Should Go Backwards
Description :
Category: [ CVu Journal Vol 17, #6 - Dec 2005 | Design of applications and programs ]
Description :
The computer science community has shown a woeful lack of interest in debugging, which given the huge economic cost of debugging is somewhat mysterious. However, there may be signs of "green shoots" in the desert landscape of debugging tools.
by Greg Law , Julian SmithCategory: [ CVu Journal Vol 17, #6 - Dec 2005 | Design of applications and programs ]
Cryptographic Mistakes Made in Programming
by Jonathan Wignall
Category: [ CVu Journal Vol 17, #6 - Dec 2005 | Design of applications and programs ]
by Jonathan Wignall
Category: [ CVu Journal Vol 17, #6 - Dec 2005 | Design of applications and programs ]
A Reflection on Defensive Programming
by Roger Orr
Category: [ CVu Journal Vol 17, #6 - Dec 2005 | Design of applications and programs ]
by Roger Orr
Category: [ CVu Journal Vol 17, #6 - Dec 2005 | Design of applications and programs ]
The Agile Manifesto Explained (and a First
Amendment)
Description :
Source : agile development
Category: [ CVu Journal Vol 17, #5 - Oct 2005 | Project Management ]
Description :
In my last article I set the scene for what I hope will be a series of provocative and informative articles. In the article I described the plight of Pete and his vain efforts to change development processes at his place of work.
by Phran RyderSource : agile development
Category: [ CVu Journal Vol 17, #5 - Oct 2005 | Project Management ]
Setting up a Subversion Server for Remote Use
Description :
Category: [ CVu Journal Vol 17, #5 - Oct 2005 | Project Management ]
Description :
Revision control is a critical part of any significant development project. Having secure full time access to your repository from wherever you are can be important. In some environments, such as open source projects, it's absolutely crucial to the functioning of the development team.
by Craig RingerCategory: [ CVu Journal Vol 17, #5 - Oct 2005 | Project Management ]
Patterns in C - Part 5: REACTOR
Description :
Category: [ CVu Journal Vol 17, #5 - Oct 2005 | Design of applications and programs ]
Description :
This final part of the series will step outside the domain of standard C and investigate a pattern for event-driven applications. The REACTOR pattern decouples different responsibilities and allows applications to demultiplex and dispatch events from potentially many clients.
by Adam PetersenCategory: [ CVu Journal Vol 17, #5 - Oct 2005 | Design of applications and programs ]
Vorsprung Durch Testing
by Kevlin Henney
Category: [ Overload Journal #69 - Oct 2005 | Design of applications and programs ]
by Kevlin Henney
Category: [ Overload Journal #69 - Oct 2005 | Design of applications and programs ]
Editorial: Size Does Matter
Description : The way that one goes about developing and delivering a software project depends critically on the scale of the project.
Discuss. by Alan Griffiths
Category: [ Overload Journal #68 - Aug 2005 | Project Management | Journal Editorial ]
Description : The way that one goes about developing and delivering a software project depends critically on the scale of the project.
Discuss. by Alan Griffiths
Category: [ Overload Journal #68 - Aug 2005 | Project Management | Journal Editorial ]
Patterns in C - Part 4: OBSERVER
Description :
Category: [ CVu Journal Vol 17, #4 - Aug 2005 | Design of applications and programs ]
Description :
This part of the series will highlight another principle for dependency management and illustrate how both of these principles may be realized in C using the OBSERVER pattern.
by Adam PetersenCategory: [ CVu Journal Vol 17, #4 - Aug 2005 | Design of applications and programs ]
Becoming and Being Agile
by Phran Ryder
Category: [ CVu Journal Vol 17, #4 - Aug 2005 | Project Management ]
by Phran Ryder
Category: [ CVu Journal Vol 17, #4 - Aug 2005 | Project Management ]
Software Project Management: Adding Stakeholder Metrics to
Agile Projects
Description : Agile methods need to include stakeholder metrics in order to ensure that projects focus better on the critical requirements, and that projects are better able to measure their achievements, and to adapt to feedback. This paper presents a short, simple defined process for evolutionary project management (Evo), and discusses its key features. by Tom Gilb
Category: [ Overload Journal #68 - Aug 2005 | Project Management ]
Description : Agile methods need to include stakeholder metrics in order to ensure that projects focus better on the critical requirements, and that projects are better able to measure their achievements, and to adapt to feedback. This paper presents a short, simple defined process for evolutionary project management (Evo), and discusses its key features. by Tom Gilb
Category: [ Overload Journal #68 - Aug 2005 | Project Management ]
Professionalism in Programming #32
Description :
Category: [ CVu Journal Vol 17, #3 - Jun 2005 | Project Management ]
Description :
In this article I present a series of thought provoking questions based on some topics that I've covered in past issues.
by Pete GoodliffeCategory: [ CVu Journal Vol 17, #3 - Jun 2005 | Project Management ]
Patterns in C - Part 3: Strategy
Description :
Category: [ CVu Journal Vol 17, #3 - Jun 2005 | Design of applications and programs ]
Description :
This part of the series will investigate a design pattern that adds flexibility to common software entities by letting clients customize and extend them without modifying existing code.
by Adam PetersenCategory: [ CVu Journal Vol 17, #3 - Jun 2005 | Design of applications and programs ]
Are Certificates Worth the Paper they are Written
On?
by Alan Lenton
Category: [ CVu Journal Vol 17, #3 - Jun 2005 | Project Management ]
by Alan Lenton
Category: [ CVu Journal Vol 17, #3 - Jun 2005 | Project Management ]