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