Ben Arciszewski Development

Project Euler Problem 10 in Scala

2012-01-19T14:05:00.000-08:00

This is 10 in a series. The previous post is at, Project Euler Problem 9 in Scala.

Problem 10 on project Euler is:

The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
Find the sum of all the primes below two million.

Problem 10 posed an interesting issue for me. I came up with a solution I thought would work well right away, but I couldn't seem to get the correct answer. After poring over my code and playing around, I finally found my issue - my isPrime function had an error in it, causing me to be off by 2.

What is interesting about this scenario is that I've been using that same function for lots of different problems, but since the function was only broken for the number 2, it didn't matter in those. If I had some sort of test that say, verified the function against a random set of prime numbers, I would have found the issue much sooner. This speaks to how important it is to test even seemingly working things whenever you can.

Another by product of the issue is that I did a little more research on calculating prime numbers. Wikipedia had a nice article about the Sieve of Eratosthenes. This gave me a much better understanding of how it works. While I am not changing my code (yet) to use a sieve, it was certainly valuable to learn more about how its done.

Well, I did manage to finish it, and here is my solution. Enjoy:

object Problem10 {
def main(args: Array[String]): Unit = {
var holder : BigDecimal = new BigDecimal(new java.math.BigDecimal("0"));
(2 to 1999999).filter{next => val prime = isPrime(next);if(prime){holder = holder + new java.math.BigDecimal(new Integer(next).toString())};prime}
println(holder)
}

/**
* Brute force method. Perhaps a better method
* can be implemented here?
*/
def isPrime(number: Long) : Boolean = {
if(number == 2)
return true
if(number%2==0 || number % 3==0)
return false;
val sqrt:Int = Math ceil (Math sqrt number) intValue;
(true /: (3 to sqrt))((isPrime, next) => {
if(number % next == 0)
return false
isPrime
})
}
}

Now that I've completed #10, I get a Euler award. I have become a 'Decathlete' for finishing 10 problems in a row.

And with that, I think I will finish blogging about my Euler solutions. I still plan on working through the problems, but I think I've worn out my Euler solution posts and will move on to some other interesting topics.

StudyBlue Flashcards nominated for Best App Ever Awards

2012-01-14T08:40:00.000-08:00

I've been working for StudybBlue for about 9 months now. If you don't know what StudyBlue is, it's a fantastic place for students to create online flashcards, study those flashcards, create quizzes from them, and track their progress. In other words, its a product that makes students more efficient and effective.

StudyBlue is more than a Web site, however. It also produces native flashcard applications for iPhone and Android to allow students to study their cards on the go. The goal for our company is to create a total user experience and we invest a lot of time, effort and energy into our application designs. Apparently, that hard work is starting to payoff.

We were recently notified that we were nominated for the the Best App Ever Awards. While its not the biggest award or the best known, the interesting thing about it is that it is a user-driven award. It means that one of our users nominated our app and other users will be voting on it. In my mind this is one of the highest compliments StudyBlue could be paid. After all, it doesn't really matter what anyone thinks but your users, and it seems that we're keeping at least some of ours pretty happy.

If you are a student and use StudyBlue, please vote for our app. There would be nothing more satisfying than knowing that our users think we're the Best App Ever.
Vote for STUDYBLUE Flashcards for Best High School Student App

Project Euler Problem 9 in Scala

2012-01-14T07:58:00.000-08:00

This is 9 in a series. The previous post is at, Project Euler Problem 8 in Scala.

I've still been (slowly) working my way through the Project Euler Problems. The next one is problem 9 which reads:

A Pythagorean triplet is a set of three natural numbers, a b c, for which,
a^2 + b^2 = c^2
For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product abc.

For this problem, I didn't use anything fancy. Two for-comprehensions and basic math produced the solution in short order. The only thing to mention about this solution is that it actually finds the solution twice since I'm iterating1 to 998 twice. I considered trying to optimize this, however, it runs plenty fast. Since my goal in solving these isn't to come up with the fastest solution, but to come up with a solution that has no mutable state, I have met my goal. Therefore, I present you the solution to problem 9:

object Problem9 {
def main(args: Array[String]): Unit = {
for (a <- 1 to 998) {
for (b <- 1 to 998) {
val c = 1000 - (a + b)
if ((a * a) + (b * b) == (c * c)) {
println("the triplet is " + a + " " + b + " " + c)
println("the product is " + (a * b * c))
}
}
}
}
}

I think that's all for this one. Problem 10 is in the hopper...

Project Euler Problem 8 in Scala

2012-01-09T07:00:00.000-08:00

This is 8 in a series. The previous post is at, Project Euler Problem 5 in Scala.

So we saw problem 6 solved with a 'one-liner'. Then we moved on to problem 7 and I had to have a while loop and control variables, which really disappointed me. Problem 8, however, was not only satisfying, but allowed me to explore even more features of Scala.

Before I get into the actual problem, I want to comment on my language progress. My 'native tongue' so-to-speak, is Java. I use Java at work and have for 12 years. I expect it will be paying the bills for years to come. We can debate the merits of Java as a language, and I'm sure every one reading this has an opinion about it, good or bad. Regardless of opinion, I am most productive in Java. Period. Why? Because I have used it so much, and am so familiar with the syntax and libraries that the language 'gets out of the way'. I don't have to think about anything but what the code is intending to do. This makes me very productive. I'm finding that its taking a little longer to get to the point where I feel like the language has stepped back with Scala. Part of it is the rather verbose API documentation, which, just seems to tell me too much and doesn't allow me to get right to 'how do I use this'. Part of it is that Scala has a lot more power and expressiveness than Java, and that takes more time to learn. At any rate, my Scala skills are slowing improving.

Now, on to Problem 8:

Find the greatest product of five consecutive digits in the 1000-digit number.

73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450

This problem is pretty straight forward. Iterate the string literal and multiply sets of 5 numbers together. Find the largest of those numbers and return it. Now, in Java, this would take a couple of for loops, a String, possibly a string buffer, some variables to store the results, and an ugly System.out.println....

Not so in Scala. The Collections facilities actually allowed me to solve this in one line, without any mutable state. No, really, I mean it. Check this out:

object Problem8 {
def main(args: Array[String]): Unit = {
val totalDigits = """[omitted the big string literal here, but you can add it back if you want to run the code...]"""
println((for (i <- 5 to totalDigits.length()) yield totalDigits slice (i - 5, i)) collect {
case i =>
i.foldLeft(1)((product: Int, nextChar) => {
(nextChar asDigit) * product
})
} max)
}
}

Okay, its a 'one-liner' but there is a lot going on there. Let's deconstruct the statement. First, we see that everything is wrapped in a 'println', which is nice shorthand in Scala for System.out.println. The second thing we see is that the result of the statement 'max' is what will be printed. max is a collection function. A couple of things to note. Since max takes no arguments, we drop the '()'. Since Scala can infer its a method call, we can even omit the '.'. Now let's look at the rest of the code, shall we?

Let's go back to the beginning of the statement. We are using the 'for' comprehension. To be honest, the 'for' comprehension in Scala is much more powerful than the 'for' loop in other languages I've used. You can see, we are going to iterate 5 to the length of the string. For each iteration, we are going to yield the slice if i-5 and i. slice is a nice string operator in Scala. Essentially, we're getting 5 characters. In turn we are going to collect the results of folding (There's that foldLeft again....) the 5 character Sequence. The result of all of these will be a Sequence of Int values, on which we call 'max' function.

Boy, that was a mouthful. It was cool, though, wasn't it? It took a few minutes for me to weed through the API and figure out the syntax for this, but in the end, it is a succinct and stateless solution....

On to the next one...

Project Euler Problem 7 in Scala

2012-01-05T07:00:00.000-08:00

This is 7 in a series. The previous post is at, Project Euler Problem 6 in Scala.

After a very successful solution to problem 6, we get to problem 7. I couldn't figure out how to remove all mutable state from this solution. The issue is that we have to find the 10,001st number which means that we do not know how long we have to iterate. I used a while loop here, and it seems to work fine. Perhaps someone has a solution without a while loop?

Here's Project Euler problem 7:

By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
What is the 10,001st prime number?

object Problem7 {

def main(args: Array[String]): Unit = {
var counter = 1L;
var number = new BigDecimal(new java.math.BigDecimal("0"));
var currentNum = 1l;

while(counter <= 10001) {
if(isPrime(currentNum)) {
number = new BigDecimal(new java.math.BigDecimal(currentNum));
counter = counter + 1;
}
currentNum = currentNum + 1;
}
println("10001st prime " + number);
}

/**
* Brute force method. Perhaps a better method
* can be implemented here?
*/
def isPrime(number: Long) : Boolean = {
if(number%2==0)
return false;
val sqrt:Int = Math ceil (Math sqrt number) intValue;
(true /: (3 to sqrt))((isPrime, next) => {
if(number % next == 0)
return false
isPrime
})
}
}

You should note that I've cleaned up my isPrime method. I noticed that it wasn't very functionally written, so I changed it to use a fold left (By the way, foldLeft is turning out to be one of the handiest Scala constructs on the planet.) I am now very comfortable with the isPrime method, at least as a brute force solution.

Project Euler Problem 6 in Scala

2011-12-31T13:26:00.000-08:00

This is 6 in a series. The previous post is at, Project Euler Problem 5 in Scala.

Problem 6 was particularly satisfying for me. You will see why when you see the code below. I think the code deserves some discussion because it takes advantage of some pretty nice Scala features.

Project Euler problem 6 reads:

The sum of the squares of the first ten natural numbers is, 12 + 22 + ... + 102 = 385The square of the sum of the first ten natural numbers is, (1 + 2 + ... + 10)2 = 552 = 3025Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025-385 = 2640. Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.

So reading this question, we want to come up with an algorithm that iterates all the numbers 1..100. During each iteration, we want to capture the sum of the squares, and the sum of the number. Finally, we want to square the sum of the number and subtract the two values.

Using some of Scala's syntactic sugar and its excellent functional handling we get:

object Problem6 {

  def main(args: Array[String]): Unit = {

    val results = ((0, 0) /: (1 to 100))((i, s) => {

      (i._1 + (s * s), i._2 + s)

})

    println((results._2 * results._2) - results._1);

}

}

If we take out the object definition and main method call, you can see that this is a two-liner (I could make it a one-liner, but I think that would sacrifice readability). Once again, I am using the foldeLeft operator (/:). This time, however, I am folding left on a sequence of values instead of a single value. Because of this, you see the (0,0) declaration. Scala also infers this type inside the body of the function, so I am storing to values i._1 and i._2. Finally, we square the sums and subtract the sum of the squares.

Note that I actually multiplied results._2 by itself. the '^' operator in Scala seems to work differently than I expected, and was giving me weird results. I might have to look into that, but for now, we have a very succinct solution to this problem.

Project Euler Problem 5 in Scala

2011-12-27T08:04:00.000-08:00

This is 4 in a series. The previous post is at, Project Euler Problem 4 in Scala.

Here we are, arriving at problem 5 from the Project Euler site. For those of you that may have stumbled in on these posts, and haven't read why I am doing this, you might want to go back to the beginning and find out here. The long and short of it is, I'm using these exercises as a way to solve fun problems while learning a new language (Scala). I've added a twist to try an help me think in a functional way - for each solution, I want my final version of code to have the least amount of mutable state possible.

As it turns out, this has been a fun and enlightening exercise, and I'm only a few problems in! If you've read any of my previous posts, you know that they were concentrating on turning my Java-like, OO style code into more functional style code without any mutable state. I must be improving slightly, because this post is going to focus more on creating the right algorithm than on functional vs. OO style. Without further adieu, I present to you, Project Euler Problem 5:

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.
What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?

Well, my first solution, as always, was a brute-force way to solve the problem. I will simply find my 'upper limit' value, which is the product of all the numbers 11 to 20 (A very large number), and iterate all values up to that number, checking if each number has a remainder when divided by any of the numbers 11 to 20. Simple right? It was simple, but it also takes 2 minutes to run on my Lenovo ThinkPad running an Intel Dual Core i7 CPU @ 2.67GHz. Here's the implementation:

object Problem5 {

def divisible(number: BigDecimal): Boolean = {

for (i <- 11 to 20 ) {

if (number.remainder(new BigDecimal(i)).longValue > 0)

return false

}

return true

}

def main(args: Array[String]): Unit = {

var start = System.currentTimeMillis

val upperBound = (new BigDecimal(1) /: (11 to 20))(_ multiply new BigDecimal(_))

println("Upper bound is " + upperBound)

var i = 1

for (i <- 20 to upperBound.intValue() if divisible(new BigDecimal(i))) {

println("Smallest # divisible by 1 .. 20 is " + i);

println("Run time seconds " + ((System.currentTimeMillis()-start)/1000));

return

}

After I solved the problem, I started thinking about it more. Iterating through every number seems wasteful, doesn't it? After all, there are a lot of numbers that will not evenly divide by ANY number in that sequence. So, I thought, I should really be iterating through a list of numbers that is the product of at least ONE of the numbers in the sequence. If I selected, 15, for instance, I could iterate through the list: (15, 30, 45, 60...). Of course, If I think about that more, the most efficient number to use will be the highest number in the list, 20. So, I created a new version of the code that iterates in increments of 20, and then checks to see if 11 to 19 are also divisible. This runs on my machine in about 2 seconds, making this about 60 times faster:

object Problem5 {
/*Let's skin this cat a different way...*/

def main(args: Array[String]): Unit = {
for (i <- 1 to 320000000) {
val mot = i * 20;
val divisibleByAll = fitsAll(mot)
if (divisibleByAll) {
println("Smallest is " + mot);
return
}
}

def fitsAll(number: Int): Boolean = {
for (i <- 11 to 19) {
if (number % i > 0)
return false;
}
return true
}
}
}

I think I can further improve this code with some of Scala's features. For instance, I think I can iterate the sequence 1 to 320000000 by increments of 20 without needing the variable mot. Notince, though, that I do not have any mutable variables in the code - I declare 2 variables, but they are both val and not var, and so cannot be re-assigned. I don't think this is 'perfect functional thinking', but I suspect, I'm slowly catching on.

Project Euler Problem 4 in Scala

2011-12-23T12:42:00.000-08:00

This is 4 in a series. The previous post is at, Project Euler Problem 3 in Scala.

So I've already worked through 3 problems in Euler in hopes of using the exercises to help me learn some Scala. In each of the previous solutions, I had a LOT of mutable state in my code. As I get more comfortable with the language, however, I think I'm improving quite a bit. Even so, it appears I still had a mutable variable in my first solution to this problem. Problem 4 on the Project Euler site reads:

A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 99.
Find the largest palindrome made from the product of two 3-digit numbers.

This doesn't seem too difficult to solve. We can cast our integer values to strings, reverse them, and compare them to determine if they are a palindrome, and iterating all the 3 digit numbers, 100-999 is easy. So, here's my first solution:

object Problem4 {

def main(args: Array[String]): Unit = {
var highestPalendrome = 0;
for(i <- 100 to 999) {
for(y <- 100 to 999) {
var product = i * y;
var productStr = product toString;

if(productStr.reverse equals(productStr)) {
println(productStr)
highestPalendrome = highestPalendrome max product;
}
}
}
println("Highest is " + highestPalendrome);
}
}

In this solution I iterate the numbers and store the highest palendrome as I go. Of course, the purpose of doing these exercises is to try and code without mutable state, so I had to get rid of that pesky highestPalendrome variable. To do this, I took advantage of the Scala fold left facilities. Turns out, this is a handy way to iterate a list and record results. Here's version 2:

object Problem4 {
def main(args: Array[String]): Unit = {
val highestPalendrome = (0 /: (100 to 999))((highest, next)=>{
(0 /: (100 to 999))((tot2, nex2)=>{
val product = next*nex2;
if(product.toString.reverse.equals(product.toString)) {
next*nex2
} else {
tot2
}
}) max highest
})
println("Highest is " + highestPalendrome);
}
}

You'll notice that this is essentially 1 statement, if you remove the main method and println. You should also notice that I'm using some of Scala's syntactic goodness to make the code easier to read - the end of that statement, 'max highest' would be much uglier in Java - .max(highest).

Well, on to #5. Maybe this time, I won't need a second iteration of the code...

Project Euler Problem 3 in Scala

2011-12-23T12:28:00.000-08:00

This is 3 in a series. The previous post is at, Project Euler Problem 2 in Scala.

I've been busy again this fall, but now that I have a couple of days off over the holiday, I thought I'd play around with some more Scala. It is pretty slow going learning the language at this pace, but the day job calls...

Problem 3 on the Euler site states:

The prime factors of 13195 are 5, 7, 13 and 29. What is the largest prime factor of the number 600851475143 ?

For this solution, I reused the isPrime method from an earlier problem. Essentially I end up looping through all the values up to the square root of the number and record the primes. The largest prime is the last one.

Here's my first solution:

object Problem3 {
val number : Long = 600851475143L;

def main(args: Array[String]): Unit = {
val sqrt = Math.sqrt(number);
var largest = 0L;
var current : Long = 2L;
while(current < sqrt.toLong) {
if(number % current == 0) {
if(isPrime(current)) {
largest = current;
}
}
current = current + 1L;
}
println("Largest " + largest);

}


*//**
* Brute force method. Perhaps a better method
* can be implemented here?
*//*
def isPrime(number: Long) : Boolean = {
var half = Math.sqrt(number)
var current = 2;
while(current < half) {
if(number % current == 0) {
return false;
}
current = current+1;
}
return true;
}
}

After looking at my first solution to this problem, you can see that I have mutable state AGAIN. Something about my Object Oriented brain just can't seem to get into the stateless-state-of-mind. This is interesting for another reason, though. Mutable state, in general, isn't a particularly good thing. That is, if you can solve a programming problem without mutable state, it is better than the solution with mutable state. It shouldn't matter if you are using OO languages or Functional ones. It seems the industries years of OO teachings have led to we engineers sort of ignoring this fact. I guess mutable state isn't as clear in an OO language if you have good Encapsulation in your code, but its still something we should be paying attention to. Luckily, I was able to refactor my solution. Here's a better version:

object Problem3 {
val number : Long = 600851475143L;

def main(args: Array[String]): Unit = {
println("Largest is " + largestPrime(2L, Math.sqrt(number), 2L));
}

@tailrec def largestPrime(initialPrime : Long, limit : Double, currentNumber : Long) : Long = {
if(currentNumber >= limit.toLong) {
initialPrime
} else {
if(isPrime(currentNumber) && number % currentNumber == 0) {
largestPrime(currentNumber, limit, currentNumber + 1);
} else {
largestPrime(initialPrime, limit, currentNumber + 1);
}
}
}

/**
* Brute force method. Perhaps a better method
* can be implemented here?
*/
def isPrime(number: Long) : Boolean = {
var root = Math sqrt number
var current = 2;
while(current < root) {
if(number % current == 0) {
return false;
}
current = current+1;
}
return true;
}
}

Here we have a new solution where all our mutable state has been removed. I start by declaring the number for which we are trying to find the largest prime. It is declared as a val, though, so we are guaranteed that the value can't change. This is different than any other language I've used, but it seems a handy facility. Next, I call the recursive largestPrime method, which uses Tail recursion to iterate the list.

Of course, I still think there is a better way to determine if a number is prime or not, but this method is pretty efficient the way it is.

That's my solution for now. Stay tuned for Problem 4....

Project Euler Problem 2 in Scala

2011-10-21T15:09:00.000-07:00

This is 2 in a series. The Previous post is at, Project Euler and Scala Problem 1.

Here is the second problem on the Project Euler(PE) site.

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:
1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.

Once again, I was able to solve this pretty easily, but I had lots of mutable state in my code. Here was my first solution:

object Problem2 {
val fourMillion : Integer = 4000000;

var first : Integer = 0;
var second : Integer = 1;

def nextFib() : Integer = {
var returnValue:Integer = prev1+prev2;
return returnValue;
}

var sum : Long = 0;

def main(args: Array[String]): Unit = {
var next:Integer = 0;
while( (next <= fourMillion) ) {
next = nextFib();
if(next % 2 == 0) {
sum = sum + next;
}

}
print(sum)
}
}

You will see that I have 3 mutable variables in there - first, second, and sum. I also have a rather ugly while loop. I'd like to get rid of the iteration here and use recursion instead. While doing so, I can also get rid of the mutable state. Here is the rewritten code:

object Problem2 {
//Tail recursive...
def fibList(currentList : Array[Int], limit : Int, previous : Int) : Array[Int] = {
if(previous > limit) {
return currentList;
}
return fibList((currentList :+ previous), limit, (currentList.last + previous));
}

def main(args: Array[String]): Unit = {
print((0 /: fibList(Array[Int](0,1), 4000000, 1))((total, next)=> {
if(next % 2 == 0) {
next + total
} else {
total
}
}))
}
}

I hope you notice the comment in there - Tail Recursive. This is a very interesting feature of Scala, and most other functional languages. You see, the big concern in Java when using recursion is that you run out of stack space for all your recursions. In Scala, the compiler can optimize this code and get rid of the stack if you don't need to keep state in your method. I've carefully constructed the fibList here so that it can be optimized. This way, we can't fill up the stack. go ahead, change 4000000 to 4000000000. While you may overflow the int values, the recursive function won't blow up the memory.

This feature of the language is really quite interesting, and from my understanding not a small feat to pull off given the current bytecode standard. This could allow for some very long-running calculations that might otherwise have caused memory problems if done other ways.

That's all for this problem. On to #3...

Project Euler and Scala problem 1

2011-10-15T08:56:00.000-07:00

I recently found a Web site called, Project Euler (PE). Its a site full of problems that are intended to be solved by coding. As I am also experimenting with Scala, I figured this would be a fun way to keep my skills sharp solving problems while learning the nuances of another language.

What I am finding is very interesting. First, my 'functional' skills need work. I'm attempting to solve each problem with no mutable state, but as you will see, my first iteration usually has some sort of mutable state and it takes me a little bit to refactor it. Part of this is due to the fact that I spend my day job programming in an OO language, part of it is due to learning Scala, but part of it is just that I need more practice in the functional way of thinking.

I am fortunate in that I have two friends who are also interested in PE and who have started working through the problems as well, so we swap notes after we solve the solutions, which further helps understanding.

I thought I would blog about the problems as I work through them. The format I have settled on this this:

I will present my first, rough, solution to the problem, along with a brief summary of the PEdocumentation.
I will present a refactored version of the same problem that makes the code much more functional and maintainable.
If the PE documentation reveals a math or programming concept that would improve the code, another version of the algorithm may be posted.

It's my hope that presenting my progress in this fashion is both interesting and revealing for other programmers. I work primarily in Java, so this might also be a good way for Java programmers to see how things translate to Scala. Of course I am not a Scala expert, so I'm sure there will be lots of comments with room for improvement. At least, that's my hope.

Here is PE's first problem:

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.Find the sum of all the multiples of 3 or 5 below 1000.

Well, this seems simple enough. Simply iterate all the numbers to 1000, testing if they are divisible by 3 or 5 along the way. The first version of my code looks like this:

object Problem1 {

def main(args: Array[String]): Unit = {
var sum = 0;
for( i <- Iterator.range(0,1000) if i % 3 == 0 || i % 5 == 0) {
sum += i;
}
print(sum);
}
}

There's nothing inherently wrong with the code above. Except I have that mutable variable, sum, in there. So, what's a more functional way to think about this? Thanks to the inspiration from my co-worker, Sean, we have a more functional version of the code above:

object Problem1 {
def main(args: Array[String]): Unit = {
val count = (1 to 999);
val sum = (0 /: count)((total, next) =>
{
if (next % 3 == 0 || next % 5 == 0) {
total + next;
} else {
total;
}
});
println(sum);
}
}

In this version, we've made the sum immutable (by using val instead of var), so it can only be assigned once. We've also used the left-fold operator, \:, to iterate the range. Finally, we've converted the contents of the for loop to a function block that gets executed on each 'fold'. This version looks pretty good, but after reviewing the PE docs, we pick up another little math trick.

Instead of iterating the numbers, we can take the sum of all the multiples of 3, sum of all the multiples of 5 and then subtract all the multiples of 15. There's also a proof that demonstrates how to find the sum (I won't reprint it here, if you are interested, unlock the problem on the PE site).

The final version of our code looks like:

object Problem1 {
def main(args: Array[String]): Unit = {
println(sumDivisibleBy(999,3) + sumDivisibleBy(999, 5) - sumDivisibleBy(999, 15));
}

def sumDivisibleBy(limit:Int, divisor:Int) : Int = {
val p = limit/divisor;
divisor * (p*(p+1))/2;
}
}

So in the end, we don't iterate the range at all. This solution would also scale well (what if we wanted to add all the multiples of 3 and five for all numbers under 1 million...)

So there it is. A brief walk through my process on Project Euler problem 1. Let me know what you think.

GWT JSNI Reference

2011-07-17T08:44:00.000-07:00

I've recently had to go through the GWT JSNI interface, and I found the documentation a little lacking. While the official JSNI page has nice examples and clearly shows how things integrate, it leaves out some reference information that would be helpful. My guess is that they didn't want to duplicate the JNI reference, but its still a little frustrating to have to look up the type codes in a separate area. And the type codes aren't exactly intuitive, I mean, who would guess that 'Z' is the representation for boolean?

So, here is a little cheat sheet for those of you looking for the GWT JSNI type codes. These are, of course, the same codes that can be found in the JNI reference.

Native Type	Java Language Type	Description	Type signature
unsigned char	jboolean	unsigned 8 bits	Z
signed char	jbyte	signed 8 bits	B
unsigned short	jchar	unsigned 16 bits	C
short	jshort	signed 16 bits	S
long	jint	signed 32 bits	I
long long __int64	jlong	signed 64 bits	J
float	jfloat	32 bits	F
double	jdouble	64 bits	D

Table taken from Wikipedia, 5/7/2011

In addition to the primitive types, any object can be referenced using its fully qualified name like this:

LFully.Qualified.Name;

For example, to access a string, you use: Ljava.lang.String;

To reference an array of the same type, prepend [ like this:

[Ljava.langString;

So that's my quick cheat sheet. Here are a couple of additional references that help:

Coding Basics - Javascript Native Interface (JSNI)

JDK 6 Java Native Interface-related APIs & Developer Guides

Master of Software Engineering

2011-04-28T17:35:00.000-07:00

Finally, I am an MSE. That's, Master of Software Engineering. I just finished presenting my capstone project at Carroll University.

A lot of people don't know what Software Engineering is. Is it related to Development? Is it really an Engineering discipline? I'd like to take this time to talk a little bit about what I think a Software Engineer is.

Let's start with the official definition of 'Software Engineer'. Any search these days starts with Wikipedia, and in fact, Wikipedia has a nice listing for 'Software Engineering', with lots of references. Here is the first paragraph:

Software engineering (SE) is a profession dedicated to designing, implementing, and modifying software so that it is of higher quality, more affordable, maintainable, and faster to build. It is a "systematic approach to the analysis, design, assessment, implementation, test, maintenance and re-engineering of a software by applying engineering to the software".[1] The term software engineering first appeared in the 1968 NATO Software Engineering Conference, and was meant to provoke thought regarding the perceived "software crisis" at the time.[2][3] Since the field is still relatively young compared to its sister fields of engineering, there is still much debate around what software engineering actually is, and if it conforms to the classical definition of engineering.[4] The IEEE Computer Society's Software Engineering Body of Knowledge defines "software engineering" as the application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software, and the study of these approaches; that is, the application of engineering to software.[5] It is the application of Engineering to software because it integrates significant mathematics, computer science and practices whose origins are in Engineering.[6]

Wikipedia, Dec 24, 2010

If I were to put that rather lengthy description into my own short words, it would be: Software Engineering is a way to build better software by studying and applying a systematic, disciplined and quantifiable approach to the development process.

You see, to me, the key characteristic is that while Software Engineering includes software development, it really goes beyond just writing code or applications. It is the study and practice of the processes that will make writing applications better. Better may not mean faster or cheaper but will always mean higher quality. Although, sometimes, it will mean faster and cheaper, but usually in the long run. So Software Engineering really expands into all the different tasks surrounding a system - business definition, requirements gathering, analysis, design, testing, and support. A Software engineer should know about all these phases in the life cycle and should be involved with all of them.

But developing software is not exactly akin to designing a bridge or a car. There's still a component of craftsmanship or artistry involved with software development. Methodologies can be used to improve estimates, quality, and outcomes, but there is also a large component that is more akin to writing a novel or creating a movie than to building a bridge or designing a car.

It is in that part of the software development process where the art of development presents itself. Writing software is a creative and abstract task with many different ways to solve a problem. In some cases, a single, best, solution can be found, but in so many others, there isn't one. In that regard, some developers are artists, some developers really aren’t, and never will be. The rest of us are aspiring to be one of the great ones. We are competent technicians, writing our works, but not gifted with the ability to produce masterpieces. Here is where what we learn and the techniques we apply from Software Engineering Study allow us to produce pieces of software that are in fact, solid and elegant. We won't be writing the next Mona Lisa, but by following proper techniques, using the best practices, studying what works, and applying them consistently and rigorously, we can produce consistent, appealing work with high levels of quality. If we work hard, people might one day also recognize us as an artist.

Perhaps not a Michelangelo, but maybe a Bob Ross.

My First Scala App

2011-04-24T10:40:00.000-07:00

I've been looking at learning another development language for some time. Over the years I've dabbled in PHP, Groovy, and even C/C++. While I learned a lot in doing this, I never became an 'expert' in any of them. For the most part, I used them for the project in which they were needed or for the scenario where they were most appropriate and then went back to Java for my primary development platform.

The reason is that I'd become so familiar with the Java tool set, language, and available libraries. I was (and am) most productive in that environment. But Java is showing its age and limitations. Its becoming clear that some of the most vexing problems facing developers will need a full range of tools to solve them, and while Java's OO support is good, its functional support is not. I, therefore, decided that I needed to expand and really learn another language pretty well. I decided that language is going to be Scala.

Why Scala? Well, I'll go over that in a different post. This post is about my experience writing my first Scala app. So, here it goes.

The Application
Since I am changing jobs (again), I decided I would leave something behind for my co-workers. In our current work environment, we have a shared drive where server error logs are stored in 'pseudo' XML format. It was always annoying to me that we had to navigate the file structure, open a text file, and hunt through the file to find an error we would be looking for. It was also difficult to determine how often an error was occurring. Now, the easy way to solve this is to use the log4j XML appender and read the files with Apache Chainsaw, but this is a large company, and it decided to go with a proprietary format. I decided to use Scala to write a little desktop app that the developers could use to view the log files in a tabular format, then select a row to see the stacktrace detail.

The Functionality
The application needed 3 essential things : a table to show rows, a TextArea to show the detail, and a FileChooser to select which log to view. In the background it also needed the following processing capabilities: read in a file, modify the text to make it valid XML, parse the XML tags. That's about it.

The Results
Well, I whipped out the app pretty quickly. It would have been much more quickly if I hadn't been learning Scala along the way. There were some really nice things about Scala that I found out. First, its swing wrapper classes are nice, and their pub/sub model is succinct. Second, the XML processing is excellent. The built in support for XML files allowed me to parse the logs in a couple of lines of code. Finally, the Actor metaphor for multi threading was also very easy to use and implement.

I had a few frustrations along the way as well. The Eclipse plugin was nice, but it still doesn't have code-complete (One of the biggest productivity tools in my mind). The code-complete is supposed to be in the plugin, but for some reason, doesn't seem to work for me. I've tried on 3 separate computers. This meant that I was reading a lot of documentation. Its also hard to read the documentation. Since Scala has so much support for so many features, the docs can get a little complicated to read. I'm sure as I become more familiar with the libraries and syntax this will get easier, but I can see how it would be daunting for a junior developer.

Conclusion
I'm by no means a Scala expert at this point, but I enjoyed the language enough, and it seems to have enough benefits that I'm looking forward to learning more. Who knows, maybe one day Scala will be my primary language...

GWT and SmartGWT - JNI and Unsatisfied Link Error

2011-02-05T19:31:00.000-08:00

GWT uses the Java JNI mechanism in a really unique way. JNI was originally intended to work with native code on the computer where you had your JDK, like C++. I've had limited exposure to the JNI interface - I've only had to use it for a serial communication component. Even then, I was using a library that relied on JNI, so I didn't generate the code, I just had to make sure the native library was on my classpath.

The Google Engineers applied this mechanism to Javascript, however. If you want to write 'Native' Javascript in your GWT classes, its easy. Just flag your method as native and put your javascript code, in comments, before your terminator. Here's a sample from the Google Web site.

public static native void alert(String msg) /*-{
  $wnd.alert(msg);
}-*/;

Viola! Instant native interface for your JavaScript CLIENT code. That's right, just try running this method on the server. While working on my current project, I ran into this issue accidently while trying to use a SmartGWT class. I got a JNI error on the server because the VM couldn't find the native code. Of course, there isn't any native code on the server. In this case, the 'native' code is JavaScript.

I was trying to pass a SmartGWT ListGridRecord to the server so I could map it to a persistent bean. Of course, once I saw the error, I followed the inheritance hierarchy for ListGridRecord all the way up the chain, and what did I find at the top? JsObject. Of course, I didn't even have to go that far. After looking at the Record code, it relies on static methods in JSOHelper, which uses a lot of native JavaScript

In the end I had make transfer objects to use to send the data over GWT RPC. This was a good reminder, though, that while GWT looks like Java, what's being executed really isn't.

SmartGWT and GWT RPC Integration

2011-01-30T08:25:00.000-08:00

I am currently finishing my Capstone project for my MSE at Carroll University. While the application I am writing itself doesn't have a lot of twists in it, I decided to use this opportunity to experiment with some different technologies. I'm using GWT, SmartGWT, and Hibernate in the application. I've used Hibernate and GWT pretty extensively in my professional career, but the twists I've added for this development are to configure Hibernate using the JPA standard, and to use GWT Designer for mockups. I've already posted about my experiences with GWT Designer.

I haven't really used SmartGWT before. My experience has been with the ExtGWT library, which I loved. I chose to use SmartGWT on this build because it is fully LGPL, while Ext is dual licensed. While working with SmartGWT I've found some things that I was not expecting.

One of the selling points of SmartGWT is that it has built in support for 'Data Binding' with Tables and the like. This is done through DataSource objects. The problem is, the published DataSource implementations don't work with GWT RPC. And the DataSource base class has dozens of methods (Just take a look at the JavaDoc). It really isn't clear how to define your own custom data source, or the work it will take to do so. This was a sticking point for me because I really like the GWT RPC mechanism, and I had already come up with a nice security model, which I posted about here.

It took a while, but I finally found a post about integrating GWT RPC on the SmartClient Forums. The post is a bit dated and says you need to compile from source, but that is not the case. The version of SmartGWT I am using, 2.4 already has the clientCustom flag built in. The developer who posted this also supplied 5 files, Including a GwtRpcDataSource abstract class, and a sample implementation. The class comments well what you need to do to implement your datasource. With this setup, a new GWT data source can be defined by implementing 4 methods.

I hope this post helps others find the solution much faster than I was able to.

dynaTrace Enlightenment

2011-01-08T04:40:00.000-08:00

My company recently sent me for dynaTrace training. dynaTrace is a tool that allows you to instrument your code in real time in order to measure and monitor performance. I'm not going to go into detail about what it can do, you can read all about it on the dynaTrace websit e. If your company has the money, however, I highly recommend it. It is impressive to say the least.

One of the things dynaTrace offers is the ability to see all the exceptions being thrown in your application, not just the the ones being propagated to your code. This is important in our applications because we use third-party libraries, and we don't always know what they are doing. In instrumenting the application we are working on, we found that Spring was throwing hundreds of thousands of exceptions and burying them. Now each one of these is small in cost, and the application works as expected. The cost of the exceptions, however, was starting to get expensive - one, two or even a few hundred probably wouldn't be cause for concern, but hundreds of thousands?

So What was the cause?

This application is also a Web application that uses Struts2. The application was set to use annotation-based configuration. But when we looked at the Exceptions, it appeared that Spring was ignoring the configuration and attempting to configure itself using other methods, throwing exceptions, and then trying the next one. Multiple exceptions occurred every time the application accessed a Spring managed bean.

As it turns out, there is another flag in Struts 2 to set that says, "No we really, really want to use this configuration." Once that flag was set, the exceptions disappeared.

So What's the Point?

In todays development environment, we are heavily reliant on 3rd party libraries in order to leverage previous code and get things done faster. Many applications use dozens of libraries from many different sources. In some ways, this is a necessary evil. Could you imagine the time it would take to write a Web application completely from scratch? I mean completely, no application container, no MVC, nothing. Start with the sockets to listen to requests. So, as engineers, we decide to use a component created from another source that matches the criteria we need. We use application containers, M-V-C frameworks, JavaScript toolkits, Persistence mappers, Logging libraries.... The list goes on and on.

While all of this is generally a good thing, sometimes its not because we don't truly know what's going on in our black boxes. I think tools like dynaTrace are going to become more popular as companies look to improve quality while still enjoying the advantage of third party software.

That's it for now, it's time to go figure out why the Struts taglibs are adding 500 ms to our page rendering times....

GWT Designer

2010-12-31T07:12:00.000-08:00

I am not a fan of WYSIWYG software. Almost every experience I had with WYSIWYG tools had the same pattern:

I implement some application using the tool because I am pressed for time.
I get the initial project done very quickly.
Someone requests a change.
Because of the WYSIWYG generated code, I essentially have to rewrite the app.

Maybe I just didn't use the WYSIWYG right. Obviously, a lot of people love them. But they were always counter-productive for me. In the end, they cost me more time than they saved. So, you can imagine my feelings when I read about GWT Designer. Here was a Drag and drop visual editor for GWT, complete with integration for SmartGWT and Ext GWT. I was hesitant, to say the least.

But I also firmly believe that as a Software Engineer, you have to keep your mind open and constantly re-evaluate new tools. So, I installed the GWT Designer plugin for Eclipse. I used it for my capstone project, a CRUD application for running a sign installation company. I was pleasantly surprised.

Here are a few observations about the Editor:

I was able to jump between code and the visual editor easily
Changing my code by hand didn't break the visual editor
The code generated by the editor was easily readable and clean

Even though I started with the WYSIWYG, as I got a simple layout produced, I found myself easily translating into the code. It was a good experience. The visual components I created were originally going to be mock ups, but they were so clean, I've transitioned them into the working code. The application is not done yet, but its looking good - I've already been able to easily incorporate changes requested by my client.

Now, here are the drawbacks I encountered:

My 5 year old PC and laptop run the visual components a little slow.
The visual rendering isn't yet perfect. While it was mostly reflective of the actual output, there were a few differences.

All in all, though, the drawbacks were more annoyances than restrictions.

If you use GWT, I recommend you try GWT Designer.

GWT Simple Security Configuration

2010-12-24T11:40:00.000-08:00

For my capstone project in my MSE program at Carroll University, I am writing a GWT application. One of the requirements for this application is security. There are several posts on securing a GWT application on the Web already, but most of them are more heavy weight solutions that show you how to use Spring-AOP and Spring-security to secure your app.

For this project, I don't need anything that heavy-weight. Here is a little review of how I secured this application.

First, I wanted each service to have it's own access controls. More specifically, I want to be able to secure each method in each service. Second, I want to be able to support Role-based access. This way I can add users to roles to grant them the permissions they need. Finally, I don't have a real need to redefine role access in real-time. Given these constraints, I was able to put together a quick and easy solution to secure my application.

First, I decided that I wanted to be able to easily see in my code what the access control was. It seemed to me that Annotations would be an easy way to do this. Something like:

@Secure("ROLE_ADMINISTRATOR")

But I want to be able to specify multiple roles that can be configured to this action, so, multiple roles would look more like this:

@Secure({"ROLE_ADMINISTRATOR, ROLE_CONFIGURATION_MANAGER"})

So, the first thing I did was define the Annotation.



package com.archie.sma.server.util.security;



import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;



@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

public @interface Secure {

  public String[] value();

}

AS you can see, annotations are annotated. This one says that this annotation applies to Methods, and it is kept at runtime.

Next I needed to apply the annotation to my services. This was quite easy. In my Service interface on the client, I used the annotation:

@Secure({"ROLE_ADMINISTRATOR", "ROLE_CONFIGURATION_MANAGER"})
public Object get(String id) throws Exception {
//Method implementation here...
}

Of course, I now need to tie these two together. Since I'm Using GWT, I decided to Extend the GWTServerServlet. By extending the servlet and over-riding the processCall and onAfterRequestDeserialized method, I am able to easily use a little bit of Reflection to get the annotation and determine if the user in Session has access to the method. This approach also requires me to extend my new security Servlet for all my secured classes. So its on the developer to ensure he is extending the class correctly. Here is the class:








public class SecureRemoteServiceServlet extends RemoteServiceServlet {


  private transient IDaoFactory daoFactory;


  @Override


  public void init(ServletConfig config) throws ServletException {


    super.init(config);


    daoFactory = new DaoFactory();


  }


  /**


   * 


   */


  private static final long serialVersionUID = 1000L;


  private static final String USER = "USER";


  private User user;


  @Override


  protected final void onAfterRequestDeserialized(RPCRequest rpcRequest) {


    Method method = rpcRequest.getMethod();


    Secure secure = method.getAnnotation(Secure.class);


    Boolean hasAccess = Boolean.FALSE;


    if (secure != null) {


      


      String[] roles = secure.value();


      HttpServletRequest request = getThreadLocalRequest();


      user = (User) request.getSession().getAttribute(USER);


      if (user != null) {


        List<Role> userRoles = user.getRoles();


        for (Role role : userRoles) {


          for (int i = 0; i < roles.length; i++) {


            if (role.toString().equals(roles[i])) {


              if(hasAccess != null) {


                hasAccess = Boolean.TRUE;


              }


            }


          }


        }


      }


    }


    if (!hasAccess){


      throw new RuntimeException("Not Authorized");


    }


  }


  /*


   * @Override public final String processCall(String payload) throws


   * SerializationException { if (!hasAccess) { throw new


   * UnexpectedException("Security Exception", new Exception(


   * "Not Authorized")); } return super.processCall(payload); }


   */





  public User getUser() {


    return user;


  }





  public void setUser(User user) {


    this.user = user;


  }





  public IDaoFactory getDaoFactory() {


    return daoFactory;


  }





  public void setDaoFactory(IDaoFactory daoFactory) {


    this.daoFactory = daoFactory;


  }


}

So that is my quick and dirty security implementation for my GWT app. This is not what you would call an enterprise solution, but it is a quick way to implement security for a little, self-contained application.

Software engineering vs. Computer Science

2010-06-26T07:04:00.000-07:00

There is a difference between Software engineering and Computer Science. Just like there is a difference between Mechanical Engineering and Physics. I believe that the big difference is that in the physical world, people have been building structures for thousands of years. The difference between the theory of the physical world and the building of things in it is well defined. Modern computing has been around for what, 60 years? We have not yet defined the difference between the theory of Computing and the practical application of it.

In computer science, the task is often to find the best, or most efficient way to perform a task. Often, Computer Scientists are looking for theoretical limits, or trying to resolve a new computing issue in a novel way.

In software engineering, you are trying to build a system to meet a need using the tools at hand, given the constraints of your system. Often this means NOT using the best solution. It means using the best solution given the constraints placed on your use case.
As a Software Engineer, this means we do not necessarily build things on our own. Rather, we evaluate alternatives and select the best one. One example of this might be Web Frameworks. Another might be ORM selection (or whether to use either of these technologies at all and actually build our own). This is analogous to a mechanical engineer designing a car - he doesn't also design the tires, alternator, battery, etc. Rather he looks at the alternative possibilities and selects the best one for the vehicle he is trying to create. Of course, there are going to be many areas that the mechanical engineer does build.

It seems like in software engineering, using other peoples tools is frowned upon. There is some sort of badge of honor to say, 'I built this myself'. While it is impressive to have that broad range of skill, does that necessarily make you the best Software Engineer?

It is my belief that as a profession, we Software Engineers need to start thinking of our task as more of an engineering endeavor and less of computer science endeavor. We need to see ourselves not as Scientists, but as Engineers.

Bug fix for Unit Test Generation Plugin

2010-06-12T19:02:00.000-07:00

I fixed a few bugs in the Unit Test Generation Plugin. I think the next release is going to be a re-factor only, as the code is pretty rough and I want to be able to keep this project clean. I believe after a few more edits I will be comfortable declaring the project a 'Beta' project.

Get the latest download

Inversion of Control - Results

2010-06-08T16:47:00.000-07:00

In a previous post I talked about how to identify and re-factor a section of code that had a switch statement in it. I was finally able to get to that statement at work and re-factor it. I thought the results would be interesting to post.

First and foremost, I was able to remove 120 unnecessary lines of code and replace it with 2 lines. That's right, where once there were 120 lines there are now 2.

But there is more to the story than that. As I mention before, I've been unit testing the application(and that led to a new Eclipse tool), so as I re-factored the system, I re-ran my tests. At one point my tests FAILED. That's right, I BROKE the intended functionality with a re-factor that shouldn't have.

When I looked into it further, I found that one little switch statement buried in that twenty-two case wonder didn't follow the pattern. Instead of getting an implementation from the factory and calling a getMap method, it was calling an entirely different method in the main class. After a little research and a few short lines of code, the issue was fixed and the tests once again showed a green bar.

The actual work here is not relevant, what is relevant is this: This is a pre-release version of this system. It is not even in Beta testing yet, and there is already a place in the code that was 'hacked' to work differently than you would expect. The implementation of a pattern will help prevent this kind of degrading of the code in the future, but it was there. In the code. Before the software was even released.

The second thing to take away from this: If I hadn't written all those unit tests, I wouldn't have found the error. I would have re-factored the code and introduced a bug into the system without realizing it. Unit tests saved me. And because of that, my company will now have a system that is more resistant to errors and less prone to new bugs.

A two week diversion. Eclipse Plugin to Generate Unit Tests

2010-06-06T17:35:00.000-07:00

I took a new job about a month ago at an insurance company. The company is in the middle of rewriting the Point of Sale application for its line of business. Since the project had already kicked off and development had begun, I had been assigned the glorious task of filling in Unit test coverage.

You see, the management at this company is pretty new to Agile development methodologies, and until about a year ago, Unit tests were largely unknown to them. They are driving a tight timeline for delivering the rewritten project. Often, the developers are going over their burndown hours, so the first thing to suffer was, you guessed it, the unit tests. On top of that, management is insistent on getting 80% coverage. As you can probably guess from the title of this post, I was assigned the duty of creating unit tests for this iteration of the code, with the purpose of increasing code coverage to as close to 80% as possible.

When I was handed the code, the coverage, depending on sub-project, was between 0% and 20% covered.

I decided to create an Eclipse plugin to help me with the task (On my own time, of course. During the day, I wrote tests.) I call it Unit Test Generation Plugin. This version is very basic. It really only works to create tests for POJOs at this point, but I think I'll extend it a bit to make it more useful soon.

I was really quite surprised at how easy and fun it was to create a plugin for Eclipse. I thought I'd post some of the code and the process I used to create the plugin on the site.

Here are some highlights. Let me know if you'd like me to write more detail about a particular topic.

Binding An Event To The Eclipse Package Menu
Eclipse uses a powerful plugin framework to allow you to extend and enhance the platform. The way to add extensions is to use the PDE, which is a part of the core project. Eclipse makes creating a new project VERY easy. To start, go to File->New->Project...->Plugin Project.

In the New Plugin Window, Enter a name, like com.a.plugin. The rest of the defaults can be left alone. Click, Next. Another popup appears to allow you to select more options for your project config. Modify the name and provider all you like, but the defaults should suffice. Click Next.

The final panel allows you to select several templates that demonstrate different extensions. You can select a template if you like, or none at all. For this project, I will select none.

When you finish, a new Eclipse plugin project is created and you are ready to continue.

Extension Points
An extension point is how you add new functionality to Eclipse. They are configured using an XML file. Eclipse supplies an editor to allow you to easily edit this file. I had some trouble configuring my Handler through this screen, but was able to write the code by hand. Once I edited it, it appeared correctly in the editor. I've done a little reading and that might be because I didn't have some RCP plugins installed, but I haven't verified it yet.

Java Code Support
It also turns out that Eclipse has robust support for Java project Elements. There are interfaces like ICompilationUnit, IPackageFragment and so forth. It was pretty easy to generate new tests.

The Result
I have decided that I am going to make the project open-source and created a SourceForge project for it. It is still in Alpha stage, and there is a bit of work to make it a 'real' plugin, but its now out there in the world.

Unit Test Generation Plugin

Now, I'm sure that Robert Martin would hunt me down if he knew what I created, and would destroy the laptop it was written on (OK, I don't really know him, but I've read one of his books, Agile Software Development, Principles, Patterns, and Practices. From the perspectives presented there, I can infer that he would not be happy with my tool

Identifying and refactoring - Inversion Of Control

2010-05-25T16:26:00.000-07:00

In my new position, I am now working on a large team of developers (15 in all). This team is working to complete a single product that has been designed using a Service Oriented Architecture. I have some insights into that design as well, however, in this post I thought I would show an example of how to identify and refactor to a design pattern, and why I feel this is a good thing for the project in the long term.

One of the hardest things about design patterns is recognizing when to use them and when not to. I have seen so many architects apply patterns for patterns sake, making code more complex, and making it HARDER to apply patterns where they are truly needed. I've also seen lots of code that isn't refactored to design patterns, and it COULD be made much easier to maintain and understand if it were changed. The code I will be talking about today is of the latter type. I've been writing Unit tests against the codebase at my new position. This has given me an opportunity to review the code. In order to protect the IP of the company I work for, the samples below have been changed. They represent the structure of some of the code, but are entirely unrelated to what my company does.

First, let me describe the general design of the code as it stands. In this instance, we have a method that takes an Enumeration argument. The method then calls the getInstance method of a Factory, and gets the proper implementation of an Interface. The getInstance method also takes an Enumeration. Finally, the code uses a case statement that tests the Enumeration value and uses the interface to set the values of different member variables in the class. Here is the sample code that would implement this design:

The Container. This is the class where our execution starts. We call setMapValue and pass it a Type enum.

  1 package com.arciszewski.staterefactor; 
  2 import com.arciszewski.staterefactor.Type; 
  3 import java.util.Map; 
  4  
  5 public class Container {
  6     private Map<String,String> map1; 
  7     private Map<String,String> map2; 
  8     private Map<String,String> map3; 
  9      
 10     public void setMapValue(Type type) {
 11          
 12         ITypeInterface intf = TypeFactory.getInstance(type); 
 13          
 14         switch(type) { 
 15             case ONE : 
 16                 map1 = intf.getMap(); 
 17                 return; 
 18             case TWO :
 19                 map2 = intf.getMap(); 
 20                 return; 
 21             case THREE : 
 22                 map3 = intf.getMap(); 
 23                 return; 
 24             default : 
 25                 return; 
 26                  
 27                  
 28         } 
 29          
 30          
 31     } 
 32  
 33     public Map<String, String> getMap1() { 
 34         return map1; 
 35     } 
 36  
 37     public void setMap1(Map<String, String> map1) {
 38         this.map1 = map1; 
 39     } 
 40  
 41     public Map<String, String> getMap2() { 
 42         return map2; 
 43     } 
 44  
 45     public void setMap2(Map<String, String> map2) {
 46         this.map2 = map2; 
 47     } 
 48  
 49     public Map<String, String> getMap3() { 
 50         return map3; 
 51     } 
 52  
 53     public void setMap3(Map<String, String> map3) {
 54         this.map3 = map3; 
 55     } 
 56      
 57 } 
 58  
 59

This is the Factory that creates ITypeIntf concrete classes. For now there is only one implementation for type.ONE.

  1 package com.arciszewski.staterefactor; 
  2  
  3 public class TypeFactory {
  4  
  5     public static ITypeInterface getInstance(Type type) {
  6          
  7         ITypeInterface typeIntf = null; 
  8         if(type.ONE == type) { 
  9           return new  TypeImplOne();  
 10         } if(type.TWO == type) { 
 11              
 12         } if(type.THREE == type) { 
 13              
 14         } 
 15         return null; 
 16     } 
 17      
 18 }

The Enum. Not much to say here.

  1 package com.arciszewski.staterefactor; 
  2  
  3 public enum Type { 
  4     ONE, TWO, THREE; 
  5 }

The Interface that defines getMap.

  1 package com.arciszewski.staterefactor; 
  2  
  3 import java.util.Map; 
  4  
  5 public interface ITypeInterface {
  6  
  7     public Map<String, String> getMap(); 
  8 }

An implementation class. Kept simple for discussion.

  1 package com.arciszewski.staterefactor; 
  2  
  3 import java.util.HashMap; 
  4 import java.util.Map; 
  5  
  6 public class TypeImplOne implements ITypeInterface {
  7  
  8     @Override 
  9     public Map<String, String> getMap() { 
 10         //Do something like get data from a DB. 
 11         return new HashMap<String, String>();
 12     } 
 13  
 14 }

Looking at this code, you'd probably say that the developers did some things right. They designed to interfaces, they are using a creational pattern, and the code is pretty clean and easy to read. I tend to agree, except when it comes to that ugly switch statement. Here are my issues with the switch statement:

Developers have to remember the return statement, or we will have NULL implementations when we shouldn't
Developers will be tempted to add more logic to the case statements that are Type specific. As these add up, the clarity of the code falls
We're already verifying the type in the Factory, so this code is checking the Type value twice when it doesn't have to.
Container needs to be aware of the different implementations of ITypeIntf. Why should it need to? Now we've added a dependency we don't need.

There is a change we can make that will improve this code. Let's change the ITypeInterface to take a Container object in its argument list. Then we can set the value in the method and the case statement is no longer needed. This is a classic IOC technique. Here is what the code looks like after the refactoring.

The new Container. Notice, there is no switch statement. None is needed. the IMPLEMENTATION of the ITypeIntf knows which attribute it needs to set. Also note that Container doesn't need to know anything about the implementation that the Factory returns.

  1 package com.arciszewski.staterefactor; 
  2 import com.arciszewski.staterefactor.Type; 
  3 import java.util.Map; 
  4  
  5 public class Container {
  6     private Map<String,String> map1; 
  7     private Map<String,String> map2; 
  8     private Map<String,String> map3; 
  9      
 10     public void setMapValue(Type type) {
 11         ITypeInterface intf = TypeFactory.getInstance(type); 
 12         intf.setMapValue(this); 
 13     } 
 14  
 15     public Map<String, String> getMap1() { 
 16         return map1; 
 17     } 
 18  
 19     public void setMap1(Map<String, String> map1) {
 20         this.map1 = map1; 
 21     } 
 22  
 23     public Map<String, String> getMap2() { 
 24         return map2; 
 25     } 
 26  
 27     public void setMap2(Map<String, String> map2) {
 28         this.map2 = map2; 
 29     } 
 30  
 31     public Map<String, String> getMap3() { 
 32         return map3; 
 33     } 
 34  
 35     public void setMap3(Map<String, String> map3) {
 36         this.map3 = map3; 
 37     } 
 38      
 39      
 40 }

The new interface. The interface definition was changed to return void and to make the name descriptive of what it does now.

  1 package com.arciszewski.staterefactor; 
  2  
  3 public interface ITypeInterface {
  4  
  5     public void setMapValue(Container container);
  6 }

The new implementation. Notice that the new implementation now has a dependency on Container. That's OK in my mind, since the interface is intended to work on Container. Here's what we gained, though. Now ALL the logic for this condition is in ONE place. Container will never need to be changed, even if a new implementation is defined (For instance, an implementation that will set ALL the map attribute values.)

  1 package com.arciszewski.staterefactor; 
  2  
  3 import java.util.HashMap; 
  4  
  5 public class TypeImplOne implements ITypeInterface {
  6     // Changed the name, too. getMap no longer describes this function, but
  7     // setMapValue does. 
  8     @Override 
  9     public void setMapValue(Container container) {
 10         // Do something like get data from a DB. 
 11         container.setMap1(new HashMap<String, String>());
 12     } 
 13  
 14 }

So what pattern does this conform to? It looks a bit like a State or Strategy pattern. It also looks a bit like a Command pattern. Which would you say it is?

Android Application Part 6 - SQLLite Database

2010-05-23T07:28:00.000-07:00

This post is part 6 of a series. Click here to go to part 5.

In my previous post, I walked through the scaffolding for the ListService, which will query a REST Web service and sync data locally. Of course, the code was just the implementation to allow the service to run in a new Thread. Today I am going to start implementing the storage part of the application. Android has a a SQLLite. Database. The OS makes it available through a service. It even comes packaged with a SQLLiteOpenHelper class. The implementation for this one is rather easy. Here I've modified the sample presented on the Android Developer Site. First I'll show you the code, then I'll talk through what its doing.

package com.arciszewski.family.shopping.db;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteDatabase.CursorFactory;

public class FamilyListOpenHelper extends SQLiteOpenHelper {

private static final int DATABASE_VERSION = 1;
private static final String FAMILY_LIST_TABLE_NAME = "familyList.db";
private static final String LIST_TABLE_CREATE = "CREATE TABLE LIST (ID INTEGER PRIMARY KEY AUTOINCREMENT, SERVER_ID INTEGER, NAME TEXT, DESCRIPTION TEXT);";
private static final String ITEM_TABLE_CREATE = "CREATE TABLE ITEM (ID INTEGER PRIMARY KEY AUTOINCREMENT, SERVER_ID INTEGER, NAME TEXT, LIST_ID INTEGER NOT NULL, NEEDED BOOLEAN, UPDATED_DATE TEXT, UPDATED_BY TEXT);";

public FamilyListOpenHelper(Context context) {
this(context, null);
}

public FamilyListOpenHelper(Context context, CursorFactory factory) {
super(context, FAMILY_LIST_TABLE_NAME, factory, DATABASE_VERSION);;
}

@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(LIST_TABLE_CREATE);
db.execSQL(ITEM_TABLE_CREATE);
}

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// TODO Auto-generated method stub

}
}

So what is this code doing? First, I've defined which version of the DB this is:

DATABASE_VERSION = 1;

I like this feature of Android. They have built-in support for upgrading. You'll notice, I have not implemented the onUpgrade method, that is because I have no need for it yet. But when I come out with version 2.0, I will have the opportunity to perform upgrade operations.

Next, I define the table names and create SQL for the List and Item tables.

private static final String LIST_TABLE_CREATE = "CREATE TABLE LIST (ID INTEGER PRIMARY KEY AUTOINCREMENT, SERVER_ID INTEGER, NAME TEXT, DESCRIPTION TEXT);"; private static final String ITEM_TABLE_CREATE = "CREATE TABLE ITEM (ID INTEGER PRIMARY KEY AUTOINCREMENT, SERVER_ID INTEGER, NAME TEXT, LIST_ID INTEGER NOT NULL, NEEDED BOOLEAN, UPDATED_DATE TEXT, UPDATED_BY TEXT);";

Finally, I've implemented a constructor that will always open the Family List Database and return it to the caller. That's it. And that is pretty easy my friends. Of course, I'm not making this available as a service to other applications, which is slightly more complex.

Next, I'll implement some querying and saving.