`
| |
|
Sunday, July 8th, 2012
| A |
Acceptance Criteria/Test, Automation, A/B Testing, Adaptive Planning, Appreciative inquiry |
| B |
Backlog, Business Value, Burndown, Big Visible Charts, Behavior Driven Development, Bugs, Build Monkey, Big Design Up Front (BDUF) |
| C |
Continuous Integration, Continuous Deployment, Continuous Improvement, Celebration, Capacity Planning, Code Smells, Customer Development, Customer Collaboration, Code Coverage, Cyclomatic Complexity, Cycle Time, Collective Ownership, Cross functional Team, C3 (Complexity, Coverage and Churn), Critical Chain |
| D |
Definition of Done (DoD)/Doneness Criteria, Done Done, Daily Scrum, Deliverables, Dojos, Drum Buffer Rope |
| E |
Epic, Evolutionary Design, Energized Work, Exploratory Testing |
| F |
Flow, Fail-Fast, Feature Teams, Five Whys |
| G |
Grooming (Backlog) Meeting, Gemba |
| H |
Hungover Story |
| I |
Impediment, Iteration, Inspect and Adapt, Informative Workspace, Information radiator, Immunization test, IKIWISI (I’ll Know It When I See It) |
| J |
Just-in-time |
| K |
Kanban, Kaizen, Knowledge Workers |
| L |
Last responsible moment, Lead time, Lean Thinking |
| M |
Minimum Viable Product (MVP), Minimum Marketable Features, Mock Objects, Mistake Proofing, MOSCOW Priority, Mindfulness, Muda |
| N |
Non-functional Requirements, Non-value add |
| O |
Onsite customer, Opportunity Backlog, Organizational Transformation, Osmotic Communication |
| P |
Pivot, Product Discovery, Product Owner, Pair Programming, Planning Game, Potentially shippable product, Pull-based-planning, Predictability Paradox |
| Q |
Quality First, Queuing theory |
| R |
Refactoring, Retrospective, Reviews, Release Roadmap, Risk log, Root cause analysis |
| S |
Simplicity, Sprint, Story Points, Standup Meeting, Scrum Master, Sprint Backlog, Self-Organized Teams, Story Map, Sashimi, Sustainable pace, Set-based development, Service time, Spike, Stakeholder, Stop-the-line, Sprint Termination, Single Click Deploy, Systems Thinking, Single Minute Setup, Safe Fail Experimentation |
| T |
Technical Debt, Test Driven Development, Ten minute build, Theme, Tracer bullet, Task Board, Theory of Constraints, Throughput, Timeboxing, Testing Pyramid, Three-Sixty Review |
| U |
User Story, Unit Tests, Ubiquitous Language, User Centered Design |
| V |
Velocity, Value Stream Mapping, Vision Statement, Vanity metrics, Voice of the Customer, Visual controls |
| W |
Work in Progress (WIP), Whole Team, Working Software, War Room, Waste Elimination |
| X |
xUnit |
| Y |
YAGNI (You Aren’t Gonna Need It) |
| Z |
Zero Downtime Deployment, Zen Mind |
Posted in Agile | No Comments »
Saturday, June 13th, 2009
Recently Brett Schuchert from Object Mentor has started posting code snippets on his blog and inviting people to refactor it. Similar to the Daily Refactoring Teaser that I’m conducting at Directi. (I’m planning to make it public soon).
Following is my refactored solution (take 1) to the poorly written code.
Wrote some Acceptance Test to understand how the RpnCalculator works:
Then I updated the perform method to
@Deprecated
public void perform(final String operatorName) {
perform(operators.get(operatorName));
}
public void perform(final Operator operator) {
operator.eval(stack);
currentMode = Mode.inserting;
} |
@Deprecated
public void perform(final String operatorName) {
perform(operators.get(operatorName));
}
public void perform(final Operator operator) {
operator.eval(stack);
currentMode = Mode.inserting;
} Notice I’ve deprecated the old method which takes String. I want to kill primitive obsession at its root.
Had to temporarily add the following map (this should go away once our deprecated method is knocked off).
private static Map operators = new HashMap() {
{
put("+", Operator.ADD);
put("-", Operator.SUBTRACT);
put("!", Operator.FACTORIAL);
}
@Override
public Operator get(final Object key) {
if (!super.containsKey(key)) {
throw new MathOperatorNotFoundException();
}
return super.get(key);
}
}; |
private static Map operators = new HashMap() {
{
put("+", Operator.ADD);
put("-", Operator.SUBTRACT);
put("!", Operator.FACTORIAL);
}
@Override
public Operator get(final Object key) {
if (!super.containsKey(key)) {
throw new MathOperatorNotFoundException();
}
return super.get(key);
}
}; Defined various Operators
private static abstract class Operator {
private static final Operator ADD = new BinaryOperator() {
@Override
protected int eval(final int op1, final int op2) {
return op1 + op2;
}
};
private static final Operator SUBTRACT = new BinaryOperator() {
@Override
protected int eval(final int op1, final int op2) {
return op2 - op1;
}
};
private static final Operator FACTORIAL = new UnaryOperator() {
@Override
protected int eval(final int op1) {
int result = 1;
int currentOperandValue = op1;
while (currentOperandValue > 1) {
result *= currentOperandValue;
--currentOperandValue;
}
return result;
}
};
public abstract void eval(final OperandStack stack);
} |
private static abstract class Operator {
private static final Operator ADD = new BinaryOperator() {
@Override
protected int eval(final int op1, final int op2) {
return op1 + op2;
}
};
private static final Operator SUBTRACT = new BinaryOperator() {
@Override
protected int eval(final int op1, final int op2) {
return op2 - op1;
}
};
private static final Operator FACTORIAL = new UnaryOperator() {
@Override
protected int eval(final int op1) {
int result = 1;
int currentOperandValue = op1;
while (currentOperandValue > 1) {
result *= currentOperandValue;
--currentOperandValue;
}
return result;
}
};
public abstract void eval(final OperandStack stack);
} Declared two types of Operators (BinaryOperator and UnaryOperator) to avoid duplication and to make it easy for adding new operators.
public static abstract class BinaryOperator extends Operator {
@Override
public void eval(final OperandStack s) {
s.push(eval(s.pop(), s.pop()));
}
protected abstract int eval(int op1, int op2);
} |
public static abstract class BinaryOperator extends Operator {
@Override
public void eval(final OperandStack s) {
s.push(eval(s.pop(), s.pop()));
}
protected abstract int eval(int op1, int op2);
} and
public static abstract class UnaryOperator extends Operator {
@Override
public void eval(final OperandStack s) {
s.push(eval(s.pop()));
}
protected abstract int eval(int op1);
} |
public static abstract class UnaryOperator extends Operator {
@Override
public void eval(final OperandStack s) {
s.push(eval(s.pop()));
}
protected abstract int eval(int op1);
}
Posted in Agile, Design, Java, Programming, Testing | No Comments »
|
