ZiltiTech

In Java, the code is as follows:

 1 public class PrimeFactors {
 2 
 3         LazyList lazyList = new LazyList();
 4         public static void main(String[] args) {
 5                 PrimeFactors primeFactors = new PrimeFactors();
 6                 System.out.println(primeFactors.getPrimeFactors(600851475143L));
 7         }
 8         
 9         public java.util.Stack<Long> getPrimeFactors(Long target) {
10                 java.util.Stack<Long> factors = new java.util.Stack<Long>();
11                 return getPrimeFactors(target, factors);
12         }
13         
14         public java.util.Stack<Long> getPrimeFactors(Long target, java.util.Stack<Long> factors) {
15                 for(int i=0;;i++) {
16                         Long prime = lazyList.get(i);
17                         if(prime <= target && target%prime == 0) {
18                                 factors.push(prime);
19                                 return getPrimeFactors(target/prime, factors);
20                         }
21                         else if(prime >= target) {
22                                 return factors;
23                         }
24                 }
25         }
26         
27         class LazyList {
28                 
29                 private java.util.List<Long> primeNumbers = new java.util.ArrayList<Long>();
30                 
31                 public LazyList() {
32                         primeNumbers.add(2L);
33                 }
34                 
35                 public Long get(int i) {
36                         if(primeNumbers.size() <= i) {
37                                 int diff = i - (primeNumbers.size() - 1);
38                                 for(int x = 0; x < diff; x++)
39                                         calcNextPrime();
40                         }
41                         return primeNumbers.get(i);
42                 }
43                 
44                 private void calcNextPrime() {
45                         Long start = primeNumbers.get(primeNumbers.size()-1);
46                         for(Long counter=start;;counter++) {
47                                 boolean isPrime = true;
48                                 for(Long i=2L;i<counter;i++) {
49                                         if(counter%i == 0) {
50                                                 isPrime = false;
51                                                 break;
52                                         }
53                                 }
54                                 if(isPrime) {
55                                         primeNumbers.add(counter);
56                                         break;
57                                 }
58                         }
59                 }
60         }
61 }

And now, the equivalent Scala code:

   1 val target = 600851475143L
   2 val primeList = nextPrime(2L)
   3 println(factor(target))
   4 
   5 def nextPrime(start:Long):Stream[Long] = {
   6     isPrime(start) match {
   7         case false => nextPrime(start+1L)
   8         case true => Stream.cons(start, nextPrime(start+1L))
   9     }
  10 }
  11 
  12 def isPrime(num:Long, mod:Long = 2L):Boolean = {
  13     num < mod*mod || (num%mod match {
  14         case 0 => if(num == mod) true else false
  15         case _ => isPrime(num, mod + 1L)
  16     })
  17 }
  18 
  19 def factor(num:Long, factors:List[Long] = List()):List[Long] = {
  20     println("Get factor for "+num)
  21     primeList takeWhile(_ <= num) find(num%_ == 0) match {
  22         case None => factors
  23         case Some(x) => factor(num/x, x::factors)
  24     }
  25 }

So this time it's pretty obvious. The Scala code is a lot shorter. Of course, the programming paradigm plays an important role in this. Functional programming just is better suited for mathematical problem solving. Especially the extensive use of pattern matching makes the code a lot shorter and better readable. In Java, on the other hand, recursive functions can cause quite some redundant code by requiring very verbose method overloading. Additionally I had to implement a lazy loading list in Java since there is no equivalent to Scala's "Stream" collection. Regarding this Java stands quite well compared to Scala despite being known as a language that's very verbose.
As for readability, usually a bit more verbose code is more readable. But here, the difference is quite big. Additionally, the Java code uses loops with increment variables, which makes the code less readable.
So this round goes to Scala and functional programming.

Code showdown statistics:

• Readability: Java 0:1 Scala
• length: Java 0:1 Scala

import org.apache.sling.scripting.scala._
class Script(arg:ScriptArgs) {}

var methods:Seq[Method] = arg.getClass.getMethods
methods.foreach(p => println(p.getName))

I decided to opensource my social network client Lopia. The project is available at Kenai.com.

Feel free to join the project to contribute graphics, code or just ideas.

I just uploaded the code and put some better documentation than I had before (speak: almost none) into it.

I'm right now writing a document about my plans of what to integrate into the project.

See you on kenai.com!

• Main Main contains the stage and scene. The scene contains a Stack containing the "normal" content, and, on top of it, a sequence which is used to store the node(s) (multitouch, anywhere? ) which should float above the components.
• Box I couldn't figure out a good name for the component which is able to hold draggable components, so I simply called it "Box". The Box has functions to add and remove the draggable nodes from/to the scene graph.
• Draggable Just as the name says: A component which is draggable.
  Well, the "draggable" part actually was difficult to master, I ended up with this code:
  

  onMousePressed:function(e:MouseEvent):Void {
              offsetX = e.x;
              offsetY = e.y;
  
              this.layoutX = 0;
              this.layoutY = 0;
  
              this.translateX = e.sceneX - offsetX;
              this.translateY = e.sceneY - offsetY;
              dragContainer = DragContainer {
                  draggable: this
                  origin: box
              }
          }
  
          onMouseDragged:function(e:MouseEvent):Void {
              this.translateX = e.dragAnchorX + e.dragX - offsetX;
              this.translateY = e.dragAnchorY + e.dragY - offsetY;
          }
  
          onMouseReleased:function(e:MouseEvent):Void {
              this.translateX = 0;
              this.translateY = 0;
              dragContainer.drop(e.sceneX, e.sceneY);
          }

• DragContainer this class manages the Draggable by setting the references to the scene graph parts ("dropping" the draggable to the right target, removing it from a Box, usw).
  I think it's alright if I show the code here, because it's the main component which manages the dragging and it's quite short:
  

  public-init var draggable:Draggable;
      public-init var origin:Box;
  
      init {
          origin.drag(draggable); // Forces the Box "origin" to delete the draggable from its scenegraph.
          insert draggable into Main.floating; // Main.floating is a sequence which is held on top of a Stack layout.
      }
  
      public function drop(x:Number,y:Number):Void {
          var boxBelow:Box;
          if(BoxStore.isBoxAt(x, y)) {
              boxBelow = BoxStore.getBoxAt(x, y);
          }
          else {
              boxBelow = origin;
          }
  
          delete draggable from Main.floating;
          boxBelow.drop(draggable); // Adds the draggable to the Box "boxBelow"
          draggable.box = boxBelow;
          println("{draggable.name} dropped onto {boxBelow.name}");
      }

• BoxStore each Box has to register itself in this "static class". The DragContainer uses the isBoxAt(x,y) and getBoxAt(x,y) methods to decide where to drop the Draggable and to drop it.
  The BoxStore itself uses the method "box.boundsInParent.contains(x, y)" to determine if the pixel is on the area of a Box.