It’ll only show when rvm is in use. And here’s how it looks.

You can use the above code in the step definitions.

Erlang
You create a dozen clones of youself, pass the gun to one another in turn to shoot at each other’s foot

Python
You have to align your foot 10 steps below the gun for it to work

Ruby
You pull the trigger to find popcorns popping out of the gun. Someone somewhere has just made all guns shoot popcorns.

Haskell
Close your eyes and picture a gun in your mind. Think about the foot being shot. Open your eyes. You found your foot shot. No sound. No smell. No one else even noticed.

Scala
You pull the trigger and you got shot. You stab your foot with the gun and you got shot.

The feature is shown here:

Define your steps:

As celerity does not have an attach_file method, I got to write my own. You could see it’s not hard at all. Remember to define the browser variable.

Last, we have some hooks to clean up the test upload files. Remember to place an @upload tag in your scenario.

• action_mailer_cache_delivery
• email_spec

Install them as plugins following the same instructions from the README. Don’t forget to change the git url!

Setting up

I’m following the example by J Aaron Farr. His example works and is simple enough.

The example code and screencast can be downloaded here.

If you are following Farr’s steps, you should end up with 3 directories: builder, features, plugins. You should place all your plugins in the plugins folder, and the features in the features folder. The builder folder can be copied from Farr’s example. One thing to note is inside the builder folder is a target folder. That contains a copy of Eclipse which is used to build. Make sure that copy has the dependencies(plugins/features) you need.

The checklist

There’re lots of things that can go wrong in an Eclipse PDE build. Most times the error messags don’t tell you clearly what’s wrong. In my experience, the problems are usually found in the configuration. And it always is a dependency problem.

Product

The product file is found from your launching plugin.

• Does the product contain all of your plugins and their dependencies? Only those plugins/features listed in the product are packaged. So make sure all the things you need are there
• Does the build.properties file point to the correct product file?
• Does the product contain the features necessary for testing? You need these 2 features org.eclipse.rcp(for launching eclipse) and org.eclipse.test(for testing). Add them as one of the features in the product.
• Does the product configuration correct? There’s the fields like name, id, application, useFeatures found in the attriute line of the product declaration. Make sure these are correct.

build.properties

This is one of the configuration files found under builder directory. It is meant for build.xml.

• Are the paths correct? Use the full path to make sure everything works first. Switch to relative paths after which.
• Is it forward slash or back slash? Ans: its “/”
• What if I have spaces in the path? Ans: Use double quotes “”

For a better explanation, you can try the eclipse wiki

customTarget.xml

This is one of the configuration files found under builder directory. It is meant for adding your own ant targets to the build process.

• Are u running junit tests? If you do, have you added an ant target task? Is the path correct?

allElements.xml

This is one of the configuration files found under builder directory.

• Is the name of your feature correct?

Deployment target

This is the eclipse that you usually use to build against.

• Does it have all the plugins features necessary for the build?
• Does it contain only 1 copy of the plugin/feature?(eclipse will always take the newest version of the same plugin. it’ll cause problems if your build needs the older version)

Build target

This is the eclipse target found under builder > target.

• Does it have all the plugins features necessary for the build?
• Does it contain only 1 copy of the plugin/feature?(eclipse will always take the newest version of the same plugin. it’ll cause problems if your build needs the older version)

feature.xml for the plugins

This is the feature.xml for the feature that contains your plugins.

• Is the id correct?
• Does it contain all the plugins of your project
• Does it have the dependencies listed?

feature.xml for the test plugins

This is the feature.xml for the feature that contains your test plugins.

• Does it have the required dependency org.apache.ant?
• Does it contain the test plugins?
• Does it contain org.apache.ant and org.eclipse.core.runtime.compatibility?

General

• Is the compiler version correct?
• Is Ant and Java configured correctly?

For a project, there’re a few tools which are absolutely necessary to function

• File Server
• Project Wiki
• Continuous Integration Server
• Bug/Issue Tracking
• Source Control

With these features in mind, I have identified the software necessary to provide all these functionality.

• Subversion – Source Control
• Redmine – wiki, issue tracking, forums, repository viewing
• Hudson – continuous integration
• VSFTP – FTP file server

Ubuntu is chosen cos Linux is more stable, its free, its much easier to install stuff in it. But the real reason is cos I’m a Linux geek.

What do you need to learn?

All the work is done on the command line. So you need to be familiar with UNIX shell commands. Another thing is you’ll be editing text files most of the time. Therefore you have to learn one of the UNIX text editors.

Basic UNIX commands

Unix text editors

• Emacs
• Vim
• Pico
• nano

What tools do you need?

• Putty SSH client
• Hardware – any old computer will do
• OS – Ubuntu Linux Server Edition

Setting up the server OS

• OpenSSH Server
• Ubuntu Initial Setup
• Fix your IP

Redmine Issue Tracking Server

• Ruby on Rails
• MySQL
• MySQL Ruby Gems
• Thin Web App Server
• Redmine

Subversion

VSFTP FTP Server

Hudson Continuous Integration Server

• Java JDK
• Hudson

Maven

Static Code Analysis Tools

• PMD
• findbugs
• Cobertura

Continuous feedback devices

• X10 firecracker
• Arduino

How-Tos

• Pragmatic Automation
• Hudson Lava Lamps
• Debian X10 package
• IBM Continuous Integration

What is a payment gateway? Why do I need it?

The payment gateway is that magic link between your website and the banks. It is how people pay you from the Internet. Without it, you can’t make any monetary transactions. No transactions means you can’t sell. Simply put, you must have a payment gateway if you were to sell things online.

E-Commerce Features

Amongst payment gateways, they offer many different pricing plans and different features. Here’re some of the major features that you should take into consideration.

1. Virtual terminal

Virtual terminal is a virtual credit card swipe machine. It means you can make purchases manually by keying in the credit card details through the virtual terminal. It is helpful in cases when you sell your goods in person. The customer can still pay you by credit card though you don’t have a swipe machine. But from a customer’s perspective, I don’t feel comfortable letting a stranger know my credit card number. Besides, isn’t your website supposed to be up 24/7? Well, I feel that this feature is helpful but largely non essential.

2. Support

Support is that helping hand when things don’t work. For example, you have problems integrating. Or the payment gateway is down, and you don’t know why. Different plans have different support arrangements. It can range from email support to phone to 24/7 phone support. Though the terms may say 24/7 phone support, it may be an empty promise. If support is important to you, do seek out current customers and find out how’s their customer service experience.

3. Hosted/Non hosted

Hosted solutions is when your customers is transferred to the payment gateway’s website to make payment. While non-hosted solutions means the entire payment process is completed on your website. The main difference is the question of user interface. When your customers are redirected to another website, they’re facing a completely different user interface. It may make them uncomfortable. Some people feel that it looks unprofessional. Is this a turn off significant enough? Well, it is subjective. If a simple redirect is enough to turn off your customers, doesn’t that reveal how much they want to buy your product? Rather than working on your interface, why not spend your energy on things that matter?

4. Credit card

Visa, Mastercard, Discover, etc There’re a multitude of credit cards available. Not all cards are supported by the gateways. Do check with them. In essence think which credit cards do your customers use. As long as you support the cards they have, you’re fine.

5. Need a merchant account?

Usually, non-hosted solutions would require you to have a merchant account. A merchant account is a bank account that is electronically linked to the payment gateway. It means when someone makes payment, the money goes into this merchant account. You will need to pay fees for it. Banks usually impose a setup fee, plus transaction fees plus monthly fees. Don’t forget you still need to pay the payment gateways.

6. E-Commerce Technology

Payment gateways offer different ways to integrate with their servers. Some may let you integrate via web services. While some may force you to use JSP(they told they’ve never heard of Rails before). So ask your programmer to check out the technologies available before you commit to a payment gateway

What are the payments gateways available in Singapore?

It is at times like this that you realise that the Internet is very US centric. Many of the well known payment gateways like Authorize.net, Braintree, Google Checkout operate exclusively in the United States. The choices are pretty limited if you’re not in US.

Available Options in Singapore

• Paypal Website Payment Standard
• Paypal Payflow Gateway
• E-Nets
• E-Clearing
• World Pay
• Payment Express
• Cybersource(See updates below)
• 2c2p(Mar 2010)
• Payvision

For Paypal Payflow Gateway, the condition is you need to have a volume of S$5 million a year. If you qualify, congratulations! Visit a Citibank branch to open a merchant account and link it to the Payflow Gateway. It took me 2 months, a wasted trip to Paypal office in Singapore(where I got chased away), over 10 emails, almost 20 calls to Paypal(including overseas calls to UK and US) just to find this out.

Banks do have e-commerce services. But Singapore banks are geared towards servicing brick and mortar companies aiming to build an internet store. They’re not start-up friendly. What do I mean by that? It is required that you go through an application process, where you fill up many forms, and wait. And in fact, their e-commerce service providers are either E-Nets or E-Clearing. So please save yourself trouble and possible middleman fees by approaching the payment gateways directly. For overseas payment gateways, they usually offer their services through E-Nets. That is the case for Payment Express which is based in New Zealand.

Cost Comparison

Final Decision?

Eventually, we decided to use Paypal Website Payment Standard. Why? First, the cost is the lowest. There’re no set up fees or monthly fees. You only pay when there’re purchases. Second, the process is easy to set up. All I needed is a credit card. Applying for a merchant account at the banks is a hassle in comparison. There is processing time, and added charges for the set up can be quite hefty.

How to build an e-commerce cart?

There’re all sorts of technologies available. It depends on the person coding it.

If you’re using Rails, I highly recommend the following blog post from fortytwo.

Good luck on your e-commerce endeavours!

Update – Jan 2010

I’ve found out that Cybersource offers an API for direct integration on your website. Their prices is reasonable too. They have a Singapore office. It’s best to call them directly. Their emails keep bouncing.

Another option that is coming is 2C2P. They will link to local banks on March 1st 2010. They also have an API.

Update – Apr 2010

Another option is Payvision. They have a local office. Their sales staff can be annoying. They want to see your website before further discussion. With Payvision, you can use CheddarGetter for recurring payments

At the moment, Ubuntu doesn’t come pre-installed with a wizard(like Windows) where you can configure your screen. You have to install the drivers by yourself. To do that just follow the tutorial from this Linux Fanatics. It demonstrates you how to get Envy, which sets up the drivers for you automatically.

After that, you got the wizard to help you configure your monitors. Well, that should work for some. But not for me. In the end, I had to configure my xorg.conf. So here’s my xorg.conf


Section "ServerLayout"
Identifier "Default Layout"
screen "Default Screen" 0 0
Inputdevice "Generic Keyboard"
Inputdevice "Configured Mouse"
EndSection

Section “Files”
EndSection

Section “Module”
Load “glx”
Load “v4l”
EndSection

Section “InputDevice”
Identifier “Generic Keyboard”
Driver “kbd”
Option “CoreKeyboard”
Option “XkbRules” “xorg”
Option “XkbModel” “pc101″
Option “XkbLayout” “us”
EndSection

Section “InputDevice”
Identifier “Configured Mouse”
Driver “mouse”
Option “CorePointer”
Option “Device” “/dev/input/mice”
Option “Protocol” “ImPS/2″
Option “ZAxisMapping” “4 5″
Option “Emulate3Buttons” “true”
EndSection

Section “Monitor”
Identifier “Digital Panel”
Gamma 1
EndSection

Section “Monitor”
Identifier “Analog Panel”
Gamma 1
Option “RightOf” “Digital Panel”
EndSection

Section “Device”
Identifier “Failsafe Device”
Driver “nvidia”
Boardname “vesa”
Option “AddARGBVisuals” “True”
Option “AddARGBGLXVisuals” “True”
Option “NoLogo” “True”
EndSection

Section “Screen”
Identifier “Default Screen”
Device “Failsafe Device”
Monitor “Digital Panel”
Defaultdepth 24
Option “Monitor-DVI0″ “Digital Panel”
Option “Monitor-VGA0″ “Analog Panel”
Option “AddARGBVisuals” “True”
Option “AddARGBGLXVisuals” “True”
Option “NoLogo” “True”
Option “TwinView” “true”
Option “TwinViewOrientation” “RightOf”# “LeftOf” “Above” “Below” “Clone”
Option “UseEdidFreqs” “True”
Option “MetaModes” “1280×1024,1280×1024″
SubSection “Display”
Depth 24
EndSubSection
Most of the times, xorg.conf is found under /etc/X11/xorg.conf Edit it as a super user, then press Ctrl-Alt-Backspace to restart X windows. And your dual monitors should be up!

My hardware setup

• Nvidia 8400GS 256mb
• 1 Acer 17 inch monitor for VGA
• 1 Samsung 19 inch monitor for DVI

This is the best book I’ve read on software best practices: Steve McConnell’s Code Complete. It is full of gems. It is so good that I decided to summarise it and placed it on my desktop so I could look over it whenever I have the time. So here’s the summary. It’s far better to read the actual book.

Control Structures Issues

• Do expressions use true and false rather than 1 and 0?
• Are boolean values compared to true and false implicitly?
• Are numeric values compared to their test values explicitly?
• Have expressions been simplified by the addition of new boolean variables and the use of boolean functions and decision tables?
• Are boolean expressions stated positively?
• Do pairs of braces balance?
• Are braces used everywhere they’re needed for clarity?
• Are logical expressions fully parenthesized?
• Have tests been written in number-line order?
• Do Java tests uses cases a.equals(b) style instead of a==b when appropriate?
• Are null statements obvious?
• Have nested statements been simplified by retesting part of the conditional, converting to if-then-else or case statements, moving nested code into its own routine, converting to a more object oriented design, or have they been improved in some other way?
• If a routine has a decision count of more than 10, is there a good reason for not designing it?

Loops

Loop selection and creation

• Is a while loop used instead of a for loop if appropriate?
• Was the loop created from the inside out?

Entering the loop

• Is the loop entered from the top?
• Is initialisation code directly before the loop?
• If the loop is an infinite loop or an event loop, is it constructed cleanly rather than using a kludge such as for i = 1 to 9999?
• If the loop is a C++, C, or Java for loop, is the loop header reserved for loop control code?

Inside the loop

• Does the loop use {and} or their equivalent to enclose the loop body and prevent problems arising from improper modifications?
• Does the loop body have something in it? is it nonempty?
• Are housekeeping chores grouped, at the beginning or at the end of the loop?
• Does the loop perform one and only one function, as a well defined routine does?
• Is the loop short enough to view all at once?
• Is the loop nested to 3 levels or less?
• Have long loops contents been moved into their own routine?
• If the loop is long, is it especially clear?

Loop indexes

• If the loop is a for loop, does the code inside it avoid monkeying with the loop index?
• Is a variable used to save important loop-index values rather than using the loop index outside the loop?
• Is the loop index an ordinal type or an enumerated type – not floating point?
• Does the loop index have a meaningful name?
• Does the loop avoid index cross talk?

Exiting the loop

• Does the loop end under all possible conditions?
• Does the loop use safety counters – if you instituted a safety-counter standard?
• Is the loop’s termination condition obvious?
• If break or continue are used, are they correct?

Defensive Programming

General

• Does the routine protect itself from bad data?
• Have you used assertions to document assumptions, including preconditions and post conditions?
• Have assertions been used only to document conditions that should never occur?
• Does the architecture or high-level design specify a specific set of error handling techniques?
• Does the architecture or high level design specify whether error handling should favour robustness or correctness?
• Have barricades been created to contain the damaging effects of errors and reduce the amount of code that has to be concerned about error processing?
• Have debugging aids been used in the code?
• Have debugging aids been installed in such a way that they can be activated or deactivated without a great deal of fuss?
• Is the amount of defensive programming code appropriate – neither too much or too little?
• Have you used offensive programing techniques to make errors difficult to overlook during development?

Exceptions

• Has your project defined a standardized approach to exception handling?
• Have you considered alternatives to using an exception?
• Is the error handled locally rather rather than throwing a nonlocal exception, if possible?
• Does the code avoid throwing exceptions in constructors and destructors?
• Are all exceptions at the appropriate levels of abstraction for the routines that throw them?
• Does each exception include all relevant exception background information?
• Is the code free of empty catch blocks?(Or if an empty catch block truly is appropriate, is it documented?)

Security Issues

• Does the code that checks for bad data input data check for attempted buffer overflows, SQL injection, HTML injection, integer overflows, and other malicious inputs?
• Are all error-return codes checked?
• Are all exceptions caught?
• Do error messages avoid providing information that would help an attacker break into the system?

Design in Construction

Design Practices

• Have you iterated, selecting the best of several attempts rather than the first attempt?
• Have you tried decomposing the system in several different ways to see which way will work best?
• Have you approached the design problem both from the top down and from the bottom up?
• Have you prototyped risky or unfamiliar parts of the system, creating the absolute minimum amount of throwaway code needed to answer specific questions
• Have your design been reviewed, formally or informally by others?
• Have you driven the design to the point that its implementation seems obvious?
• Have you captured your design work using an appropriate technique such as a Wiki, email, flip charts, digital photography, UML, CRC cards, or comments in the code itself?

Design Goals

• Does the design adequately address issues that were identified and deferred at the architectural level?
• Is the design stratified into layers?
• Are you satisfied with the way the program has been decomposed into subsystems, packages and classes?
• Are you satisfied with the ways the classes have been decomposed into routines?
• Are classes designed for minimal interaction with each other?
• Are classes and subsystems designed so that you can use them in other systems?
• Will the program be easy to maintain?
• Is the design lean? Are all its parts strictly necessary?
• Does the design use standard techniques and avoid exotic, hard-to-understand elements?
• Overall, does the design help minimise both accidental and essential complexity?

Fundamental Data Types

Numbers in General

• Does the code avoid magic numbers?
• Does the code anticipate divide by zero errors?
• Are type conversions obvious?
• If variables with 2 different types are used in the same expression, will the expression be evaluated as you intend it to be? you know a float with an int, you know what will happen right?
• Does the code avoid mixed-type comparisons?
• Does the program compile with no warnings?

Integers

• Do expressions that use integer division work the way they’re meant to?
• Do integer expressions avoid integer-overflow problems?

Floating-point numbers

• Does the code avoid additions and subtractions on numbers with greatly different magnitudes?
• Does the code systematically prevent rounding errors?
• Does the code avoid comparing floating point numbers for equality?

Characters and Strings

• Does the code avoid magic characters and strings?
• Are references to strings free of off-by-one errors?
• Does C code treat string pointers and character arrays differently?
• Does C code follow the convention of declaring strings to be length CONSTANT + 1?
• Does C code use arrays of characters rather than pointers, when appropriate?
• Does C code initialise strings to NULLs to avoid endless strings?
• Does C code use strncpy() rather than strcpy()? And strncat() and strncmp()?

Boolean Variables

• Does the program use additional boolean variables to document conditional tests?
• Does the program use additional boolean variables to simplify conditional tests?

Enumerated Types

• Does the program use enumerated types instead of named constants for their improved readability, reliability, and modifiability?
• Does the program use enumerated types instead of boolean variables when a variable’s use cannot be completely be captured with true and false?
• Do tests using enumerated type reserved for invalid values?
• Is the first entry in an enumerated type reserved for invalid?

Named Constants

• Does the program use named constants for data declarations and loop limits rather than magic numbers?
• Have named constants been used consistently? – meaning its not used as named constants in some places and as literals in others?

Arrays

• Are all array indexes within the bonds of the array?
• Are all array references free of off-by-one errors?
• Are all subscripts on multidimensional arrays in the correct order?
• In nested loops, is the correct variable used as the array subscript, avoiding loop index cross talk?

Creating Types

• Does the program use a different type for each kind of data that might change?
• Are type names oriented toward the real-world entities the types represent rather than toward programming language types?
• Are the types names descriptive enough to help document data declarations?
• Have you avoided redefining predefined types?
• Have you considered creating a new class rather than simply redefining a type?

General Issues in using variables

Initialising variables

• Does each routine check input parameters for validity?
• Does the code declare variables close to where they’re first used?
• Does the code initialise variables as they’re declared, if possible?
• Does the code initialise variables close to where they’re first used, if it isn’t possible to declare and initialise them at the same time?
• Are counters and accumulators initialised properly and, if necessary, reintialised each time they are used?
• Are variables reinitialised properly in code that’s being executed repeatedly?
• Does the code compile with no warnings from the compiler?
• If your language uses implicit declarations, have you compensated for the problems they cause?

Other general issues in using data

• Do all variables have the smallest possible scope possible?
• Are all references to variables as close together as possible, both from each reference to a variable to the next reference and in total live time?
• Do control structures correspond to the data types?
• Are all declared variables being used?
• Are all variables bound at appropriate times – that is, are you striking a conscious balance between the flexibility of late binding and the increased complexity associated with late binding?
• Does each variable have one and only one purpose?
• Is each variable’s meaning explicit, with no hidden meanings?

High Quality Routines

Big Picture Issues

• Is the reason for creating the routine sufficient?
• Have all parts of the routine that would benefit from being put into routines of their own been put into routines of their own?
• Is the routine’s name a strong, clear verb-plus-object name for a procedure or a description of the return value for a function?
• Does the routine’s name describe everything the routine does?
• Have you established naming conventions for common operations?
• Does the routine have strong, functional cohesion – doing one and only one thing and doing it well?
• Do the routines have loose coupling – are the routine’s connections to other routines small, intimate, visible, and flexible?
• Is the length of the routine determined naturally by its function and logic, rather than by an artificial coding standard

Parameter- Passing issues

• Does the routine’s parameter list, taken as a whole, present a consistent interface abstraction?
• Are the routine’s parameters in a sensible order, including matching the order of parameters in similar routines?
• Are interface assumptions documented?
• Does the routine have 7 or fewer parameters?
• Is each input parameter used?
• Is each output parameter used?
• Does the routine avoid using input parameters as working variables?
• If the routine is a function, does it return a valid value under all possible circumstances?

Naming Variables

General Naming Considerations

• Does the name fully and accurately describe what the variable represents?
• Does the name refer to the real world problem rather than to the programming language solution?
• Is the name long enough that you don’t have to puzzle it out?
• Are computed value qualifiers, if any, at the end of the name?
• Does the name use Count or Index instead of Num?

Naming specific kinds of Data

• Are loop index names meaningful (something other than i, j, or k if the loop is more than one or two lines long or is nested)?
• Have all ‘temporary variables’ been renamed to something more meaningful?
• Are boolean variables names so that their meanings when they’re true are clear?
• Do enumerated-type names include a prefix or suffix that indicates the category-for example, Color_ for Color_red, color_green, color_blue and so on
• Are named constants named for the abstract entities they represent rather than the numbers they refer to?

Naming Conventions

• Does the convention distinguish among local, class, and global data?
• Does the convention distinguish among type names, named constants, enumerated types and variables?
• Does the convention identify input-only parameters to routines in languages that don’t enforce them?
• Is the convention as comparable as possible with standard conventions for the language?
• Are names formatted for readability?

Short Names

• Does the code use long names(unless it’s necessary to use short ones?)?
• Does the code avoid abbreviations that only save one character?
• Are all words abbreviated consistently?
• Are the names pronounceable?
• Are names that could be misread or mispronounced avoided?
• Are short names documented in translation tables?

Common Naming Problems: Have you avoided….

• Names that are misleading?
• Names with similar meaning?
• Names that are different by one or two characters?
• Names that sound familiar?
• Names that use numerals?
• Names intentionally mispelled to make them shorter?
• Names that are commonly misspelled in English?
• Names that conflict with standard library routines names or with predefined variable names?
• Totally arbitrary names?
• Hard to read characters?

Checklist: Summary of Refactoring

Data Level Refactoring

• Replace a magic number with a named constant
• Rename a variable with a clearer or more informative name
• Move an expression inline
• Replace an expression with a routine
• Introduce an intermediate variable
• Convert a multiuse variable to a multiple single-use variables
• Use a local variable for local purposes rather than a parameter
• Convert a data primitive to a class
• Convert a set of type codes to a class or an enumeration
• Convert a set of type codes to a class with subclasses
• Change an array to an object
• Encapsulate a collection
• Replace a traditional record with a data class

Statement Level Refactoring

• Decompose a boolean expression
• Move a complex boolean expression into a well-named boolean function
• Consolidate fragments that are duplicated within different parts of a conditional
• Use break or return instead of a loop control variable
• Return as soon as you know the answer instead of assigning a return value within nested if-then-else statements
• Replace conditionals(especially repeated case statements) with polymorphism
• Create and use null objects instead of testing for null values

Routine Level refactoring

• Extract a routine
• Move a routine’s code inline
• Convert a long routine to a class
• Substitute a simple algorithm for a complex algorithm
• Add a parameter
• Remove a parameter
• Separate query operations from modification operations
• Combine similar routines by parameterising them
• Separate routines whose behaviour depends on parameters passed in
• Pass a whole object rather than specific fields
• Pass specific fields rather than a whole object
• Encapsulate downcasting

Class Implementation Refactoring

• Change value objects to reference objects
• Change reference objects to value objects
• Replace virtual routines with data initializations
• Change member routine or data placement
• Extract specialised code into a subclass
• Combine similar code into a superclass

Class Interface refactorings

• Move a routine to another class
• Convert one class to two
• Eliminate a class
• Hide a delegate
• Remove a middleman
• Replace inheritance with delegation
• Replace delegation with inheritance
• Introduce a foreign routine
• Introduce an extension class
• Encapsulate an exposed member variable
• Remove Set() routines for fields that cannot be changed
• Hide routines that are not intended to be used outside the class
• Encapsulate unused routines
• Collapse a superclass and subclass if their implementations are very similar

System Level Refactorings

• Create a definitive reference source for data you can’t control
• Change unidirectional class association to bidirectional class association
• Change bidirectional class association to unidirectional class association
• Provide a factory routine rather than a simple constructor
• Replace error codes with exceptions or vice versa

Organising Straight line code

• Does the code make dependencies among statements obvious?
• Do the names of routines make dependencies obvious?
• Do parameters to routines make dependencies obvious?
• Do comments describe any dependencies that would otherwise be unclear?
• Have housekeeping variables been used to check for sequential dependencies in critical sections of the code?
• Does the code read from top to bottom?
• Are related statements grouped together?
• Have relatively independent groups of statements been moved into their own routines?

Table driven Methods

• Have you considered table-driven methods as an alternative to complicated logic?
• Have you considered table driven methods as an alternative to complicated inheritance structures?
• Have you considered storing the table’s data externally and reading it at run time so that the data can be modified without changing code?
• If the table cannot be accessed directly via a straightforward array index, have you put the access-key calculation into a routine rather than duplicating the index calculation in the code?

Unusual Control Structures

return

• Does each routine use return only when necessary?
• Do returns enhance readability?

Recursion

• Does the recursion routine include code to stop the recursion?
• Does the routine use a safety counter to guarantee that the routine stops?
• Is recursion limited to one routine?
• Is the routine’s depth of recursion within the limits imposed by the size of the program’s stack?
• Is recursion the best way to implement the routine? Is it better than simple iteration?

goto

• Are gotos used only as a last resort, and then only to make code more readable and maintanable?
• If a goto is used for the sake of efficiency, has the gain in efficiency been measured and documented?
• Are gotos limited to one label per routine?
• Do all gotos go forward, not backward?
• Are all goto labels used?

Unusual Data Types

Structures

• Have you used structures instead of naked variables to organise and manipulate groups of related data?
• Have you considered creating a class as an alternative to using structure?

Global data

• Are all variables local or of class scope unless they absolutely need to be global?
• Do variable naming convention differentiate among local, class and global data?
• Are all variables documented?
• Is the code free of pseudo-global data – mammoth objects containing a mishmash of data that’s passed to every routine?
• Are access routines used instead of global data?
• Do access routines provide a level of abstraction beyond the underlying data type implementations?
• Are all related access routines at the same level of abstraction?

Pointers

• Are pointer operations isolated in routines?
• Are pointer references valid, or could the pointer be dangling?
• Does the code check pointers for validity before using them?
• Is the variable that the pointer references checked for validity before it’s used?
• Are pointers set to null after they’re freed?
• Does the code use all the pointer variables needed for the sake of readability?
• Are pointers in linked list freed in the right order?
• Does the program allocate a reserve parachute of memory so that it can shut down gracefully if it runs out of memory?
• Are pointers used only as a last resort, when no other method is available?

Using Conditionals

if-then Statements

• Is the nominal path through the code clear?
• Do if-then tests branch correctly on equality?
• Is the else clause present and documented?
• Is the else clause correct?
• Are the if and else clauses used correctly – not reversed?
• Does the normal case follow the if rather than the else?

if-then-else-if chains

• Are complicated tests encapsulated in boolean function calls?
• Are the most common cases tested first?
• Are all cases covered?
• Is the if-then else-if chain the best implementation – better than a case statement?

Case statements

• Are cases ordered meaningfully?
• Are the actions for each case simple – calling other routines if necessary?
• Does the case statement test a real variable, not a phony one that’s made up solely to use and abuse the case statement?
• Is the use of the default clause legitimate?
• Is the default clause used to detect and report unexpected cases?
• In C, C++, Java, does the end of each case have a break?
• Use retesting to refactor nested if-else

Abstract Data Types

• Have you thought of the classes in your program as abstract data types and evaluated their interfaces from that point of view?

Abstraction

• Does the class have a central purpose?
• Is the class well named, and does its name describe its central purpose?
• Does the class’s interface present a consistent abstraction?
• Does the class’s interface make obvious how you should use the class?
• Is the class’s interface abstract enough that you don’t have to think about how its services are implemented? Can you treat the class as a black box?
• Are the class’s services complete enough that other classes don’t have to meddle with its internal data?
• Has unrelated information been moved out of the class?
• Have you thought about subdividing the class into component classes, and have you subdivided it as much as you can?
• Are you preserving the integrity of the class’s interface as you modify the class?

Encapsulation

• Does the class minimize accessibility to its members?
• Does the class avoid exposing member data?
• Dos the class hide its implementation details from other classes as much as the programming language permits?
• Does the class avoid making assumptions about its users, including its derived classes?
• Is the class independent of other classes? iS it loosely coupled?

Inheritance

• Is inheritance used only to model ‘is a’ relationships – that is, do derived classes adhere to the Liskov Substitution Principle?
• Does the class documentation describe the inheritance strategy?
• Do derived classes avoid overidding non-overridable routines?
• Are common interfaces, data, and behaviour as high as possible in the inheritance tree?
• Are inheritance trees fairly shallow?
• Are all data members in the base class private rather than protected?

Other Implementation issues

• Does the class contain about 7 data members or fewer?
• Does the class minimise direct and indirect routine calls to other classes?
• Does the class collaborate with other classes only to the extent absolutely necessary?
• Is all member data initialised in the constructor?
• Is the class designed to be used as deep copies rather than shallow copies unless there’s a measured reason to create shallow copies?

Language-Specific Issues

• Have you investigated the language-specific issues for classes in your specific programming language?