The Daily Scrum Exercise Program 38
Yesterday I was in a chicken in a scrum meeting. I made the observation that the Daily Scrum was called that and not a “Stand-up meeting.”
Standing up is a mechanism for making the meeting fast. Someone mentioned that they actually used a weight in a previous team. You hand to hold the weight while talking.
This logically leads to a workout program. You start with a weight and, as people get used to it, you increase it. Start with 5 pounds, work up to 45. The problem with this is you’ll end up with inconsistent development. You’ll have a bunch of developers with strong, wide upper bodies but weak, pipe-like legs.
So the next logical step is to rotate the exercises used while reporting on what you did, what you’re going to do and roadblocks.
So maybe something like:- Monday, upper body, dumbbells held out in front or to the side (depending on where you need more definition.
- Tuesday, cardio, jog in place, kicking your knees up high.
- Wednesday, lower body, squat with your feet pointing at 45 degrees and legs apart.
- Thursday, cardio, jog in place, kicking your feet into your rear
- Friday, mid section, alternatively lift your knees to the opposite side of your body while twisting to the size of leg you are lifting.
You get the idea. Of course, you’d customize the workouts to at least the team or maybe even the developer.
I’d like to be on that team!
Another Refactoring Exercise: Design Patterns Recommended!-) 45
Well the previous exercise was fun so here’s another one. The following code is taken from the same problem, an RPN calculator. Originally, the interface of the calculator was “wide”; there was a method for each operator. E.g., plus(), minus(), factorial(). In an effort to fix this, a new method, perform(String operatorName) was added and ultimately the interface was fixed gradually to remove those methods.
Changing he calculator API in this way is an example of applying the open/closed principle. However, the resulting code is just a touch ugly (I made it a little extra ugly just for the hack [sic] of it). This code as written does pass all of my unit tests.
Before the code, however, let me give you a little additional information:- I changed the calculator to use BigDecimal instead of int
- Right now the calculator has three operators, +, – !
- Eventually, there will be many operators (50 ish)
- Right now there are only binary and unary operators, however there will be other kinds: ternary, quaternary, and others such as sum the stack and replace just the sum on the stack or calculate the prime factors of the top of the stack so take one value but push many values
So have a look at the following code and then either suggest changes or provide something better. There’s a lot that can be done to this code to make it clearer and make the system easier to extend.
The Perform Method
public void perform(String operatorName) {
BigDecimal op1 = stack.pop();
if ("+".equals(operatorName)) {
BigDecimal op2 = stack.pop();
stack.push(op1.add(op2));
currentMode = Mode.inserting;
} else if ("-".equals(operatorName)) {
BigDecimal op2 = stack.pop();
stack.push(op2.subtract(op1));
currentMode = Mode.inserting;
} else if ("!".equals(operatorName)) {
op1 = op1.round(MathContext.UNLIMITED);
BigDecimal result = BigDecimal.ONE;
while (op1.compareTo(BigDecimal.ONE) > 0) {
result = result.multiply(op1);
op1 = op1.subtract(BigDecimal.ONE);
}
stack.push(result);
} else {
throw new MathOperatorNotFoundException();
}
}Unlike the last example, I’ll provide the entire class. Feel free to make changes to this class as well. However, for now focus on the perform(...) method.
One note, Philip Schwarz recommended a change to what I proposed to avoid the command/query separation violation. I applied his recommendation before posting this updated version.
The Whole Class
package com.scrippsnetworks.calculator;
import java.math.BigDecimal;
import java.math.MathContext;
public class RpnCalculator {
private OperandStack stack = new OperandStack();
private Mode currentMode = Mode.accumulating;
enum Mode {
accumulating, replacing, inserting
};
public RpnCalculator() {
}
public void take(BigDecimal value) {
if (currentMode == Mode.accumulating)
value = determineNewTop(stack.pop(), value);
if (currentMode == Mode.replacing)
stack.pop();
stack.push(value);
currentMode = Mode.accumulating;
}
private BigDecimal determineNewTop(BigDecimal currentTop, BigDecimal value) {
BigDecimal newTopValue = currentTop;
String digits = value.toString();
while (digits.length() > 0) {
newTopValue = newTopValue.multiply(BigDecimal.TEN);
newTopValue = newTopValue.add(new BigDecimal(Integer.parseInt(digits
.substring(0, 1))));
digits = digits.substring(1);
}
return newTopValue;
}
public void enter() {
stack.dup();
currentMode = Mode.replacing;
}
public void perform(String operatorName) {
BigDecimal op1 = stack.pop();
if ("+".equals(operatorName)) {
BigDecimal op2 = stack.pop();
stack.push(op1.add(op2));
currentMode = Mode.inserting;
} else if ("-".equals(operatorName)) {
BigDecimal op2 = stack.pop();
stack.push(op2.subtract(op1));
currentMode = Mode.inserting;
} else if ("!".equals(operatorName)) {
op1 = op1.round(MathContext.UNLIMITED);
BigDecimal result = BigDecimal.ONE;
while (op1.compareTo(BigDecimal.ONE) > 0) {
result = result.multiply(op1);
op1 = op1.subtract(BigDecimal.ONE);
}
stack.push(result);
} else {
throw new MathOperatorNotFoundException();
}
}
public BigDecimal getX() {
return stack.x();
}
public BigDecimal getY() {
return stack.y();
}
public BigDecimal getZ() {
return stack.z();
}
public BigDecimal getT() {
return stack.t();
}
}Refactoring Exercise 76
So I’ve written a somewhat ugly method with the intent of having people clean it up. Want to give it a try? Post your results and then I’ll show what I ended up doing in a few days (or after the activity dies down).
It’s in Java, but feel free to post in other languages. I’d be interested in seeing something in whatever language Michael Feathers happens to be deeply studying right now!-)
Oh, and if you feel like going “overboard” and using a few design patterns just because you can, I’d like to see that as well.
Here it is:
public void take(int v) {
if (currentMode == Mode.accumulating) {
int digits = (int)Math.pow(10, (int)Math.log10(v) + 1);
int x = stack.pop();
x *= digits;
x += v;
stack.push(x);
}
if (currentMode == Mode.replacing) {
stack.pop();
stack.push(v);
currentMode = Mode.accumulating;
}
if (currentMode == Mode.inserting) {
int top = stack.peek();
stack.push(top);
stack.push(v);
currentMode = Mode.accumulating;
}
}