programming addicted

Exploring the world: Eclipse after IntelliJ

2012-01-06T22:57:00.011+04:00

updated on 09.01.2012

I've been an IntelliJ IDEA fan for quite a long time but there are pretty many buddies at the web who are happy with eclipse. Having my knowledge of the basic IntelliJ facilities improved significantly by working at the IntelliJ Core team, I've decided to try using eclipse at home for a while and build own opinion about it.

This post is expected to be expanded as I spend more time with eclipse and collect more information about it.

editor;

maven;
- + UI for pom.xml
- + Adding maven dependencies

Editor

Highlighting braces at the txt files

Haven't found a way to teach eclipse to highlight matched braces at the plain text file. IntelliJ does that perfectly (fixed couple of bugs at that area myself :) ):

Call action by name

'Call action by name' ('Ctrl+Shift+L' in eclipse) supports speed search at IntelliJ. I.e. it's possible to start typing a name and the actions list is automatically trimmed:

Appearance

Imho, eclipse doesn't provide enough visual separation between editing area and auxiliary information like line numbers, foldings etc:

eclipse:

The same code looks as follows at the intellij:

Maven

UI for pom.xml

I like the additional pom.xml UI provided by eclipse:

Adding maven dependencies

It's much more convenient to add new maven dependencies at eclipse:

it's possible to do that via UI;

completion is provided;

the dependency is automatically added to the pom.xml;

IntelliJ also allows to do that but the facilities are not so productive:

Swing color keys

2011-08-04T17:32:00.002+04:00

Always forget about the place to check available Swing LAF property keys (like text box text foreground, label background etc). Here it is - BasicLookAndFeel.

Closing Empathy chat by 'escape;

2011-08-02T14:50:00.003+04:00

Standard shortcut for closing empathy chat tab is 'Ctrl+W'. Thanks God, it's possible to reassign it to 'escape':

Open /usr/share/empathy/empathy-chat-window.ui;

Change '<accelerator key="W" modifiers="GDK_CONTROL_MASK"/>' to '<accelerator key="Escape" />';

Empathy opens hyperlinks at new browser window

2011-07-28T17:18:00.002+04:00

Started using empathy recently. So far so good except for the one annoying feature - every time I click hyperlink at the messenger's window it starts firefox (though I use chrome) and displays it there.

It looks like chrome guys didn't handle properly 'set chrome as default browser' option. Go to 'System - Preferences - Preferred Applications' and ensure that the desired browser is set at 'Web Browser' there (firefox was there in my case).

Everything works fine after setting 'chrome' there.

IntelliJ IDEA: from Windows to Linux

2011-07-26T13:06:00.013+04:00

Default IntelliJ IDEA keymap contains number of shortcuts that conflict with standard Gnome shortcuts. It's possible to use the dedicated 'Gnome' keymap inside the IDE but I've used the standard keymap for a while and don't want to change my fingertips memory.

Here is a the list of the conflicting Gnome actions I've encountered:

System | Preferences | Windows
1. Disable alt+click over window (system - preferences - windows)

System | Preferences | Keyboard Shortcuts
1. Show the panel's main menu - alt+f1;
2. Switch to workspace on the left/right' - 'ctrl+alt+left/right';
3. Lock screen - 'ctrl + alt + L'
4. Move window - 'alt + f7'
5. Resize window - 'alt + f8'
6. Run a terminal - 'ctrl + alt + t'
7. Minimize window - 'alt + f9'
8. Toggle maximization state - 'alt + f10'

Fanboys!

2011-07-05T19:49:00.002+04:00

Couldn't resist:

IDEA candy - column mode

2011-04-20T20:22:00.012+04:00

Foreword;

Column mode editing;

Foreword

IntelliJ IDEA contains uncountable number of features and most of them are unknown to the end-users. I'm going to talk about one of them that is quite useful under some circumstances.

Column mode editing

It's rather often that we want to perform similar action on a number of subsequent lines. For example we may have a private static class that was used internally and holds data at public final fields. Let's imagine that we want to make it public and change fields visibility from 'public' to 'private' and provide corresponding getters. The later can be done quickly via 'generate getters' feature and the former can be achieved by the following:

Select target modifiers at column mode;

Type 'private';

Here is a small video that illustrates that:

It's also possible to perform column selection by left mouse button holding Alt. In example below we have a newly introduced method that overloads existing one and uses default value as the one of the arguments. Javadoc stub is generated by IntelliJ and we want to copy description from the remained parameters. The algorithm is pretty simple:

Copy target parameters description at 'column mode';

Start column mode in a place where we want to perform 'paste';

Perform paste;

One more use-case - copying to external application. IntelliJ IDEA provides 'Reformat on paste' feature that automatically adapts pasted text to the current context. However, that is not the case for external applications. So, we can select the text at column mode in order to avoid unnecessary indentation then:

IDEA candy - custom context menu

2011-04-19T21:38:00.007+04:00

Foreword;

The tip;

Foreword

IDEA provides a great number of features and is very customizable. Today I'm going to talk about ability to customize context menus for your needs and reduce necessity to use a mouse even more.

The tip

Suppose you use particular actions rather often and want to be able to invoke them quickly. One solution is to assign dedicated shortcut to every action but number of convenient key combinations is not too big and most of them are already assigned to the useful actions. IntelliJ IDEA has a solution for that - custom quick lists. Here is a detailed instruction:

Say, I realize that I frequently use set of vcs-related operations. I want to be able to call them quickly. First of all, create new custom quick list:

Next step is to assign that newly created quick list to the convenient shortcut. My choice is 'Ctrl+Shift+Q' because it's rather convenient and is not used at default IDEA keymap:

Save the changes and we're done. Now it's possible to quickly invoke all of the actions configured for the quick list. Press assigned shortcut ('Ctrl+Shift+Q' at our example) and custom context menu appears:

The feature becomes very useful when you get accustomed to it a little. For example, I automatically press the following sequence to see file history: 'Ctrl+Shift+Q Enter'; 'Ctrl+Shift+Q down Enter' for 'annotate' etc.

The Black Keys

2011-04-15T14:51:00.002+04:00

Recently found these guys. Like them very much so far:

Intellij IDEA X is here

2010-12-09T17:15:00.001+03:00

First release of the most intelligent IDE made with my active participation is here - IntelliJ IDEA 10 Released. New Decade of Evolution Ahead

Free time

2010-09-24T15:16:00.002+04:00

Sorry for being absent here for so long. Blizzard released StartCraft II eventually and I'm completely lost there :)

IDEA candy - find usages trick

2010-07-02T21:28:00.005+04:00

Foreword;

The trick;

Foreword

I rather often use 'Find Usages' ('Alt+F7') at IDEA. I like it more than 'Show Usages' ('Ctrl+Alt+F7') because the former keeps search results and it's possible to navigate between them easily without necessity to repeat the search.

However, this functionality may be configured in a way to get even better user experience.

The trick

It's not too seldom to get a single result from 'Find Usages' and it's not convenient to view separate panel with it then:

I never noticed that we can configure 'Find Usages' dialog in order to get a better behavior exactly at situation like this - there is a small check box at the dialog shown when you press 'Alt+F7' - 'Skip results tab with one usage':

Let's perform the search now and IDE directly points us to the single found match:

IDEA candy - Highlighting by exception

2010-07-02T20:28:00.008+04:00

Foreword;

From 'throws';

From 'catch';

Foreword

It's been quite a long time since I wrote here last time. The reason is quite simple - I work hard on a new exciting IDEA feature - soft wraps and spend most of my free time to rewriting syntax highlighter.

I became git fun as I started to use it at work, so, the highlighter is hosted on github now - web-view.
It's main features are:

pleasant UI;

performance;

I'll provide more details about the project as the first milestone is over.

Anyway, I want to continue my blogging activity and going to talk about new cool IDEA features I encountered recently.

From 'throws'

It's rather common situtation when you see a method that declares multiple exceptions at 'throws' clause but you don't have a clue on what expresssions may actually throw them. IDEA can provide information about that.

Example.

Consider that you have a code like the one below:


package org.denis;

import java.io.FileNotFoundException;
import java.net.SocketException;

/**
 * @author Denis Zhdanov
 * @since Jul 2, 2010
 */
public class TestClass {
    
    public void test() throws FileNotFoundException, SocketException {
        method1();
        method2();
        method3();
        method4();
    }
    
    private void method1() throws FileNotFoundException {}
    private void method2() throws SocketException {}
    private void method3() throws SocketException {}
    private void method4() throws FileNotFoundException {}
}

You can see that 'test()' method declares two checked exceptions at 'throws' clause but it may be hard to understand what expressions may throw it, especially if method body is rather large and involves calls to other classes.

It's possible to do the following to relief the analysis:

Put caret on method's 'throws' clause;

Press 'Ctrl+Shift+F7' ('Highlight usages in a file');

Result:

We need to decide what exactly should be highlighted. The options are:

highlight all expressions that may throw checked exceptions declared at 'throws';

highlight expressions that may throw checked exception of particular type;

Let's highlight, for example, all expressions that may throw FileNotFoundException:

IDEA also supports IS-A relation during highlighting. E.g. all expressions that may throw FileNotFoundExceptions are highlighted when we ask to show expressions that may throw IOException:

From 'catch'

Similar capability for highlighting expressions by checked exception they may throw is provided for 'catch' blocks. Just put caret on a 'catch' keyword of the target clause and press 'Ctrl+Shift+F7'. Result:

P.S. I already adopted all IDEA features discovered during working at JetBrains and use them all the time. It's hard to imagine how to live without 'Step Into', 'Step to Cursor', 'Join Lines' etc :)

IDEA candy - Harnessing debugger

2010-05-26T22:39:00.005+04:00

Foreword;

Smart step into;

Run to cursor;

Foreword

This article contains convenient tricks that may be used during debugging under IDEA. I've been IDEA user for more than five years but got know about them only today. They are so cool that I believe I use them all the time now.

Smart step into

There is a possible situation that break point is set for the statement that contains multiple method calls. Consider example below:


package com.spring.example.test;

public class MyTest {

    public static void main(String[] args) {
        MyTest test = new MyTest();
        test.bar(test.baz(test), test.foo());
        System.out.println(test.foo());
        System.out.println(test);
    }

    public MyTest foo() {
        return this;
    }

    public MyTest bar(MyTest ... t) {
        return this;
    }

    public MyTest baz(MyTest t) {
        return t;
    }
}

We can set break point to the line containing statement 'test.bar(test.baz(test), test.foo());', start the application and wait for break point hit.

We can go into method body now via 'Step Into' action ('F7' shortcut), however, we'll be dispatched to the first method body ('bar()'). It's possible that we want to proceed to 'foo()'/'baz()' instead.

I used to do the following at such situations - skip any number of uninteresting calls via performing 'Step Into' + 'Step Out' ('Shift + F8'). I was really surprised that IDEA provides much more convenient way to manage that - 'Main Menu -> Run -> Smart Step Into' ('Shift + F7' shortcut). Here is its execution result:

I.e. we can choose target method which body should be inspected. Really enjoy this feature!

Run to cursor

Another cool debugger feature I want to talk about is 'Run to cursor'. Consider the same code as above. Suppose that we setup breakpoints as mentioned at screenshot below, start application and wait while the first one is hit:

We can ask to proceed debugging and automatically pause when any of conditions below is met:

control flow reaches the line where editor caret is located at the moment;

any existing break point is hit before condition above;

I.e. we can execute 'Main Menu -> Run -> Run to Cursor' ('Alt + F9' shortcut) - that produces behavior described above. Here break point at 'baz()' method is reached before the line where editor caret is located now, hence, debug session automatically stops there.

However, it's possible to execute 'Force Run to Cursor' ('Ctrl + Alt + F9') - that makes debugger to temporary ignore any intermediate breakpoints and stop exactly at the line with caret.

I used to use the following trick before - set break point at target line, perform 'Resume Debug' ('F9'), remove break point. Will make a habit to use feature above instead since it's provide much more convenient way to achieve the same result and is more powerful in that it allows to ignore intermediate break points.

IDEA candy - Live code formatting

2010-05-15T15:43:00.012+04:00

Foreword;

Horizontal code block move;

'Indent Lines' action;

'Join Lines' action;

'Unwrap' action;

Foreword

I'm continuing the theme of describing IDEA features new to me and going to talk about various live code formatting facilities provided out of the box.

Horizontal code block move

It's possible to perform horizontal move of code located at current line (selected multiline code) to the standard indentation value (defined via 'Settings -> Code Style -> General -> Indent'). Move to right is performed via pressing 'Tab'; move to left via 'Shift + Tab'.

Example: consider the following class:


public class FormattingTest {
    public void test(int[] data) {
        if (data[0] > 0 && data[1] < 10 
                && data[2] > 4 && data[2] < 6
                && data[3] > 18 && data[3] < 20) 
        {                
                System.out.println("crazy condition is satisfied");        
        }
    }
}

Suppose you want last line at 'if' condition section to have additional indent. Put cursor to it and press 'Tab'. Result:


public class FormattingTest {
    public void test(int[] data) {
        if (data[0] > 0 && data[1] < 10
                && data[2] > 4 && data[2] < 6
                    && data[3] > 18 && data[3] < 20)
        {
                System.out.println("crazy condition is satisfied");        
        }
    }
}

Suppose you want to have the second and the third lines of 'if' condition to have one more additional indent. Select them and press 'Tab' again:

Result:


public class FormattingTest {
    public void test(int[] data) {
        if (data[0] > 0 && data[1] < 10
                    && data[2] > 4 && data[2] < 6
                        && data[3] > 18 && data[3] < 20)
        {
                System.out.println("crazy condition is satisfied");        
        }
    }
}

You can perform line(s) code move to left via pressing 'Shit + Tab' instead of 'Tab'.

'Indent Lines' action

Let's continue with our example - it's 'if' condition clause contains two lines that are indented too far to the right now. We'd like to fix indentation in accordance with current formatting settings (i.e. make both lines to have single indent to the first 'if' line). There are two ways to go - the first one is to reformat the code via 'Reformat Action' ('Ctrl + Alt + L'). This is rather ubiqutious approach known to most of IDEA users. It's drawback is in its power - it can introduce/remove line breaks in accordance with current formatting options and we may don't want that.

However, there is a dedicated action that just fixes indentation for selected code (active line). Select target code to indent:

Press 'Ctrl + Alt + I' now - 'Indent Lines' action. Result:


public class FormattingTest {
    public void test(int[] data) {
        if (data[0] > 0 && data[1] < 10
                && data[2] > 4 && data[2] < 6
                && data[3] > 18 && data[3] < 20)
        {
                System.out.println("crazy condition is satisfied");        
        }
    }
}

'Join Lines' action

We can notice that we don't need line breaks at out 'if' condition. IDEA allows to automatically collapse multiple lines to the single one.

Example: select target lines to collapse (join):

Invoke 'Join Lines' action ('Ctrl + Shift + J'). Result:


public class FormattingTest {
    public void test(int[] data) {
        if (data[0] > 0 && data[1] < 10 && data[2] > 4 && data[2] < 6 && data[3] > 18 && data[3] < 20) {
            System.out.println("crazy condition is satisfied");        
        }
    }
}

Note that 'Join Lines' action is rather smart - it correctly handles string literals:

Before:

After 'Join Lines' is called for selection:


public class FormattingTest {
    public void test(int[] data) {
        foo("xxxxxyyyyzzzz");
    }

    private void foo(String s) {        
    }
}

Also it manages variable declaration and assignment:

Before:

After 'Join Lines':


public class FormattingTest {
    public void test() {
        int i = 12;
    }
}

Also 'Join Lines' tries to collapse multiple statements to the single one:

Before:

After 'Join Lines':


public class FormattingTest {
    public void test(int i) {
        int j = i * 14 + 3;
        System.out.println(j);
    }
}

Also there is feature request for smart processing of StringBuilder and StringBuffers - IDEA-54209.

'Unwrap' action

Last but not least cool action is 'Unwrap'. It simplifies the process of wrapping blocks removal. Consider the following example:


import java.util.concurrent.Callable;

public class FormattingTest {
    public void test(Callable<Object> task) {
        try {
            task.call();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Here method 'foo()' doesn't declare any checked exceptions but calls Callable.call() that declares Throwable. We wrapped the call into try/catch block initially but decide to throw the Throwable to the upper stack now.

We do the following then:

Remove unnecessary try/catch - move caret inside 'try' block and invoke 'Unwrap' action ('Ctrl + Shift + Del'):

Result:


import java.util.concurrent.Callable;

public class FormattingTest {
    public void test(Callable<Object> task) {
        task.call();
    }
}

Then we can add 'throws Throwable' to the method signature using 'Add Exception to Method Signature' quickfix - put the caret to the problem call ('task.call()') and press 'Alt + Enter':

Result:


import java.util.concurrent.Callable;

public class FormattingTest {
    public void test(Callable<Object> task) throws Exception {
        task.call();
    }
}

Develop with pleasure! :)

IDEA candy - Analyze external stack trace

2010-05-15T13:25:00.007+04:00

Foreword;

Usage;

Foreword

I've been IDEA user for more than five years but still discover new nice features with it. The rate of that discovering is increased since I've become IDEA developer because I work with people that implemented those features and, more importantly, use them in every day programming. So, I'm starting to blog about IDEA candies that are new to me.

Usage

I encounter the following use-case rather often - someone reports a problem and provides its stack-trace. IDEA allows to view it with convenient facility to directly navigate to target source code location.

Let me illustrate that. Suppose you want to help to solve a problem - e.g. this forum thread contains stack trace:

java.lang.ArrayIndexOutOfBoundsException: -1
at org.springframework.core.MethodParameter.getParameterType(MethodParameter.java:154)
at org.springframework.core.convert.TypeDescriptor.getType(TypeDescriptor.java:190)
at org.springframework.core.convert.TypeDescriptor.isTypeAssignableTo(TypeDescriptor.java:525)
at org.springframework.core.convert.TypeDescriptor.isMap(TypeDescriptor.java:283)
at org.springframework.expression.spel.ast.Indexer.getValueInternal(Indexer.java:92)
at org.springframework.expression.spel.ast.CompoundExpression.getValueInternal(CompoundExpression.java:57)
at org.springframework.expression.spel.ast.SpelNodeImpl.getValue(SpelNodeImpl.java:93)
at org.springframework.expression.spel.standard.SpelExpression.getValue(SpelExpression.java:71)
at net.youngdev.springutils.expression.SpELUtilsTest.testGetValue(SpELUtilsTest.java:37)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:616)
at junit.framework.TestCase.runTest(TestCase.java:154)
at junit.framework.TestCase.runBare(TestCase.java:127)
at junit.framework.TestResult$1.protect(TestResult.java:106)
at junit.framework.TestResult.runProtected(TestResult.java:124)
at junit.framework.TestResult.run(TestResult.java:109)
at junit.framework.TestCase.run(TestCase.java:118)
at org.eclipse.jdt.internal.junit.runner.junit3.JUnit3TestReference.run(JUnit3TestReference.java:130)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)

You can copy the stack trace to the clipboard and view it at IDEA:

Open 'Analyze stacktrace' dialog via 'Main Menu -> Analyze -> Analyze Stacktrace':

Paste target stack trace and press 'Ok' button:

Check that analysed stack trace appears at 'Debug' panel - it contains clickable links to the source code (if source file for corresponding class is configured for the project):

You can also see that IDEA folds infrastructure calls (reflection processing, groovy internal processing etc) as well.

Groovy features, part 3 - method gotchas

2010-04-28T20:38:00.012+04:00

Foreword;

Operator-like methods;

Groovy Equals;

Multimethods;

Overloaded operators;

Optional parameters;

Vararg methods;

Named parameters;

Constructors with named parameters;

Constructors with positional parameters;

Foreword

This is a regular article produced on Groovy exploration way. We'll talk about Groovy method calls processing here.

Previous part may be found here - Groovy features, part 2 - java beans

Operator-like methods

Groovy offers convenient call syntax for predefined set of methods. It looks like operator appliance at source code level but is compiled to a method call. Example:


Integer i = 1;
Integer j = 2;
println i.class
println j.class
println i + j

Output:


class java.lang.Integer
class java.lang.Integer
3

We can see that it looks like '+' operator is applied to two objects of type 'java.lang.Integer', howver, it's transformed to call 'i.plus(j)'. I.e. Groovy automatically converts '+' defined at source level to invocation of 'plus()' method at runtime.

That means that it's possible to declare such a method at custom class and use operator-like syntax for it:


class FirstNumberWrapper {
  Number i

  def plus(j) {
    println "FirstNumberWrapper.plus($j) is called"
    new FirstNumberWrapper(i: i + j)
  }

  String toString() {"'wrapper for $i'"}
}

class SecondNumberWrapper {
  Number i

  String toString() {"'wrapper for $i'"}
}

first = new FirstNumberWrapper(i: 1)
second = new SecondNumberWrapper(i: 2)

println "Adding 3 to first wrapper ($first)..."
first += 3
println "done. Result: $first"

println "Adding 3 to second wrapper ($second)..."
second += 3

Output:


Adding 3 to first wrapper ('wrapper for 1')...
FirstNumberWrapper.plus(3) is called
done. Result: 'wrapper for 4'
Adding 3 to second wrapper ('wrapper for 2')...
Caught: groovy.lang.MissingMethodException: No signature of method: SecondNumberWrapper.plus() is applicable for argument types: (java.lang.Integer) values: [3]
 at GroovyTestScript.run(GroovyTestScript.groovy:26)

Here is a complete list of method name - operator sign mappings:

Operator	Method
a + b	a.plus(b)
a - b	a.minus(b)
a * b	a.multiply(b)
a / b	a.div(b)
a % b	a.mod(b)
a++; ++a	a.next()
a--; --a	a.previous()
a ** b	a.power(b)
a \| b	a.or(b)
a & b	a.and(b)
a ^ b	a.xor(b)
~a	a.negate()
a[b]	a.getAt(b)
a[b] = c	a.putAt(b, c)
a << b	a.leftShift(b)
a >> b	a.rightShift(b)
a >>> b	a.rightShiftUnsigned(b)
switch (a) { case b: }	b.isCase(a)
a == b	a.equals(b)
a != b	!a.equals(b)
a <=> b	a.compareTo(b)
a > b	a.compareTo(b) > 0
a >= b	a.compareTo(b) >= 0
a < b	a.compareTo(b) < 0
a <= b	a.compareTo(b) <= 0
a as type	a.asType(typeClass)

Groovy Equals

I want to pay special attention to ' == ' operator processing - it is automatically mapped to 'equals()' call. You should use is() method to compare objects by identity:


s1 = "xxx"
s2 = new String("xxx")
s3 = s2

println s1 == s2  // true
println s1.is(s2) // false

println s2 == s3  // true
println s2.is(s3) // true

Multimethods;

Java selects target overloaded method at compile-time, hence, it looks at static reference type. Consider the following example:


class GeneralItem {}
class SubItem extends GeneralItem {}

class BaseService {
    public void test(Object data) {
        System.out.println("BaseService.test()");
    }
}

class SubService extends BaseService {
    public void test(String data) {
        System.out.println("SubService.test()");
    }
}

public class JavaTest {
    public static void main(String[] args) {
        BaseService subService = new SubService();
        subService.test(""); // prints 'BaseService.test()'
    }
}

Here actual object type is 'SubService' and argument type is 'String'. However, BaseService.test() is called because static type of 'SubService' reference is 'BaseService', hence, algorithm that resolves overloaded method to use selects 'BaseService.test()'.

We can perform the same test in Groovy and see that 'SubService.test()' is printed. The reason is that Groovy resolves all method calls in runtime, hence, it checks both actual argument types and target reference type. This is really cool!

Overloaded operators;

Multimethods allow to do the following nice trick - it's possible to define overloaded versions of base operator methods. Necessary version is automatically chose in runtime:


class NumberWrapper {
  def number;

  def multiply(Number number) {
    println 'muliply(Number)'
    new NumberWrapper(number: this.number * number)
  }

  def multiply(NumberWrapper wrapper) {
    println 'muliply(NumberWrapper)'
    new NumberWrapper(number: number * wrapper.number)
  }

  def String toString() {
    "wrapper for $number"
  }
}

def wrapper1 = new NumberWrapper(number: 1)
def wrapper2 = new NumberWrapper(number: 2)

println(wrapper1 * wrapper2)
println(wrapper1 * 3)

Output:


muliply(NumberWrapper)
wrapper for 2
muliply(Number)
wrapper for 3

Optional parameters

It's possible to define default parameters values for Groovy method arguments. Any number of such parameters can be introduced. The only restriction is that they should be trailing within the method definition:


def sum(first, second, third = 3, forth = 4) {
    println "sum($first, $second, $third, $forth)"
}

sum(10, 20)
sum(10, 20, 30)
sum(10, 20, 30, 40)

Output:


sum(10, 20, 3, 4)
sum(10, 20, 30, 4)
sum(10, 20, 30, 40)

Vararg methods

Groovy supports java syntax sugar for var-arg parameter delivered as array at runtime. Moreover, any trailing array parameter is treated as vararg parameter with 0..* cardinality:


def test1(first, ... trailing) {
    println "test1($first, $trailing)"
}

def test2(first, Object[] trailing) {
    println "test2($first, $trailing)"
}

test1(1, 2, 3, 4)
test1(1)

test2(10, 20, 30, 40)
test2(10)

Output:


test1(1, [2, 3, 4])
test1(1, [])
test2(10, [20, 30, 40])
test2(10, [])

Named parameters

All method calls above used so-called 'positional parameters', i.e. parameter meaning is defined by its position at method call expression. However, it's possible to use rather convenient alternative to that - 'named parameters'. Method caller supplies every parameter with it's name and it's position doesn't matter at all. Moreover, it's even possible to provide support for optional parameters within method implementation:


def test(Map args) {
  args.get('quantity', 1) // Provide default value for 'quantity' argument
  println "Total price: ${args.quantity * args.price}"
}

test(quantity: 3, price: 2)
test(price: 4, quantity: 2)
test(price: 10)

Output:


Total price: 6
Total price: 8
Total price: 10

Constructors with named parameters

Groovy allows to create instances of classes with 'named parameters syntax' for their properties. The only restriction for such usage is that class which object is constructed should have no-args constructor:


class TestClass {
  String property1, property2

  def String toString() {
    return "property1: $property1; property2: $property2";
  }
}

println new TestClass(property1: 'xxx')
println new TestClass(property2: 'zzz', property1: 'xxx')

Output:


property1: xxx; property2: null
property1: xxx; property2: zzz

Constructors with positional parameters

There is convenient syntax for calling constructors with positional parameters as well.

The main idea is that every time Groovy sees the need to convert list to some other type it tries to call appropriate type's constructor with all list items as arguments (at same order). Such a conversion may be performed either explicitly (via 'as' operator) or implicitly:


class TestClass {
  String property1, property2

  def TestClass(property1, property2) {
    this.property1 = property1
    this.property2 = property2
  }

  def String toString() {
    return "property1: $property1; property2: $property2";
  }
}

def obj1 = [1, 2] as TestClass
TestClass obj2 = ['xxx', new Date()] // Note that we use explicit variable typing here

println obj1
println obj2

Output:


property1: 1; property2: 2
property1: xxx; property2: Mon May 10 23:14:43 MSD 2010

Groovy features, part 2 - java beans

2010-04-21T21:39:00.013+04:00

Foreword;

Property definition

Custom getters/setters

Working with properties

Read-only properties

Convenient properties initialisation

Declare instance/static fields

Bound and constrained properties support

Foreword

I'm continuing my dairy of groovy exploration, here is a second part that talks about groovy syntax sugar for JavaBeans support. Feel free to check the previous topic - Exploring Groovy, part 1 - common stuff. Next article - Groovy features, part 3 - method gotchas

Property definition

It's possible to define JavaBean property for the groovy class with relaxed groovy supported-syntax. Basically, 'property' here means private field and implicitly generated and used getter/setter.

Two property types are supported - 'typed' and 'untyped'.

Here is an example that shows property definition:


package org.denis

class GroovyTestClass {
  static def staticUntypedProperty;
  static long staticTypedProperty;

  def untypedInstanceProperty;
  Integer typedInstanceProperty;
}

We can check structure of the class generated by Groovy for such a source:


$ javap org.denis.GroovyTestClass
Compiled from "GroovyTestClass.groovy"
public class org.denis.GroovyTestClass extends java.lang.Object implements groovy.lang.GroovyObject{
    public static final java.lang.Class $ownClass;
    public static java.lang.Long __timeStamp;
    public static java.lang.Long __timeStamp__239_neverHappen1271917491545;
    public org.denis.GroovyTestClass();
    protected groovy.lang.MetaClass $getStaticMetaClass();
    public groovy.lang.MetaClass getMetaClass();
    public void setMetaClass(groovy.lang.MetaClass);
    public java.lang.Object invokeMethod(java.lang.String, java.lang.Object);
    public java.lang.Object getProperty(java.lang.String);
    public void setProperty(java.lang.String, java.lang.Object);
    static {};
    public static java.lang.Object getStaticUntypedProperty();
    public static void setStaticUntypedProperty(java.lang.Object);
    public static long getStaticTypedProperty();
    public static void setStaticTypedProperty(long);
    public java.lang.Object getUntypedInstanceProperty();
    public void setUntypedInstanceProperty(java.lang.Object);
    public java.lang.Integer getTypedInstanceProperty();
    public void setTypedInstanceProperty(java.lang.Integer);
    public void super$1$wait();
    public java.lang.String super$1$toString();
    public void super$1$wait(long);
    public void super$1$wait(long, int);
    public void super$1$notify();
    public void super$1$notifyAll();
    public java.lang.Class super$1$getClass();
    public java.lang.Object super$1$clone();
    public boolean super$1$equals(java.lang.Object);
    public int super$1$hashCode();
    public void super$1$finalize();
    static java.lang.Class class$(java.lang.String);
}

I.e. Groovy generated getters and setters for both instance and static properties.

Custom getters/setters

It's also possible to define custom getters/setters with desired visibility for particular property. The only trick here is to explicitly declare return type as 'void' for setters because methods declared via 'def' have return type 'Object' by default:


class GroovyTestClass {
  int typedProperty;
  def untypedProperty;

  // Custom setter.
  protected void setTypedProperty(value) {
    typedProperty = value
  }

  // Custom getter
  def getUntypedProperty() {
    untypedProperty
  }
}

Working with properties

Groovy not only generates getters and setters for properties, it also implicitly uses them during working with properties:


package org.denis

class GroovyTestClass {
  int typedProperty;
  def untypedProperty;

  void setTypedProperty(value) {
    println "'typedProperty' is set to '$value' via custom setter"
    typedProperty = value
  }

  def getUntypedProperty() {
    println "'untypedProperty' is accessed via via custom getter"
    untypedProperty
  }
}

class AnotherGroovyTestClass {

  def static void main(args) {
    def test = new GroovyTestClass()
    println "Typed property: $test.typedProperty"
    test.typedProperty = 1
    println "Typed property: $test.typedProperty"

    println "Untyped property: $test.untypedProperty"
    test.untypedProperty = 2
    println "Untyped property: $test.untypedProperty"
  }
}

We get the following output if we run AnotherGroovyTestClass:


Typed property: 0
'typedProperty' is set to '1' via custom setter
Typed property: 1
'untypedProperty' is accessed via via custom getter
Untyped property: null
'untypedProperty' is accessed via via custom getter
Untyped property: 2

Note: direct access to the property is used every time it is accessed at compile time from the same class via explicit or implicit 'this' reference:


package org.denis

class GroovyTestClass {
  def untypedProperty;

  def static void main(args) {
    def test = new GroovyTestClass()
    println 'Direct property access from static context'
    println test.untypedProperty
    println ''
    test.indirectPropertyAccess()
  }

  def indirectPropertyAccess() {
    println 'Direct property access from instance context'
    println untypedProperty
  }

  def getUntypedProperty() {
    println "'untypedProperty' is accessed via via custom getter"
    untypedProperty
  }
}

Output:


Direct property access from static context
'untypedProperty' is accessed via via custom getter
null

Direct property access from instance context
null

Also there is a trick to access the property directly from outside the class (i.e. ignore all custom getters/setters if any). That is done via '.@' operator:


package org.denis

class GroovyTestClass {
  def untypedProperty;

  void setUntypedProperty(value) {
    println "'untypedProperty' is set to '$value' via custom setter"
    untypedProperty = value
  }

  def getUntypedProperty() {
    println "'untypedProperty' is accessed via via custom getter"
    untypedProperty
  }
}

class AnotherGroovyTestClass {

  def static void main(args) {
    def test = new GroovyTestClass()
    println 'Setting property using standard syntax'
    test.untypedProperty = 1
    println 'Getting property using standard syntax'
    println "Property: $test.untypedProperty"

    println()

    println 'Setting property using non-standard syntax'
    test.@untypedProperty = 'xxx'
    println 'Getting property using non-standard syntax'
    println "Property: ${test.@untypedProperty}"
  }
}

Output:


Setting property using standard syntax
'untypedProperty' is set to '1' via custom setter
Getting property using standard syntax
'untypedProperty' is accessed via via custom getter
Property: 1

Setting property using non-standard syntax
Getting property using non-standard syntax
Property: xxx

Read-only properties

Often we need to make property read-only for external clients, i.e. define only getter for it. We can achieve that in Groovy by using 'final' keyword with the property:


package org.denis

class GroovyTestClass {
  def final myProperty = 'xxx'
}

class AnotherGroovyTestClass {

  def static void main(args) {
    def test = new GroovyTestClass()
    println 'Getting property...'
    println "Property: $test.myProperty"
    println 'Setting property...'
    test.myProperty = 'xxx' // fails at runtime because the property is read-only
  }
}

Output:


Getting property...
Property: xxx
Setting property...
Exception in thread "main" groovy.lang.ReadOnlyPropertyException: Cannot set readonly property: myProperty for class: org.denis.GroovyTestClass
 at groovy.lang.MetaClassImpl.setProperty(MetaClassImpl.java:2406)
 at groovy.lang.MetaClassImpl.setProperty(MetaClassImpl.java:3307)
 at org.denis.GroovyTestClass.setProperty(GroovyTestClass.groovy)
 at org.codehaus.groovy.runtime.InvokerHelper.setProperty(InvokerHelper.java:179)
 at org.codehaus.groovy.runtime.ScriptBytecodeAdapter.setProperty(ScriptBytecodeAdapter.java:483)
 at org.denis.AnotherGroovyTestClass.main(GroovyTestClass.groovy:14)

Please note that read-only property still can be accessed from the 'instance' context of the same class:


package org.denis

class GroovyTestClass {

  final def myProperty = 'xxx'

  def static void main(args) {
    def test = new GroovyTestClass()
    println "Initial read-only property value: '$test.myProperty'"
    print 'Setting read-only property from instance context...'
    test.setPropertyFromInstanceContext(2)
    println "done. Current read-only property value: '$test.myProperty'"
    println 'Trying to set read-only property value from static context...'
    test.myProperty = 3 // fails at runtime because we attempt to set read-only property value from static context
  }

  def setPropertyFromInstanceContext(value) {
    this.myProperty = value
  }
}

Output:


Initial read-only property value: 'xxx'
Setting read-only property from instance context...done. Current read-only property value: '2'
Trying to set read-only property value from static context...
Exception in thread "main" groovy.lang.ReadOnlyPropertyException: Cannot set readonly property: myProperty for class: org.denis.GroovyTestClass
 at groovy.lang.MetaClassImpl.setProperty(MetaClassImpl.java:2406)
 at groovy.lang.MetaClassImpl.setProperty(MetaClassImpl.java:3307)
 at org.denis.GroovyTestClass.setProperty(GroovyTestClass.groovy)
 at org.codehaus.groovy.runtime.InvokerHelper.setProperty(InvokerHelper.java:179)
 at org.codehaus.groovy.runtime.ScriptBytecodeAdapter.setProperty(ScriptBytecodeAdapter.java:483)
 at org.denis.GroovyTestClass.main(GroovyTestClass.groovy:14)

That means that it's possible to define a property with, say, public getter and protected setter:


package org.denis

class GroovyTestClass {

  final def myProperty = 'xxx'

  def static void main(args) {
    def test = new GroovyTestClass()
    println "Initial property value: '$test.myProperty'"
    print 'Setting property from instance context...'
    test.myProperty = 2 // Allowed because of 'protected' setter visibility
    println "done. Current property value: '$test.myProperty'"
  }

  protected void setMyProperty(value) {
    this.myProperty = value
  }
}

Output:


Initial property value: 'xxx'
Setting property from instance context...done. Current property value: '2'

Convenient properties initialisation

Properties may be initialised using the following convenient syntax:


package org.denis

class GroovyTestClass {

  def property1
  def property2

  def static void main(args) {
    def test = new GroovyTestClass(property1: 1, property2: 'xxx')
    println "Properties are initialized: $test.property1 $test.property2"
  }
}

It is executed as if new object is created and target properties setters are called on it. Here is equivalent java code for that:


test = new GroovyTestClass();
test.setProperty1(1);
test.setProperty2("xxx");

Declare instance/static fields

It's cool to have relaxed syntax for declaring and using properties but sometimes we need just fields, i.e. we don't want Groovy to generate and use getters and setters. We can achieve that simply by almost the same syntax as we used for properties. The only difference is that we explicitly define field visibility:


package org.denis

class GroovyTestClass {
  public def property1
  protected String property2
}


$ javap org.denis.GroovyTestClass
Compiled from "GroovyTestClass.groovy"
public class org.denis.GroovyTestClass extends java.lang.Object implements groovy.lang.GroovyObject{
    public java.lang.Object property1;
    protected java.lang.String property2;
    public static java.lang.Long __timeStamp;
    public static java.lang.Long __timeStamp__239_neverHappen1271924017378;
    public org.denis.GroovyTestClass();
    public java.lang.Object this$dist$invoke$2(java.lang.String, java.lang.Object);
    public void this$dist$set$2(java.lang.String, java.lang.Object);
    public java.lang.Object this$dist$get$2(java.lang.String);
    protected groovy.lang.MetaClass $getStaticMetaClass();
    public groovy.lang.MetaClass getMetaClass();
    public void setMetaClass(groovy.lang.MetaClass);
    public java.lang.Object invokeMethod(java.lang.String, java.lang.Object);
    public java.lang.Object getProperty(java.lang.String);
    public void setProperty(java.lang.String, java.lang.Object);
    static {};
    public void super$1$wait();
    public java.lang.String super$1$toString();
    public void super$1$wait(long);
    public void super$1$wait(long, int);
    public void super$1$notify();
    public void super$1$notifyAll();
    public java.lang.Class super$1$getClass();
    public java.lang.Object super$1$clone();
    public boolean super$1$equals(java.lang.Object);
    public int super$1$hashCode();
    public void super$1$finalize();
    static java.lang.Class class$(java.lang.String);
}

Also note that it's still allowed to explicitly define getter/setter and Groovy automatically picks it up during field access:


package org.denis

class GroovyTestClass {

  public def property1
  protected String property2

  def static void main(args) {
    def test = new GroovyTestClass()
    println "Current 'property1' field value is $test.property1"
    println "Setting value to the 'property1' field..."
    test.property1 = 'xxx'
    println "Current 'property1' field value is $test.property1"
  }

  public void setProperty1(value) {
    println "setProperty1() is called with value '$value'"
    property1 = value
  }
}

Output:


Current 'property1' field value is null
Setting value to the 'property1' field...
setProperty1() is called with value 'xxx'
Current 'property1' field value is xxx

Bound and constrained properties support

Groovy provides convenient way to define bound and constrained properties:

bound property - property which change fires notification for interested listeners;

constrained property - property which change may be prevented;

@Bindable

@Vetoable


package org.denis

import groovy.beans.Bindable
import groovy.beans.Vetoable
import java.beans.PropertyVetoException

class GroovyTestClass {

  @Bindable def property1
  @Vetoable Integer property2

  def static void main(args) {
    def test = new GroovyTestClass()

    test.propertyChange = {
      println "Got notification that '$it.propertyName' property value is set to '$it.newValue'"
    }

    test.vetoableChange = {
      if (it.newValue <= 0) {
        throw new PropertyVetoException("Detected attempt to set non-positive value ($it.newValue) to the property"
                                           + "'$it.propertyName'. Rejected.", it)
      }
    }

    println "Setting 'xxx' value to the 'property1' field..."
    test.property1 = 'xxx'

    println "Setting '1' value to the 'property1' field..."
    test.property2 = 1

    println "Setting '-1' value to the 'property1' field..."
    test.property2 = -1
  }
}


Setting 'xxx' value to the 'property1' field...
Got notification that 'property1' property value is set to 'xxx'
Setting '1' value to the 'property1' field...
Setting '-1' value to the 'property1' field...
Exception in thread "main" java.beans.PropertyVetoException: Detected attempt to set non-positive value (-1) to the property'property2'. Rejected.
 at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
 at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39)
 at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27)
 at java.lang.reflect.Constructor.newInstance(Constructor.java:513)
 at org.codehaus.groovy.reflection.CachedConstructor.invoke(CachedConstructor.java:77)
 at org.codehaus.groovy.reflection.CachedConstructor.doConstructorInvoke(CachedConstructor.java:71)
 at org.codehaus.groovy.runtime.callsite.ConstructorSite$ConstructorSiteNoUnwrap.callConstructor(ConstructorSite.java:84)
 at org.codehaus.groovy.runtime.callsite.CallSiteArray.defaultCallConstructor(CallSiteArray.java:52)
 at org.codehaus.groovy.runtime.callsite.AbstractCallSite.callConstructor(AbstractCallSite.java:192)
 at org.codehaus.groovy.runtime.callsite.AbstractCallSite.callConstructor(AbstractCallSite.java:204)
 at org.denis.GroovyTestClass$_main_closure2.doCall(GroovyTestClass.groovy:21)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
 at java.lang.reflect.Method.invoke(Method.java:597)
 at org.codehaus.groovy.reflection.CachedMethod.invoke(CachedMethod.java:88)
 at groovy.lang.MetaMethod.doMethodInvoke(MetaMethod.java:233)
 at org.codehaus.groovy.runtime.metaclass.ClosureMetaClass.invokeMethod(ClosureMetaClass.java:273)
 at groovy.lang.MetaClassImpl.invokeMethod(MetaClassImpl.java:886)
 at groovy.lang.Closure.call(Closure.java:276)
 at org.codehaus.groovy.runtime.ConvertedClosure.invokeCustom(ConvertedClosure.java:51)
 at org.codehaus.groovy.runtime.ConversionHandler.invoke(ConversionHandler.java:79)
 at $Proxy1.vetoableChange(Unknown Source)
 at java.beans.VetoableChangeSupport.fireVetoableChange(VetoableChangeSupport.java:335)
 at java.beans.VetoableChangeSupport.fireVetoableChange(VetoableChangeSupport.java:252)
 at java.beans.VetoableChangeSupport.fireVetoableChange(VetoableChangeSupport.java:273)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
 at java.lang.reflect.Method.invoke(Method.java:597)
 at org.codehaus.groovy.runtime.callsite.PojoMetaMethodSite$PojoCachedMethodSiteNoUnwrapNoCoerce.invoke(PojoMetaMethodSite.java:229)
 at org.codehaus.groovy.runtime.callsite.PojoMetaMethodSite.call(PojoMetaMethodSite.java:52)
 at org.codehaus.groovy.runtime.callsite.CallSiteArray.defaultCall(CallSiteArray.java:40)
 at org.codehaus.groovy.runtime.callsite.PojoMetaMethodSite.call(PojoMetaMethodSite.java:54)
 at org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:133)
 at org.denis.GroovyTestClass.fireVetoableChange(GroovyTestClass.groovy)
 at org.denis.GroovyTestClass$fireVetoableChange.callCurrent(Unknown Source)
 at org.codehaus.groovy.runtime.callsite.CallSiteArray.defaultCallCurrent(CallSiteArray.java:44)
 at org.denis.GroovyTestClass$fireVetoableChange.callCurrent(Unknown Source)
 at org.denis.GroovyTestClass.setProperty2(GroovyTestClass.groovy)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
 at java.lang.reflect.Method.invoke(Method.java:597)
 at org.codehaus.groovy.reflection.CachedMethod.invoke(CachedMethod.java:88)
 at groovy.lang.MetaMethod.doMethodInvoke(MetaMethod.java:233)
 at groovy.lang.MetaClassImpl.setProperty(MetaClassImpl.java:2387)
 at groovy.lang.MetaClassImpl.setProperty(MetaClassImpl.java:3307)
 at org.denis.GroovyTestClass.setProperty(GroovyTestClass.groovy)
 at org.codehaus.groovy.runtime.InvokerHelper.setProperty(InvokerHelper.java:179)
 at org.codehaus.groovy.runtime.ScriptBytecodeAdapter.setProperty(ScriptBytecodeAdapter.java:483)
 at org.denis.GroovyTestClass.main(GroovyTestClass.groovy:33)

Exploring Groovy, part 1 - common stuff

2010-04-20T12:11:00.007+04:00

Foreword;

Semicolon;

Return;

Default visibility;

Safe navigation operator;

Boolean evaluation;

Elvis operator;

Exception handling;

Foreword

I started working at new company recently and encountered that Groovy is used for various non-performance critical tasks here. I follow the principle that leaky abstractions should be avoided whenever possible, hence, it's a time to learn Groovy.

Couple of words about it - Groovy is a dynamic language that provides concise syntax and metaprogramming facilities, is executed under JVM and completely interoperable with java code, i.e. it's possible either to use groovy from java or java from groovy. The only drawback I see for now is performance aspect - groovy heavily uses reflection, type-checks, exception-based processing. However, that may be the tool of choice for application prototyping and various support tasks like buildmastering.

I'm going to highlight groovy faetures that are the most significant for java developers that want to get familiar with groovy.

Next part - Groovy features, part 2 - java beans

Semicolon

Semicolon is almost optional in Groovy. You can use it to separate the statements if necessary. I.e. following groovy script works just fine


print('hello, ')
println('world')
print('hello '); println('one more time')

Return

'return' keyword is optional:


def test(i) { i > 0 }

value = 4
printf('%d is %spositive%n', value, test(value) ? '' : 'not ')

Default visibility

Methods and classes are public by default in groovy:


package org.denis

class GroovyTestClass {
  def test() { println 'test' }
}


projects/java/test/target$ javap org.denis.GroovyTestClass
Compiled from "GroovyTestClass.groovy"
public class org.denis.GroovyTestClass extends java.lang.Object implements groovy.lang.GroovyObject{
    public static final java.lang.Class $ownClass;
    public static java.lang.Long __timeStamp;
    public static java.lang.Long __timeStamp__239_neverHappen1271752231139;
    public org.denis.GroovyTestClass();
    public java.lang.Object test();
    protected groovy.lang.MetaClass $getStaticMetaClass();
    public groovy.lang.MetaClass getMetaClass();
    public void setMetaClass(groovy.lang.MetaClass);
    public java.lang.Object invokeMethod(java.lang.String, java.lang.Object);
    public java.lang.Object getProperty(java.lang.String);
    public void setProperty(java.lang.String, java.lang.Object);
    static {};
    public void super$1$wait();
    public java.lang.String super$1$toString();
    public void super$1$wait(long);
    public void super$1$wait(long, int);
    public void super$1$notify();
    public void super$1$notifyAll();
    public java.lang.Class super$1$getClass();
    public java.lang.Object super$1$clone();
    public boolean super$1$equals(java.lang.Object);
    public int super$1$hashCode();
    public void super$1$finalize();
    static java.lang.Class class$(java.lang.String);
}

You can see that either GroovyTestClass or GroovyTestClass.test() visibility is public.

Safe navigation operator

Groovy offers convenient operator '?.' - it is used with object references for checking that it's not null, i.e. it returns null if it's applied to null or proceeds to the target method instead:


class Address {
  def street
}

class User {
  def name
  def address
}

user1 = new User(name: 'Guy', address: new Address(street: 'Reg Lights District'))
user2 = new User()

println 'Processing user1'
println user1.address.street
println user1.name

println 'Processing user2 with ?.'
println user2?.address?.street
println user2?.name

println 'Processing user2 without ?.'
println user2.address.street

Output:


Processing user1
Reg Lights District
Guy
Processing user2 with ?.
null
null
Processing user2 without ?.
Caught: java.lang.NullPointerException: Cannot get property 'street' on null object
 at GroovyTest.run(GroovyTest.groovy:22)

Boolean evaluation

Groovy provides special rules for using objects of various types at boolean context:


def test(value, description) {
  evaluationResult = value ? true : false;
  printf "%s '%s' evaluates to %b%n", description, value, evaluationResult
}

test(true, 'boolean value')
test(false, 'boolean value')
test(null, 'null reference')
test(new Object(), 'non-null reference')
test([], 'empty list')
test([1], 'non-empty list')
test([:], 'empty map')
test([1: 2], 'non-empty map')
test('', 'empty char sequence')
test('xxx', 'non-empty char sequence')
test([].iterator(), 'empty iterator')
test([1].iterator(), 'non-empty iterator')
test(new Properties().elements(), 'empty enumeration')
test(System.properties.elements(), 'non-empty enumeration')
test([1].iterator(), 'non-empty iterator')
test(0.01, 'none-zero number double value')
test(0, 'zero number double value')
test('test' =~ /es/, 'matcher with at least one match')
test('test' =~ /se/, 'matcher with no match')

Output:


boolean value 'true' evaluates to true
boolean value 'false' evaluates to false
null reference 'null' evaluates to false
non-null reference 'java.lang.Object@51e67ac' evaluates to true
empty list '[]' evaluates to false
non-empty list '[1]' evaluates to true
empty map '{}' evaluates to false
non-empty map '{1=2}' evaluates to true
empty char sequence '' evaluates to false
non-empty char sequence 'xxx' evaluates to true
empty iterator 'java.util.AbstractList$Itr@1d2c5431' evaluates to false
non-empty iterator 'java.util.AbstractList$Itr@494b6bed' evaluates to true
empty enumeration 'java.util.Hashtable$EmptyEnumerator@24ebf068' evaluates to false
non-empty enumeration 'java.util.Hashtable$Enumerator@2a313170' evaluates to true
non-empty iterator 'java.util.AbstractList$Itr@3a4c5b4' evaluates to true
none-zero number double value '0.01' evaluates to true
zero number double value '0' evaluates to false
matcher with at least one match 'java.util.regex.Matcher[pattern=es region=0,4 lastmatch=es]' evaluates to true
matcher with no match 'java.util.regex.Matcher[pattern=se region=0,4 lastmatch=]' evaluates to false

Elvis operator

There is a short form of ternary operator - '?:'. It works as follows - use left operand if it evaluates to true; use right operand otherwise:


println([]?: 'empty array')
println(null?: 'null reference')
println(''?: 'empty char sequence')
println([1]?: 'empty array')
println(new Object()?: 'null reference')
println('xxx'?: 'empty char sequence')

Output:


empty array
null reference
empty char sequence
[1]
java.lang.Object@1408a92
xxx

Exception handling

Groovy doesn't require to handle checked exceptions. Another feature is that it's possible to use more concise syntax for catching all Exceptions:


class Test {

  def test() {
    // Not obliged to declare the exception at method signature
    throw new IOException()
  }
}

test = new Test()
try {
  test.test()
} catch (ex) { // Only Exception are handled here, all Errors and Throwable are popped up to the stack
  println 'Exception is caught: ' + ex
}

Apache is hacked

2010-04-13T22:30:00.000+04:00

I read that Apache was hacked recently.

Couple of comments for that:

Really respect the way Apache team processed that - shared the information and provided detailed attack description. It's really cool that the guys don't afraid to face the music;

I don't have enough experience in 'hacking stuff' but used attack algorithm seems rather elegant, nice job :)

Jet fuel

2010-04-05T23:29:00.003+04:00

Today was my first day at new job - JetBrains company, IntelliJ IDEA project.

I've been IDEA user for more than five years and really enjoy it. It's ... interesting to be a part of the team that makes this product :)

Kittens

2010-04-01T21:34:00.008+04:00

My kittens get bigger. They look like a real cats now :)

Photos inside

Compound iterators in Scala - present and future

2010-03-23T19:38:00.003+03:00

Introduction;

Traits and Iterator trait;

Compound iterators;

Problem with compound iterators;

Solution;

Introduction

This article is about another step made by java guy to the world of Scala. It's not that hard to learn new programing language syntax but it's just a half of the deal. There is a large library as well and collections is its integral part. So, I started with them and want to share already obtained knowledge.

P.S. Significant result of checking Scala iterators is my first Scala enhancement request - Ticket #3205: Optimize performance of compound iterator created via Iterator.++()

Traits and Iterator trait

Scala has a notion of traits. Basically speaking, 'trait' is a combination of 'abstract class' and 'interface' in terms of java. Here are the main trait features from my point of view:

trait may contain either abstract or concrete methods (similar to abstract classes in java);

single class may extend multiple traits (like multiple interfaces inheritance in java);

That means that it's possible to define either abstract methods or concrete methods that are based on them. Scala Iterator trait is a classic example of such approach. It defines abstract methods 'hasNext()' and 'next()' and couple of dozens other methods that are based on them.

Compound iterators

One of concrete methods of Iterator trait is ++(). It does the following:

Receives lazily evaluated iterator;

Produces iterator that combines both current and given iterators;

Example:


object ScalaTest {

  case class MyIterator(val value: Int) extends Iterator[Int] {

    println(this + " is being constructed")

    var empty = false

    def hasNext = !empty
    def next() = if (empty) Iterator.empty.next
                 else {empty = true; value}
  }

  def main(args: Array[String]) {
    println("Creating compound iterator")
    val i = MyIterator(1) ++ MyIterator(2) ++ MyIterator(3)
    println("Created compound iterator, starting iteration...")
    while (i.hasNext) println(i.next)
  }
}

We get the following output from example above:


Creating compound iterator
non-empty iterator is being constructed
Created compound iterator, starting iteration...
1
non-empty iterator is being constructed
2
non-empty iterator is being constructed
3

That shows two things:

'Iterator.++()' method really glues iterators together;

all iterators starting from the second are evaluated lazily (that is done because 'Iterator.++()' receives its parameter 'by-name' as described at previous post);

Problem with compound iterators

'Iterator.++()' works fine from the first sight, however, important problem is hidden there.

Current implementation looks as follows:


  def ++[B >: A](that: => Iterator[B]): Iterator[B] = new Iterator[B] {
    // optimize a little bit to prevent n log n behavior.
    private var cur : Iterator[B] = self 
    // this was unnecessarily looping forever on x ++ x
    def hasNext = cur.hasNext || ((cur eq self) && {
      val it = that
      it.hasNext && {
        cur = it
        true
      }
    })
    def next() = { hasNext; cur.next() }
  }

Let's modify our example a little in order to highlight a problem:


object ScalaTest {

  case class MyIterator(val value: Int) extends Iterator[Int] {

    var empty = false

    def hasNext = {Thread.dumpStack; !empty}
    def next() = if (empty) Iterator.empty.next
                 else {empty = true; value}
  }

  def main(args: Array[String]) {
    println("Creating compound iterator")
    val i = MyIterator(1) ++ MyIterator(2) ++ MyIterator(3)
    println("Created compound iterator, starting iteration...")
    i.next
  }
}

I.e. we dump current stack on 'hasNext()' call on our iterator. Here is the output:


Creating compound iterator
java.lang.Exception: Stack trace
 at java.lang.Thread.dumpStack(Thread.java:1206)
 at net.scalatest.ScalaTest$MyIterator.hasNext(ScalaTest.scala:13)
 at scala.collection.Iterator$$anon$20.hasNext(Iterator.scala:340)
 at scala.collection.Iterator$$anon$20.hasNext(Iterator.scala:340)
 at scala.collection.Iterator$$anon$20.next(Iterator.scala:347)
 at net.scalatest.ScalaTest$.main(ScalaTest.scala:22)
 at net.scalatest.ScalaTest.main(ScalaTest.scala)
java.lang.Exception: Stack trace
 at java.lang.Thread.dumpStack(Thread.java:1206)
 at net.scalatest.ScalaTest$MyIterator.hasNext(ScalaTest.scala:13)
 at scala.collection.Iterator$$anon$20.hasNext(Iterator.scala:340)
 at scala.collection.Iterator$$anon$20.next(Iterator.scala:347)
 at scala.collection.Iterator$$anon$20.next(Iterator.scala:347)
 at net.scalatest.ScalaTest$.main(ScalaTest.scala:22)
 at net.scalatest.ScalaTest.main(ScalaTest.scala)
Created compound iterator, starting iteration...

Two things to highlight:

'hasNext()' is called two times though we only called 'next()' on compound iterator;

every call to 'hasNext()' is preceded by nested calls to 'hasNext()' on compound iterator objects;

Such behavior doesn't surprise if we check current implementation. That is a real performance bottleneck in case of large number of glued iterators.

Solution

I created alternative 'Iterator.++()' implementation that addresses problems mentioned above:


    def ++[B >: A](that: => Iterator[B]) : Iterator[B] = {

      case class Node[T](val current: () => Iterator[T]) {
        var next: Option[Node[T]] = None
        def append[U >: T](i: => Iterator[U]) : Node[U] = {
          def doAppend(to: Node[U], from: Option[Node[T]]) : Node[U] = {
            from match {
              case None => to
              case Some(n) => {val node: Node[U] = Node(n.current); to.next = Some(node); doAppend(node, n.next)}
            }
          }
          val result: Node[U] = Node(current)
          lazy val it = i
          doAppend(result, next).next = Some(Node(() => it))
          result
        }
      }

      class CombinedIterator[T](var head: Node[T]) extends Iterator[T] {

        var checkNext = true

        def hasNext = {
          checkNext = false
          if (head.current().hasNext) true
          else head.next match {
            case None => false
            case Some(x) => {head = x; hasNext}
          }
        }

        def next() = {
          if (checkNext) hasNext
          checkNext = true
          head.current().next
        }

        override def ++[B >: T](that: => Iterator[B]) = {
          new CombinedIterator(head.append(that))
        }
      }      

      val node: Node[B]= Node(() => self)
      lazy val t = that
      node.next = Some(Node(() => t))
      new CombinedIterator(node)
    }

The main idea is to avoid nested calls by building list of glued iterators on compound iterator instantiation. Also we don't call 'hasNext()' from 'next()' if it's not necessary.

I offered the code above to Scala team, let's see if they like it - Ticket #3205: Optimize performance of compound iterator created via Iterator.++()

Here is a simple driver program that shows performance difference between current Scala implementation and the one above:


object CollectionProcessing {
  trait MyIterator[+A] {self =>
    def hasNext: Boolean

    def next(): A

    def ++[B >: A](that: => MyIterator[B]): MyIterator[B] = new MyIterator[B] {
      // optimize a little bit to prevent n log n behavior.
      private var cur: MyIterator[B] = self
      // this was unnecessarily looping forever on x ++ x
      def hasNext = {
        cur.hasNext || ((cur eq self) && {
          val it = that
          it.hasNext && {
            cur = it
            true
          }
        })
      }

      def next() = {hasNext; cur.next()}
    }

    def +++[B >: A](that: => MyIterator[B]) : MyIterator[B] = {

      case class Node[T](val current: () => MyIterator[T]) {
        var next: Option[Node[T]] = None
        def append[U >: T](i: => MyIterator[U]) : Node[U] = {
          def doAppend(to: Node[U], from: Option[Node[T]]) : Node[U] = {
            from match {
              case None => to
              case Some(n) => {val node: Node[U] = Node(n.current); to.next = Some(node); doAppend(node, n.next)}
            }
          }
          val result: Node[U] = Node(current)
          lazy val it = i
          doAppend(result, next).next = Some(Node(() => it))
          result
        }
      }

      class CombinedIterator[T](var head: Node[T]) extends MyIterator[T] {

        var checkNext = true

        def hasNext = {
          checkNext = false
          if (head.current().hasNext) true
          else head.next match {
            case None => false
            case Some(x) => {head = x; hasNext}
          }
        }

        def next() = {
          if (checkNext) hasNext
          checkNext = true
          head.current().next
        }

        override def +++[B >: T](that: => MyIterator[B]) = {
          new CombinedIterator(head.append(that))
        }
      }      

      val node: Node[B]= Node(() => self)
      lazy val t = that
      node.next = Some(Node(() => t))
      new CombinedIterator(node)
    }
  }
  def main(args: Array[String]) {
    var sum1 = 0L
    var sum2 = 0L
    var start = 0L
    val ElementsPerIterator = 150
    val IteratorsNumber = ElementsPerIterator
    while (true) {
      sum1 = 0L
      sum2 = 0L
      val (standard, extended) = createInput(ElementsPerIterator, IteratorsNumber)
      start = System.currentTimeMillis
      while (standard.hasNext) {
        sum1 += standard.next
      }
      println("iteration standard: " + (System.currentTimeMillis - start) + " ms")
      
      start = System.currentTimeMillis
      while (extended.hasNext) {
        sum2 += extended.next
      }
      println("iteration custom: " + (System.currentTimeMillis - start) + " ms")

      require(sum1 == sum2)
    }
  }

  def createInput(elementsPerIterator: Int, iteratorsNumber: Int) = {
    val random = new Random

    class IteratorImpl(var current: Int) extends MyIterator[Int] {
      var remains = elementsPerIterator

      def next() = {
        remains -= 1
        current += 1
        current
      }

      def hasNext = remains > 0
    }

    val base = random.nextInt
    var standard: MyIterator[Int] = new IteratorImpl(base)
    var custom: MyIterator[Int] = new IteratorImpl(base)
    var remains = iteratorsNumber - 1
    var timeStandard = 0L
    var timeCustom = 0L
    var startTime = 0L
    while (remains > 0) {
      val base = random.nextInt
      startTime = System.currentTimeMillis
      standard ++= new IteratorImpl(base)
      timeStandard += System.currentTimeMillis - startTime
      startTime = System.currentTimeMillis
      custom +++= new IteratorImpl(base)
      timeCustom += System.currentTimeMillis - startTime
      remains -= 1
    }
    println("\nconstruction standard: " + timeStandard + " ms")
    println("construction custom: " + timeCustom + " ms")
    (standard, custom)
  }
}

It shows about 700 times performance boost on my machine when we iterate 150 iterators of 150 elements.

Working with by-name arguments in Scala

2010-03-22T19:59:00.003+03:00

Preview;

Task;

Solution;

Preview

I talked about various ways to deliver method parameters in Scala recently. We'll continue that by checking one important use-case that can arise during 'by-name' parameters usage.

Task

Let's consider the situation when we have a method with 'by-name' argument and want to store that argument for future use.

First implementation may look like below:


object ScalaTest {

  class DataHolder(var data: Int) {
    def test() = {
      println(data)
      data += 1
    }
  }
  case class Storage(i: () => DataHolder)

  def main(args: Array[String]) {
    val storage = wrap({println("evaluation"); new DataHolder(1)})
    println("after storages construction")
    storage.i().test
    storage.i().test
  }

  def wrap(holder: => DataHolder) : Storage = {
    Storage(() => holder)
  }
}

We were expecting to grab 'by-name' parameter of 'wrap()' method and reuse it later. Also it was expected to be evaluated lazily. However, the thing is that we grab not desired DataHolder reference but whole block '{println("evaluation"); new DataHolder(1)}'.

We get the following output from example above:


after storages construction
evaluation
1
evaluation
1

I.e. the argument is evaluated lazily but DataHolder object is recreated every time 'by-name' argument is used.

Solution

Scala allows to do the following trick for achieving desired result - it's possible to assign by-name parameter to 'lazy val'. Such construction does exactly what we need - lazily evaluates given parameter and remembers it:


object ScalaTest {

  class DataHolder(var data: Int) {
    def test() = {
      println(data)
      data += 1
    }
  }
  case class Storage(i: () => DataHolder)

  def main(args: Array[String]) {
    val storage1 = wrap1({println("evaluation1"); new DataHolder(1)})
    val storage2 = wrap2({println("evaluation2"); new DataHolder(1)})
    println("after storages construction")
    storage1.i().test
    storage1.i().test
    storage2.i().test
    storage2.i().test
  }

  def wrap1(holder: => DataHolder) : Storage = {
    Storage(() => holder)
  }

  def wrap2[T](holder: => DataHolder): Storage = {
    lazy val h = holder
    Storage(() => h)
  }
}

Output:


after storages construction
evaluation1
1
evaluation1
1
evaluation2
1
2

Scala method arguments processing - Iterator.++() doesn't work problem

2010-03-21T21:43:00.005+03:00

Preview;

Overview;

Broken compound iterator;

Explanation;

Preview

I want to talk about available modes of method arguments delivery in Scala and couple of common pitfalls with that. That information is useful for all developers new to Scala, especially to the one without functional programming background (my case).

Overview

Basically, there are three ways to deliver single method parameter in Scala. All of them are explained at Scala wiki:

normal (call-by-value) - argument is evaluated before method body execution;

by-name - argument is lazily evaluated every time it's used;

no-args function - argument is delivered as a no-args function that returns target value;

Here is an example that illustrates the above:


package net.scalatest

/**
 * @author Denis Zhdanov
 * @since Mar 21, 2010
 */
object ArgumentDelivery {
  def main(args: Array[String]) {
    testDefault({println("testDefault() argument"); 1})
    println
    testByName({println("testByName() argument"); 2})
    println
    testByFunction(() => {println("testByFunction() argument"); 3})
  }

  def testDefault(i: Int) {
    println("testDefault() body")
    var x = i
    var y = i
    println(x + " " + y)
  }
  def testByName(i: => Int) = {
    println("testByName() body")
    var x = i
    var y = i
    println(x + " " + y)
  }

  def testByFunction(i: () => Int) = {
    println("testByFunction() body")
    var x = i
    var y = i
    println("x: " + x)
    println("y(): " + y())
  }
}

We get the following ouput from example above:


testDefault() argument
testDefault() body
1 1

testByName() body
testByName() argument
testByName() argument
2 2

testByFunction() body
x: <function0>
testByFunction() argument
y(): 3

We can see that the difference between 'by-value' and 'by-name'/'by-function' modes is that method argument is evaluated lazily at last two cases. The difference between 'by-name' and 'by-function' argument is that 'by-name' argument re-evaluated every time it is used within the method; we need to explicitly put braces in order to evaluate 'by-function' and it's simple usage just creates an alias to the function.

Broken compound iterator

We got a little theory above, let's see it in action. Scala defines standard Iterator trait that is similar to java iterators. It's essense is shown below:


trait Iterator[+A] { self =>

  /** Tests whether this iterator can provide another element.
   *  @return  `true` if a subsequent call to `next` will yield an element,
   *           `false` otherwise.
   */
  def hasNext: Boolean

  /** Produces the next element of this iterator.
   *  @return  the next element of this iterator, if `hasNext` is `true`,
   *           undefined behavior otherwise.
   */
  def next(): A

  // ...
}

Scala Iterator also provides convenient methods like the one that allows to build Iterator object from another two iterators. It's signature is defined as follows:


def ++[B >: A](that: => Iterator[B]): Iterator[B]

We can see that ++ method takes another iterator as 'by-name' argument. Here is a little artificial example that shows the problem that may arise with that:


package net.scalatest

/**
 * @author Denis Zhdanov
 * @since Mar 9, 2010
 */
object ScalaTest {

  class IteratorImpl(val base: Int) extends Iterator[Int] {
    private var empty = false

    def next() = if (empty) Iterator.empty.next
    else {empty = true; base}

    def hasNext = !empty
  }

  def main(args: Array[String]) {
    val i = create()
    while (i.hasNext) print(i.next + " ")
  }

  def create() = {
    var base = 1
    var i: Iterator[Int] = new IteratorImpl(base)
    base = 2
    i ++= new IteratorImpl(base)
    base = 3
    i ++= new IteratorImpl(base)
    i
  }
}

I was expecting to get '1 2 3' as an output but, surprisingly got '1 3 3' instead.

Explanation

We know that 'by-name' arguments are lazily evaluated. So, 'new IteratorImpl(base)' expression is evaluated not during 'i ++= new IteratorImpl(base)' execution but later, during printing iterator elements at main().

The thing is that our 'by-name' argument is actually a closure, i.e. it's a block of code that keeps reference to its outer context. That means that the closure 'new IteratorImpl(base)' doesn't evaluate 'base' at the moment of creation. Instead, it evaluates it to the current 'base' value at the moment of evaluation.

That exactly explains example behavior - 'new IteratorImpl(base)' refers to the last 'base' value (3) either for the second or third members of compound iterator.

We can fix the problem by binding new iterators construction closure to immutable variable:


package net.scalatest

/**
 * @author Denis Zhdanov
 * @since Mar 9, 2010
 */
object ScalaTest {

  class IteratorImpl(val base: Int) extends Iterator[Int] {
    private var empty = false

    def next() = if (empty) Iterator.empty.next
    else {empty = true; base}

    def hasNext = !empty
  }

  def main(args: Array[String]) {
    val i = create()
    while (i.hasNext) print(i.next + " ")
  }

  def create() = {
    new IteratorImpl(1) ++ new IteratorImpl(2) ++ new IteratorImpl(3)
  }
}

It's clear that we can easily fix this simple example but note that real-world situation may be much more complex and it may be hard to understand what went wrong.

Developers inhabitant is discovered

2010-03-16T15:45:00.002+03:00

From today Scala mailing list:

Hi everyone,

I've noticed a big trend in the Java community (as a whole, not a specific group) that they tend to not be on the Internet in the droves that they used to be a few years ago. It is not uncommon to see Hibernate, Spring, etc. forums virtually dead, and most posts have only a handful of views over 7 days.

I'm curious - what has happened? Where are the developers? Are they using other technologies? Are they so stable nobody cares but they still use them? Is the industry so slow that there's a small % of us left?

Would appreciate some credible insight. Thanks!
--------------------------------------------------------------------------
I'd see that as: The products are more mature and there's more and higher quality documentation

I mean, why spend time waiting for a response if I can google the answer in 10 seconds?
--------------------------------------------------------------------------
Dammit he found us. Where to next guys?

The best!

Kittens

2010-03-11T18:40:00.017+03:00

I have a cat of rather interesting breed - Kurilian Bobtail. There are really many distinctions between she and other cats and she give me a lot of joy but I want to talk about different thing here. My cat gave life to four kittens about month ago and now they look like a real kittens (used to be strange tadpoles at first :) ). Just want to post couple of their photos here.

Pregnant mommy:

First day:

Second day:

Funny dream:

Lair:

Sleepy kingdom:

Relax:

Teamwork:

Black bro:

Ginger:

Blonde:

Grey:

UML class diagrams editor

2010-03-05T20:09:00.008+03:00

Want to share results of my long search for a cool UML editors to use either under Windows or Linux.

NClass;

UMLet;

Fujaba;

Violet;

NClass

NClass is the best free editor for class diagrams. It's main benefits are simplicity, intuitiveness and eye-pleasing view:

It runs under Linux without any problem using Mono. Moreover, Mono team uses NClass as one of examples of porting pure WinForms applications to Linux.

UMLet

UMLet is a simple java-based UML editor that allows to build not only class diagrams but use-case, activity, sequence etc. Screenshots may be found at official site, e.g. this one:

Fujaba

Fujaba is not pure UML editor but MDA tool. I used it before NClass as a class diagram editor because it is wrote in java and provides nice icons for fields and methods (very similar to the one from NClass):

Violet

Violet is created by Cay Horstmann and I have a lot of respect to that man because I started my java developer carrer from his Core Java book and it was a good start. Violet was very promising but unfortunately I realized that I can't go with it. The reason is that it just doesn't allow to do necessary things. E.g. you can't define your own way of transition representation:

But I should admit that Violet provides nice GUI and is really easy to use. It may worth to spend time and contribute to it in order to solve existing problems.

Shopping

2010-02-20T20:18:00.003+03:00

Today my wife and me went to shop by car. Nothing special, just wanted to get some food and drinks. Half-way between the shop a home we saw a car that stood right on a road. When we came around it we saw a dense smoke coming from it. We stopped, I got a fire extinguisher and ran to the burning car. There were couple of other men there that tried to choke a fire by their extinguishers. Nothing helped - the fire just paused for a couple of seconds and raised even more. We started to throw snow from verge to the car and it made a little effect - there was no open fire but stinky black smoke still continued. Eventually firemen arrived and finished the business.

Almost all cars that moved around didn't stop. I didn't think about that that time and realized the fact later. I understand that we live in a real world and its hardly possible to change people but ... just want to say that we stopped and tried to help. And couple of another men joined us. And I believe that all of the people that I consider to be my friends would stop.

I'm sad.

ProjectEuler - problem10

2010-02-09T21:09:00.020+03:00

Problem definition;

Brute-force algorithm;

Improved algorithm;

Profiling algorithm;

Problem definition

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

Find the sum of all the primes below two million.

Brute-force algorithm

The most easiest solution is to use prime numbers generator developed during another tasks processing:

ProjectEulerUtil.scala


package net.projecteuler.util

/**
 * Holds utility methods for the ProjectEuler task classes and objects.
 *
 * @author Denis Zhdanov
 * @since Jan 5, 2010
 */
object ProjectEulerUtil {

    def getFibonacciStream() : Stream[Long] = {
        lazy val fib: Stream[Long] = Stream.cons(0, Stream.cons(1, fib.zip(fib.tail).map(t => t._1 + t._2)))
        fib
    }

    def getNaturalNumbers(from: Long, step: Long) : Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(from, result map(_ + step))
        result
    }

    def getPrimeNumbers(): Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(2, getNaturalNumbers(3, 2) filter {
            n => result.takeWhile(p => p * p <= n).forall(n % _ != 0)
        })
        result
    }

    def timedExecute(f: => Any) = {
        println()
        println("--------------------> Starting <---------------------")
        val start = System.nanoTime
        f
        println("------------------> Executed in " + ((System.nanoTime - start) / 1000000000d) + " seconds <-------------------")
    }

    /**
     * Iterates elements of given collection and applies given function to them.
     * <p/>
     * Stops if the function returns <code>Some</code> value or all elements are processed
     *
     * @param collection    collection which content should be checked
     * @param checker       function that should be applied to collection elements
     * @returns             <code>Some</code> value if given function yields <code>Some</code> value for
     *                      any element of the given collection; <code>None</code> otherwise
     */
    def find[I, O] (collection: Iterable[I])(checker: I => Option[O]) : Option[O] = {
        var result : Option[O] = None
        collection.dropWhile {
            checker(_) match {
                case Some(x) => {result = Some(x); false}
                case None => true
            }
        }
        result
    }

    def gcd(i: Long, j: Long) : Long = {
        if (j <= 0) i
        else gcd(j, i % j)
    }
}

P10.scala


package net.projecteuler.p10

import net.projecteuler.util.ProjectEulerUtil._

/**
 * @author Denis Zhdanov
 * @since Feb 9, 2010
 */
object P10 extends Application {

    val Limit = 2000000L

    timedExecute {
        val result = (0L /: getPrimeNumbers.takeWhile(_ < Limit))(_ + _)
        println(result)
    }
}

It may be seen that the program takes a while to process.

Improved algorithm

We can optimize prime numbers discovery via ancient Eratosthen sieve algorithm - 'ProjectEulerUtil.getPrimes()' (main algorithm concepts are defined at source code level):

ProjectEulerUtil.scala


package net.projecteuler.util

import Math._
import collection.{SortedSet, BitSet}
import collection.immutable.TreeSet

/**
 * Holds utility methods for the ProjectEuler task classes and objects.
 *
 * @author Denis Zhdanov
 * @since Jan 5, 2010
 */
object ProjectEulerUtil {

    def getFibonacciStream() : Stream[Long] = {
        lazy val fib: Stream[Long] = Stream.cons(0, Stream.cons(1, fib.zip(fib.tail).map(t => t._1 + t._2)))
        fib
    }

    def getNaturalNumbers(from: Long, step: Long) : Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(from, result map(_ + step))
        result
    }

    def getPrimeNumbers(): Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(2, getNaturalNumbers(3, 2) filter {
            n => result.takeWhile(p => p * p <= n).forall(n % _ != 0)
        })
        result
    }

    def getPrimes() : Iterator[Long] = {

        // General idea is to process numbers by blocks of fixed size and find all prime numbers from them.
        // This constant defines block size.
        val BlockSize = 1000

        /**
         * Allows to retrieve bitset of size defined by <code>'BlockSize'</code> constant. That bitset is assumed to
         * contain numbers that are not prime. Please note that we use an optimization here - there is no point
         * to process even numbers because all of them except <code>'2'</code> are guaranteed to be not primes.
         * <p/>
         * Returned bitset is assumed to hold information about odd numbers only then - every target number is
         * calculated by the following formula <code>'2 * i + 1'</code> where <code>'i'</code> is a target number
         * contained at bitset.
         * <p/>
         * <b>Example:</b> consider that returned bitset contains numbers <code>4, 7, 10</code>. That means that it
         * provides information that numbers <code>9, 15, 21</code> are not prime.
         *
         *
         * @param primes        prime numbers that are already known and that are not greater than given threshold
         * @param threshold     value that defines how many numbers are already processed
         * @return              bitset that holds numbers that are known to be non-prime
         */
        def getPrimesBitSet(primes: SortedSet[Long], threshold: Long) : BitSet = {
            val sieve = new scala.collection.mutable.BitSet(BlockSize)

            /**
             * Marks <code>'sieve'</code> bitset with the given number and all of its odd multiplies.
             * <p/>
             * Example: <code>'3'</code> is given as a <code>'base'</code> - the method stores information
             * about <code>3, 3 * 3, 3 * 5, 3 * 9</code> numbers at the bitset. Please note that bitset is assumed
             * to contain only odd numbers where target number is calculated by formula <code>'2 * i + 1'</code>
             * where <code>'i'</code> is a number stored at bitset. That explains main concepts of marking algorithm:
             * <ul>
             *     <li>
             *          <b>start with the square of the base number</b>
             *          <p/>
             *          We do that in assumption that all numbers that are multiplications of <code>'base'</code>
             *          and number lower than <code>'base'</code> are processed during marking that
             *          <code>'lower'</code> number. So, our task is to calculate resulting formula for square of
             *          <code>'base'</code> number calculation:
             *          <p/>
             *          <pre>
             *              base = 2i + 1
             *              base<sup>2</sup> = 4i<sup>2</sup> + 4i + 1 = 2j + 1
             *              2j = 4i * (i + 1)
             *              j = 2i * (i + 1)
             *          </pre>
             *     </li>
             *     <li>
             *          <b>add all odd multiplies of 'base' number to the bitset</b>
             *          <p/>
             *          Our task is to find <code>'k'</code> that solves the following equation:
             *          <p/>
             *          <pre>
             *              2 * (i + k) + 1 = 3 * (2i + 1)
             *              2k = 6i - 2i + 3 - 2
             *              k = 2i + 1
             *          </pre>
             *          <p/>
             *          That means that we can found the first number to store at bitset and defines every next odd
             *          multiply to store at bitset by summarizing current multiply with <code>'base'</code> number;
             *     </li>
             * </ul>
             *
             * @param base      number to apply to the <code>'sieve'</code> bitset
             */
            def mark(base: Long) {
                val baseIndex = (base - 1) / 2
                val j = (threshold / 2) - baseIndex;
                val firstIndex = if (base > threshold) 2 * baseIndex * (baseIndex + 1)
                                 else if (j % base == 0) 0L
                                 else base - (j % base)
                getNaturalNumbers(firstIndex, base).takeWhile(_ < BlockSize).foreach(sieve += _.toInt)
            }

            // Mark known primes.
            val crosslimit = sqrt(2 * threshold + BlockSize)
            primes.takeWhile(_ <= crosslimit).foreach(mark)

            // Sieve primes from the new block.
            val start = if (threshold == 0) 1
                        else 0
            for (i <- start until BlockSize; if (!sieve.contains(i))) {
                mark(threshold + (i * 2) + 1);
                sieve -= i
            }

            sieve
        }

        def getPrimesFromBitSet(primes: BitSet, threshold: Long) : Seq[Long] = {
            val start = if (threshold == 0) 1
                        else 0
            for (i <- start until BlockSize; if !primes.contains(i)) yield threshold + 2 * i + 1
        }

        new Iterator[Long]() {            

            private var iterations = 0
            private var allPrimes = TreeSet[Long]()
            private var i = List(2L).elements

            def hasNext = true
            def next() = {
                while (!i.hasNext) iteration()
                i.next
            }

            private def iteration() {
                val threshold = iterations * BlockSize * 2
                val primes = getPrimesFromBitSet(getPrimesBitSet(allPrimes, threshold), threshold)
                allPrimes ++= primes
                iterations += 1
                i = primes.elements
            }
        }
    }

    def timedExecute(f: => Any) = {
        println()
        println("--------------------> Starting <---------------------")
        val start = System.nanoTime
        f
        println("------------------> Executed in " + ((System.nanoTime - start) / 1000000000d) + " seconds <-------------------")
    }

    /**
     * Iterates elements of given collection and applies given function to them.
     * <p/>
     * Stops if the function returns <code>Some</code> value or all elements are processed
     *
     * @param collection    collection which content should be checked
     * @param checker       function that should be applied to collection elements
     * @returns             <code>Some</code> value if given function yields <code>Some</code> value for
     *                      any element of the given collection; <code>None</code> otherwise
     */
    def find[I, O] (collection: Iterable[I])(checker: I => Option[O]) : Option[O] = {
        var result : Option[O] = None
        collection.dropWhile {
            checker(_) match {
                case Some(x) => {result = Some(x); false}
                case None => true
            }
        }
        result
    }

    def gcd(i: Long, j: Long) : Long = {
        if (j <= 0) i
        else gcd(j, i % j)
    }
}

Profiling algorithm

We implemented general idea of prime numbers sieve. Let's check if its implementation can be improved.

I use visualvm for that. It's not as feature-rich as JProfiler or YourKit profilers but it provides basic functionality and is free. I think experience with such a tool is very useful for every java developer.

Let's rewrite our start class in order to run forether:

P10.scala


package net.projecteuler.p10

import net.projecteuler.util.ProjectEulerUtil._

/**
 * @author Denis Zhdanov
 * @since Feb 9, 2010
 */
object P10 {

    val Limit = 2000000L

    def main(args: Array[String]) {
        while (true) {
            timedExecute {
                val result2 = (0L /: getPrimes.takeWhile(_ < Limit))(_ + _)
                println(result2)
            }
        }
    }
}

Start profiling session:

Check profiling results:

It's rather surprising to see that 'TreeSet.$plus$plus' takes more time than actual primes filtering.

We can expand that processing a little:

Dozens of recursive 'upd()' and 'lookup()' look very suspicious. I'm definitely going to check standard Scala collections implementation.

Anyway, profiling shows that there is performance problem with storing parsed prime numbers at Scala's TreeSet. I used it in order to process prime numbers from smallest to greatest. However, it's clear that they are already discovered at that order and we can use simple list instead of TreeSet. So, we can change TreeSet to ArrayBuffer at ProjectEulerUtil:


def getPrimes() : Iterator[Long] = {

    def getPrimesBitSet(primes: Seq[Long], threshold: Long) : BitSet = {
        ...
    }

    new Iterator[Long]() {
        private var allPrimes = new ArrayBuffer[Long]()
    }
}

If we run the program we see that it's executed approximately twice as fast as before. Check the change via profiler:

Much better but we can see that significant amount of time is still spent to 'ArrayBuffer$plus$plus$eq processing'. If we expand its processing and check source code we see that the reason is that ++= method adds all elements of the given collection one-by-one that implies unnecessary processing. We can use ArrayBuffer[Seq[Long]] then:


package net.projecteuler.util

import Math._
import collection.{BitSet}
import collection.mutable.{ArrayBuffer}

/**
 * Holds utility methods for the ProjectEuler task classes and objects.
 *
 * @author Denis Zhdanov
 * @since Jan 5, 2010
 */
object ProjectEulerUtil {

    def getFibonacciStream() : Stream[Long] = {
        lazy val fib: Stream[Long] = Stream.cons(0, Stream.cons(1, fib.zip(fib.tail).map(t => t._1 + t._2)))
        fib
    }

    def getNaturalNumbers(from: Long, step: Long) : Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(from, result map(_ + step))
        result
    }

    def getPrimeNumbers(): Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(2, getNaturalNumbers(3, 2) filter {
            n => result.takeWhile(p => p * p <= n).forall(n % _ != 0)
        })
        result
    }

    def getPrimes() : Iterator[Long] = {

        // General idea is to process numbers by blocks of fixed size and find all prime numbers from them.
        // This constant defines block size.
        val BlockSize = 1000

        /**
         * Allows to retrieve bitset of size defined by <code>'BlockSize'</code> constant. That bitset is assumed to
         * contain numbers that are not prime. Please note that we use an optimization here - there is no point
         * to process even numbers because all of them except <code>'2'</code> are guaranteed to be not primes.
         * <p/>
         * Returned bitset is assumed to hold information about odd numbers only then - every target number is
         * calculated by the following formula <code>'2 * i + 1'</code> where <code>'i'</code> is a target number
         * contained at bitset.
         * <p/>
         * <b>Example:</b> consider that returned bitset contains numbers <code>4, 7, 10</code>. That means that it
         * provides information that numbers <code>9, 15, 21</code> are not prime.
         *
         *
         * @param primes        prime numbers that are already known and that are not greater than given threshold
         * @param threshold     value that defines how many numbers are already processed
         * @return              bitset that holds numbers that are known to be non-prime
         */
        def getPrimesBitSet(primes: Seq[Seq[Long]], threshold: Long) : BitSet = {
            val sieve = new scala.collection.mutable.BitSet(BlockSize)

            /**
             * Marks <code>'sieve'</code> bitset with the given number and all of its odd multiplies.
             * <p/>
             * Example: <code>'3'</code> is given as a <code>'base'</code> - the method stores information
             * about <code>3, 3 * 3, 3 * 5, 3 * 9</code> numbers at the bitset. Please note that bitset is assumed
             * to contain only odd numbers where target number is calculated by formula <code>'2 * i + 1'</code>
             * where <code>'i'</code> is a number stored at bitset. That explains main concepts of marking algorithm:
             * <ul>
             *     <li>
             *          <b>start with the square of the base number</b>
             *          <p/>
             *          We do that in assumption that all numbers that are multiplications of <code>'base'</code>
             *          and number lower than <code>'base'</code> are processed during marking that
             *          <code>'lower'</code> number. So, our task is to calculate resulting formula for square of
             *          <code>'base'</code> number calculation:
             *          <p/>
             *          <pre>
             *              base = 2i + 1
             *              base<sup>2</sup> = 4i<sup>2</sup> + 4i + 1 = 2j + 1
             *              2j = 4i * (i + 1)
             *              j = 2i * (i + 1)
             *          </pre>
             *     </li>
             *     <li>
             *          <b>add all odd multiplies of 'base' number to the bitset</b>
             *          <p/>
             *          Our task is to find <code>'k'</code> that solves the following equation:
             *          <p/>
             *          <pre>
             *              2 * (i + k) + 1 = 3 * (2i + 1)
             *              2k = 6i - 2i + 3 - 2
             *              k = 2i + 1
             *          </pre>
             *          <p/>
             *          That means that we can found the first number to store at bitset and defines every next odd
             *          multiply to store at bitset by summarizing current multiply with <code>'base'</code> number;
             *     </li>
             * </ul>
             *
             * @param base      number to apply to the <code>'sieve'</code> bitset
             */
            def mark(base: Long) {
                val baseIndex = (base - 1) / 2
                val j = (threshold / 2) - baseIndex;
                val firstIndex = if (base > threshold) 2 * baseIndex * (baseIndex + 1)
                                 else if (j % base == 0) 0L
                                 else base - (j % base)
                getNaturalNumbers(firstIndex, base).takeWhile(_ < BlockSize).foreach(sieve += _.toInt)
            }

            // Mark known primes.
            val crosslimit = sqrt(2 * threshold + BlockSize)
            primes.takeWhile {
                var stop = false
                subprimes => {
                    subprimes.takeWhile(prime => {mark(prime);stop = prime > crosslimit; !stop})
                    !stop
                }
                !stop
            }

            // Sieve primes from the new block.
            val start = if (threshold == 0) 1
                        else 0
            for (i <- start until BlockSize; if (!sieve.contains(i))) {
                mark(threshold + (i * 2) + 1);
                sieve -= i
            }

            sieve
        }

        def getPrimesFromBitSet(primes: BitSet, threshold: Long) : Seq[Long] = {
            var i = if (threshold == 0) 1
                        else 0
            val result = new ArrayBuffer[Long]
            while (i < BlockSize) {
                if (!primes.contains(i)) {
                    result += threshold + 2 * i + 1
                }
                i += 1
            }
            result
//            val result = for (i <- start until BlockSize; if !primes.contains(i)) yield threshold + 2 * i + 1
//            result force
        }

        new Iterator[Long]() {

            private var iterations = 0
            private var allPrimes = new ArrayBuffer[Seq[Long]]()
            private var i = List(2L).elements

            def hasNext = true
            def next() = {
                while (!i.hasNext) iteration()
                i.next
            }

            private def iteration() {
                val threshold = iterations * BlockSize * 2
                val primes = getPrimesFromBitSet(getPrimesBitSet(allPrimes, threshold), threshold)
                allPrimes += primes
                iterations += 1
                i = primes.elements
            }
        }
    }

    def timedExecute(f: => Any) = {
        println()
        println("--------------------> Starting <---------------------")
        val start = System.nanoTime
        f
        println("------------------> Executed in " + ((System.nanoTime - start) / 1000000000d) + " seconds <-------------------")
    }

    /**
     * Iterates elements of given collection and applies given function to them.
     * <p/>
     * Stops if the function returns <code>Some</code> value or all elements are processed
     *
     * @param collection    collection which content should be checked
     * @param checker       function that should be applied to collection elements
     * @returns             <code>Some</code> value if given function yields <code>Some</code> value for
     *                      any element of the given collection; <code>None</code> otherwise
     */
    def find[I, O] (collection: Iterable[I])(checker: I => Option[O]) : Option[O] = {
        var result : Option[O] = None
        collection.dropWhile {
            checker(_) match {
                case Some(x) => {result = Some(x); false}
                case None => true
            }
        }
        result
    }

    def gcd(i: Long, j: Long) : Long = {
        if (j <= 0) i
        else gcd(j, i % j)
    }
}

I got about 20% performance improvement. Profiling confirms that:

We can see that most of the time is spent to internal Scala processing but I think we won't dig deeper this time and improve the implementation even more. I'm going to return to this after Scala internals review.

ProjectEuler - problem9

2010-02-07T10:06:00.013+03:00

Problem definition;

Brute-force algorithm;

Brute-force solution;

Primitive Pythagorean triples formula;

Revised algorithm;

Revised solution;

Problem definition

A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
a² + b² = c²

For example, 3² + 4² = 9 + 16 = 25 = 5².

There exists exactly one Pythagorean triplet for which a + b + c = 1000.
Find the product abc.

Brute-force algorithm

Let's perform simple analysis for our data constraints:

a < b < c
a < b < 1000 - a - b

a < 1000 - a - b
2a < 1000 - b
a < b ==> 2a < 1000 - a
3a < 1000
a < 1000 / 3

b < 1000 - a - b
2b < 1000 - a
b < (1000 - a) / 2

We just constrained our parameters and can iterate all of their available values in order to find such (a; b) pair that conforms to equation below:

a² + b² = (1000 - a - b)²

Brute-force solution

We introduce utility method find():

ProjectEulerUtil.java


package net.projecteuler.util

/**
 * Holds utility methods for the ProjectEuler task classes and objects.
 *
 * @author Denis Zhdanov
 * @since Jan 5, 2010
 */
object ProjectEulerUtil {

    def getFibonacciStream() : Stream[Long] = {
        lazy val fib: Stream[Long] = Stream.cons(0, Stream.cons(1, fib.zip(fib.tail).map(t => t._1 + t._2)))
        fib
    }

    def getNaturalNumbers(from: Long, step: Long) : Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(from, result map(_ + step))
        result
    }

    def getPrimeNumbers(): Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(2, getNaturalNumbers(3, 2) filter {
            n => result.takeWhile(p => p * p <= n).forall(n % _ != 0)
        })
        result
    }

    def timedExecute(f: => Any) = {
        println()
        println("--------------------> Starting <---------------------")
        val start = System.nanoTime
        f
        println("------------------> Executed in " + ((System.nanoTime - start) / 1000000000d) + " seconds <-------------------")
    }

    /**
     * Iterates elements of given collection and applies given function to them.
     * <p/>
     * Stops if the function returns <code>Some</code> value or all elements are processed
     *
     * @param collection    collection which content should be checked
     * @param checker       function that should be applied to collection elements
     * @returns             <code>Some</code> value if given function yields <code>Some</code> value for
     *                      any element of the given collection; <code>None</code> otherwise
     */
    def find[I, O] (collection: Iterable[I])(checker: I => Option[O]) : Option[O] = {
        var result : Option[O] = None
        collection.dropWhile {
            checker(_) match {
                case Some(x) => {result = Some(x); false}
                case None => true
            }
        }
        result
    }
}

This class iterates all possible combinations using arguments restrictions produced before:

P9.scala


package net.projecteuler.p9

import net.projecteuler.util.ProjectEulerUtil._

/**
 * @author Denis Zhdanov
 * @since Feb 8, 2010
 */
object P9 extends Application {

    val TripleSum = 1000

    timedExecute {
        val result = find(1 to TripleSum / 3) {
            i =>
                find((i + 1) to ((TripleSum - i) / 2)) {
                    j =>
                        if (i * i + j * j == (TripleSum - i - j) * (TripleSum - i - j)) Some(j)
                        else None
                } match {
                    case Some(x) => Some(i, x)
                    case None => None
                }
        }

        result match {
            case Some(x) => println(x._1 * x._2 * (TripleSum - x._1 - x._2))
        }
    }
}

Primitive Pythagorean triples formula

Let's perform more analysis for our problem in order to provide more scalable solution.

There are ancient formulas for primitive Pythagorean triple calculations (primitive Pythagorean Triple is a (a; b; c) triple where a² + b² = c² and gcd(a, b, c) = 1:

a = m² - n²
b = 2mn
c = m² + n²

m > n > 0
only one of m, n is even
gcd(m, n) = 1

The most interesting here it is to deduce that:

We can conclude that gcd(a, b) = gcd(a, c) = gcd(b, c) = 1. Let's assume that gcd(a, b) = d > 1. We get the following then:

a = d * x
b = d * y

a² + b² = (dx)² + (dy)² = d²(x² + y²)

a² + b² = c²
==> c² = d²(x² + y²)
==> c is divisible by d that contradicts to our invariant that gcd(a, b, c) = 1

We can prove that gcd(a, c) = 1 and gcd(b, c) = 1 at the same manner;

Lets observe a, b and c parity.
- suppose a, b and c are all odd. We get the following then:
  
  (2x + 1)² + (2y + 1)² = (2z + 1)²
  4x² + 4x + 1 + 4y² + 4y + 1 = 4z² + 4z + 1
  4 * (x² + x + y² + y - z² - z + 1) = 3
  
  That's not possible because 3 is not divisible by 4;
- let's assume that a and b are odd and c is even:
  
  4x² + 4x + 1 + 4y² + 4y + 1 = 4z²
  4 * (x² + x + y² + y - z² + 1) = 2
  
  2 is not divisible by 4, hence, such use-case is also illegal;
- we remember that gcd(a, b, c) = 1, so, it's not possible for all a, b and c to be even;
Conclusion: only one of a, b is even and another is odd. Let's say that b is even and a, c are odd;

Let's play around with our equation:

a² + b² = c²
b² = c² - a²
b² = (c - a)(c + a)
(b / 2)² = (c - a) / 2 * (c + a) / 2

We already proved that b is even and a, c are odd, hence, (b / 2), (c - a) / 2 and (c + a) / 2 are all whole numbers. It's clear that they are positive too;

let's define d = gcd((c - a) / 2, (c + a) / 2). It's implied that d is a divisor for the sum of the mentioned numbers (c) and difference (a). But we know that gcd(a, c) = 1 ==> d = 1;

That gives us the product of two whole numbers, (c - a) / 2 and (c + a) / 2, whose greatest common divisor is 1, and whose product is a square. The only way that can happen is if each of them is a square itself. This means that there are positive whole numbers m and n such that the below is correct:

m² = (c + a) / 2
n² = (c - a) / 2
b / 2 = m * n

Final observations for m and n defined above:
- m > n
- n > 0 because c > a
- gcd(m², n²) = 1 ==> gcd(m, n) = 1
- m and n can't be both odd because m² - n² = a would be even and we know that it's odd;
- m and n can't be both even because gcd(m, n) = 1
- conclusion - one of m, n is even and another one is odd;

We can solve the system above and get target formulas for primitive pythagorean triplets calculation;

Phew...

Revised algorithm

Let's apply primitive Pythagorean triples calculation formulas deduced above to our solution.

It's clear that we can multiply all members of primitive Pythagorean triple to the same number d and get Pythagorean triple again. I.e. formulas for all Pythagorean triples looks like the one below:

a = d (m² - n²)
b = 2dmn
c = d (m² + n²)
a + b + c = 2m² + 2mn = 2m(m + n) = 1000

I.e. we can rewrite our constraint for triple members sum as follows:

a + b + c = d * (2m² + 2mn) = 2dm * (m + n) = 1000

That means that we need to find m as a 1000 / 2 divisor that is more than 1 and odd divisor k = m + n of 1000 / 2m. We can see that m < k < 2m and gcd(m, k) = 1.

So, we can find m and k, calculate n = k - m and d = 1000 / 2mk

Revised solution

ProjectEulerUtil.scala


package net.projecteuler.util

/**
 * Holds utility methods for the ProjectEuler task classes and objects.
 *
 * @author Denis Zhdanov
 * @since Jan 5, 2010
 */
object ProjectEulerUtil {

    def getFibonacciStream() : Stream[Long] = {
        lazy val fib: Stream[Long] = Stream.cons(0, Stream.cons(1, fib.zip(fib.tail).map(t => t._1 + t._2)))
        fib
    }

    def getNaturalNumbers(from: Long, step: Long) : Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(from, result map(_ + step))
        result
    }

    def getPrimeNumbers(): Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(2, getNaturalNumbers(3, 2) filter {
            n => result.takeWhile(p => p * p <= n).forall(n % _ != 0)
        })
        result
    }

    def timedExecute(f: => Any) = {
        println()
        println("--------------------> Starting <---------------------")
        val start = System.nanoTime
        f
        println("------------------> Executed in " + ((System.nanoTime - start) / 1000000000d) + " seconds <-------------------")
    }

    /**
     * Iterates elements of given collection and applies given function to them.
     * <p/>
     * Stops if the function returns <code>Some</code> value or all elements are processed
     *
     * @param collection    collection which content should be checked
     * @param checker       function that should be applied to collection elements
     * @returns             <code>Some</code> value if given function yields <code>Some</code> value for
     *                      any element of the given collection; <code>None</code> otherwise
     */
    def find[I, O] (collection: Iterable[I])(checker: I => Option[O]) : Option[O] = {
        var result : Option[O] = None
        collection.dropWhile {
            checker(_) match {
                case Some(x) => {result = Some(x); false}
                case None => true
            }
        }
        result
    }

    def gcd(i: Long, j: Long) : Long = {
        if (j <= 0) i
        else gcd(j, i % j)
    }
}

P9.scala


package net.projecteuler.p9

import net.projecteuler.util.ProjectEulerUtil._
import Math._

/**
 * @author Denis Zhdanov
 * @since Feb 8, 2010
 */
object P9 extends Application {

    val TripleSum = 1000
    val TripleSumHalf = TripleSum / 2
    val limit = sqrt(TripleSumHalf)

    def reduce(i: Int, divisor: Int) : Int = {
        i % divisor match {
            case 0 => reduce(i / divisor, divisor)
            case _ => i
        }
    }

    timedExecute {
        val result = find(2 to limit) {
            i =>
                if (TripleSumHalf % i == 0) {
                    val k = if (i % 2 == 0) i + 1
                            else i + 2

                    val reduced = reduce(TripleSumHalf / i, 2)
                    find(k to min(2 * i, reduced)) {
                        j =>
                            if (reduced % j == 0 && gcd(i, j) == 1) Some(j)
                            else None
                    } match {
                        case Some(x) => Some(i, x)
                        case None => None
                    }
                } else None
        }

        result match {
            case Some(x) => {
                val m = x._1
                val k = x._2
                val d = TripleSumHalf / m / k
                val n = k - m
                val a = d * (m * m - n * n)
                val b = 2 * d * m * n
                val c = d * (m * m + n * n)
                println(a * b * c)
            }
        }
    }
}

ProjectEuler - problem8

2010-01-31T12:40:00.004+03:00

Problem definition;

Algorithm;

Problem solution;

Problem definition

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

Algorithm

This is rather simple problem that doesn't require any mathematical studies. I.e. all we need is to iterate all combinations of number products and choose the max of them.

There are four main product types - five numbers in a row, five numbers in column, five numbers on right diagonal, five numbers on left diagonal.

Problem solution

P8.scala


package net.projecteuler.p8

/**
 * @author Denis Zhdanov
 * @since 31.01.2010
 */

object P8 extends Application {
    val ProductSize = 5
    val NumbersInRow = 50
    val NumbersInColumn = 20
    val input = """|73167176531330624919225119674426574742355349194934
                   |96983520312774506326239578318016984801869478851843
                   |85861560789112949495459501737958331952853208805511
                   |12540698747158523863050715693290963295227443043557
                   |66896648950445244523161731856403098711121722383113
                   |62229893423380308135336276614282806444486645238749
                   |30358907296290491560440772390713810515859307960866
                   |70172427121883998797908792274921901699720888093776
                   |65727333001053367881220235421809751254540594752243
                   |52584907711670556013604839586446706324415722155397
                   |53697817977846174064955149290862569321978468622482
                   |83972241375657056057490261407972968652414535100474
                   |82166370484403199890008895243450658541227588666881
                   |16427171479924442928230863465674813919123162824586
                   |17866458359124566529476545682848912883142607690042
                   |24219022671055626321111109370544217506941658960408
                   |07198403850962455444362981230987879927244284909188
                   |84580156166097919133875499200524063689912560717606
                   |05886116467109405077541002256983155200055935729725
                   |71636269561882670428252483600823257530420752963450""".stripMargin

    val data = (new Array[Int](0) /: input.lines)(_ ++ _.map(_.asDigit))

    def build(startIndex: Int, nextElementIndexStep: (Int) => Option[Int]): Option[Int] = {
        def build(index: Int, current: Option[Int], iterationsLeft: Int): Option[Int] = {
            current match {
                case Some(value) => {
                    if (iterationsLeft <= 0) {
                        return current
                    }
                    nextElementIndexStep(index) match {
                        case Some(nextIndex) => build(nextIndex, Some(value * data(nextIndex)), iterationsLeft - 1)
                        case None => None
                    }
                }
                case None => current
            }
        }
        build(startIndex, Some(data(startIndex)), ProductSize - 1)
    }

    val horizontal = (i: Int) => {
        if (i % NumbersInRow >= NumbersInRow - 1) None
        else Some(i + 1)
    }

    val vertical = (i: Int) => {
        if (i / NumbersInRow >= NumbersInColumn - 1) None
        else Some(i + NumbersInRow)
    }

    val rightHorizontal = (i: Int) => {
        (horizontal(i), vertical(i)) match {
            case (Some(x), Some(y)) => Some(y + 1)
            case _ => None
        }
    }

    val leftHorizontal = (i: Int) => {
        vertical(i) match {
            case Some(x) => {
                if (i % NumbersInRow > 0) Some(x - 1)
                else None
            }
            case _ => None
        }
    }

    var result = 0
    val formulas = List(horizontal, vertical, rightHorizontal, leftHorizontal)
    for (
        i <- 0 until data.length;
        formula <- formulas
    ) {
        build(i, formula) match {
            case Some(x) => result = result max x
            case None =>
        }
    }
    println(result)
}

Here are the main principles that are used at the implementation:

convert input string to the numbers array;

define utility function that calculates product based on its first number index at the data array - 'build()' method;

define four rules for product elements index definitions - 'horizontal()', 'vertical()', 'rightHorizontal()' and 'leftHorizontal()' functions;

calculate all possible products for all array indices and find the greatest;

It's possible to improve the algorithm at following:

stop product calculation as soon as zero is detected as a one of its elements (since resulting product is zero);

optimize processing in order to use subsequent product calculation results, e.g. we can iterate row by row for 'horizontal' rule calculation and use the following algorithm:
1. Calculate first five row numbers product;
2. Divide product from the previous step to the first element and multiply result to the 6-th element;
3. Divide product from the previous step to the second number and multiply it to the 7-th element;
4. Etc;

ProjectEuler - problem7

2010-01-26T18:28:00.003+03:00

Problem definition;

Problem solution;

Problem definition

By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6^th prime is 13.

What is the 10001^st prime number?

Problem solution

It's really easy to solve the task using sieve-based prime numbers generator introduced during problem5 processing. Here is the solution:

P7.scala


package net.projecteuler.p7

import net.projecteuler.util.ProjectEulerUtil._

/**
 * @author Denis Zhdanov
 * @since Jan 25, 2010
 */
object P7 extends Application {

    timedExecute {
        println(getPrimeNumbers.take(10001).last)
    }
}

ProjectEulerUtil.scala


package net.projecteuler.util

import collection.mutable.ListBuffer

/**
 * Holds utility methods for the ProjectEuler task classes and objects.
 *
 * @author Denis Zhdanov
 * @since Jan 5, 2010
 */
object ProjectEulerUtil {

    def getFibonacciStream() : Stream[Long] = {
        lazy val fib: Stream[Long] = Stream.cons(0, Stream.cons(1, fib.zip(fib.tail).map(t => t._1 + t._2)))
        fib
    }

    def getNaturalNumbers(from: Long, step: Long) : Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(from, result map(_ + step))
        result
    }

    def getPrimeNumbers(): Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(2, getNaturalNumbers(3, 2) filter {
            n => result.takeWhile(p => p * p <= n).forall(n % _ != 0)
        })
        result
    }

    def timedExecute(f: => Any) = {
        println()
        println("--------------------> Starting <---------------------")
        val start = System.nanoTime
        f
        println("------------------> Executed in " + ((System.nanoTime - start) / 1000000000d) + " seconds <-------------------")
    }
}

ProjectEuler - problem4

2010-01-24T12:59:00.008+03:00

Problem definition;

Algorithm;

Implementation;

Under the covers;

Problem definition

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.

Algorithm

I used the following algorithm for solving the problem:

implement sub-routine that allows to answer if given number is palindrome;

iterate all candidate products of three-digits numbers, filter all palindroms from them and find the greatest;

We define a loop to iterate all candidate three-digits numbers and an inner loop to iterate all interested three-digits numbers in order to process their product. We can apply couple of optimizations here:

iterate numbers in descending order - it's clear that the larger numbers produce larger products;

use current outer loop value as a starting point for the inner loop in order to avoid duplicate processing like '123 * 456' and '456 * 123';

stop inner loop processing as soon as product value is less than or equal to the max product value known at the moment - there is no point in continuing since the product values decrease during inner loop processing;

stop outer loop processing as soon as current value is less that or equal to the square root of the currently known max product value - that is implied from the two previous points because max inner loop iterable value is equal to the current outer loop variable value and the products of inner and outer loop variables are decreased during inner loop processing;

We can provide one more optimization here - suppose our resulting palindrome (P) is written as 'abccba' number. We can observe the following then:

P = 100000 * a + 10000 * b + 1000 * c + 100* c + 10 * b + a
P = 100001 * a + 10010 * b + 1100 * c
P = 11* (9091 * a  910 * b  100 * c

That means that resulting palindrome is divisible by 11, hence, at least one of the target three-digits numbers is divisible by 11. That produces the following optimization:

we use step '11' at inner loop if current outer loop variable is not divisible by 11;

Implementation

Here is a Scala implementation of the algorithm mentioned above. Note that we use varios palindrome checks and either optimized or non-optimized algorithms here:

P4.scala


package net.projecteuler.p4

import net.projecteuler.util.ProjectEulerUtil.getNaturalNumbers
import Math.sqrt

/**
 * @author Denis Zhdanov
 * @since Jan 20, 2010
 */
object P4 extends Application {

    def isPalindrome1(i: Long) = {
        i.toString == i.toString.reverse.mkString
    }

    def isPalindrome2(i: Long) = {
        var buffer = i
        var reversed = 0L
        while (buffer > 0) {
            reversed = (reversed * 10) + (buffer % 10)
            buffer /= 10
        }
        i == reversed
    }

    def isPalindrome3(i: Long) = {
        lazy val reversedDigits: Stream[(Long, Long)] =
            Stream.cons((i % 10, i / 10), reversedDigits.map(t => (t._2 % 10, t._2 / 10)))

        i == (reversedDigits.takeWhile(t => t._1 > 0 || t._2 > 0) :\ (0L, 1L)) {
            (t, p) => (t._1 * p._2 + p._1, p._2 * 10)
        }._1
    }

    def isPalindrome4(i: Long) = {
        def reverse(j: Long, result: Long) : Long = {
            if (j <= 0) result
            else reverse(j / 10, result * 10 + j % 10)
        }
        i == reverse(i, 0)
    }

    val resultSet = scala.collection.mutable.Set.empty[Long]

    def solve(isPalindrome: Long => Boolean, innerSeqGenerator: (Long) => Range) = {
        var result = 0L
        var bound = 0.0

        def continueIteration(i: Long): Boolean = {
            if (i <= bound) false
            else {
                innerSeqGenerator(i).map(i * _).dropWhile {
                    j => j > result && !isPalindrome(j)
                }.firstOption match {
                    case Some(candidate) =>
                        if (isPalindrome(candidate) && candidate > result) {
                            result = candidate
                            bound = sqrt(result)
                        }
                    case _ =>
                }
                true
            }
        }

        new Range.Inclusive(999, 100, -1).takeWhile(continueIteration( _)).last
        resultSet += result
    }

    def usualInnerRangeGenerator(i: Long) = {
        new Range.Inclusive(i.toInt, 100, -1)
    }

    def optimizedInnerRangeGenerator(i: Long) = {
        if (i % 11 == 0) new Range.Inclusive(i.toInt, 100, -1)
        else new Range.Inclusive(getNaturalNumbers(i - 1, -1).dropWhile(_ % 11 != 0).head.toInt, 100, -11)
    }

    for ((algoName, seqGenerator) <- List(
        ("usual", usualInnerRangeGenerator _), ("optimized", optimizedInnerRangeGenerator _))
    ) {
        println(algoName + " algorithm:")
        for ((checkName, check) <- List(
            ("string-based", isPalindrome1 _), ("imperative", isPalindrome2 _),
            ("fold-tuple", isPalindrome3 _), ("recursive", isPalindrome4 _))
        ) {
            print("\t" + checkName + " check: avg time = ")
            val start = System.nanoTime
            for (i <- 0 to 100) {
                solve(check, seqGenerator)
            }
            println((System.nanoTime - start) / 1000000000d / 100 + " seconds")            
        }
        println
    }
    println ("result: " + resultSet)
}

ProjectEulerUtil.scala


package net.projecteuler.util

import collection.mutable.ListBuffer

/**
 * Holds utility methods for the ProjectEuler task classes and objects.
 *
 * @author Denis Zhdanov
 * @since Jan 5, 2010
 */
object ProjectEulerUtil {

    def getFibonacciStream() : Stream[Long] = {
        lazy val fib: Stream[Long] = Stream.cons(0, Stream.cons(1, fib.zip(fib.tail).map(t => t._1 + t._2)))
        fib
    }

    def getNaturalNumbers(from: Long, step: Long) : Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(from, result map(_ + step))
        result
    }

    def getPrimeNumbers(): Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(2, getNaturalNumbers(3, 2) filter {
            n => result.takeWhile(p => p * p <= n).forall(n % _ != 0)
        })
        result
    }

    def execute(f: => Any) = {
        println()
        println("--------------------> Starting <---------------------")
        val start = System.nanoTime
        f
        println("------------------> Executed in " + ((System.nanoTime - start) / 1000000000d) + " seconds <-------------------")
    }
}

Under the covers

I want to talk here about various implementations of 'isPalindrome' checks. Let's briefly enumerate them:

isPalindrome1 - uses standard API for converting given number to string, reversing its characters and checking reversed version against initial;

isPalindrome2 - performs examination without unnecessary string/character processing. Written in imperative way;

isPalindrome3 - uses scala Stream folding in order to achieve the desired result. It was some kind of challenge for me to write it, so, don't consider it to be a real-life approach. It's the worst implementation because the code is hard to understand and a lot of objects are created during processing;

isPalindrome4 - classic functional style-based recursive implementation;

If we run the example we see that imperative check performs approximately the same as recursive check. It's interesting to understand the reason of that. We can check generated java byte code for those methods:

imperative check


 0 lload_1
 1 lstore_3
 2 lconst_0
 3 lstore 5
 5 lload_3
 6 lconst_0
 7 lcmp
 8 ifle 34 (+26)
11 lload 5
13 ldc2_w #109 <10>
16 lmul
17 lload_3
18 ldc2_w #109 <10>
21 lrem
22 ladd
23 lstore 5
25 lload_3
26 ldc2_w #109 <10>
29 ldiv
30 lstore_3
31 goto 5 (-26)
34 lload_1
35 lload 5
37 lcmp
38 ifne 45 (+7)
41 iconst_1
42 goto 46 (+4)
45 iconst_0
46 ireturn

recursive check (reverse() function):


 0 lload_1
 1 lconst_0
 2 lcmp
 3 ifgt 8 (+5)
 6 lload_3
 7 lreturn
 8 lload_1
 9 ldc2_w #109 <10>
12 ldiv
13 lload_3
14 ldc2_w #109 <10>
17 lmul
18 lload_1
19 ldc2_w #109 <10>
22 lrem
23 ladd
24 lstore_3
25 lstore_1
26 goto 0 (-26)

We can see that scala compiler transformed tail-recursive 'reverse()' into a loop, i.e. its byte code instructions are almost the same as the one generated for imperative approach. That shows that writing the code in functional style doesn't imply that it performs worse than the one written in imperative style. That's cool!

ProjectEuler - problem3

2010-01-19T22:45:00.004+03:00

Problem definition;

Optimized prime numbers generator;

Solution;

Problem definition

The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143 ?

Optimized prime numbers generator

I optimized a little prime numbers generator introduced during problem5 solving. The general idea is that there is an only even prime number - '2', hence, we need to check only odd numbers if they are prime.

Here is the optimized approach:

ProjectEulerUtil.scala


package net.projecteuler.util

/**
 * Holds utility methods for the ProjectEuler task classes and objects.
 *
 * @author Denis Zhdanov
 * @since Jan 5, 2010
 */
object ProjectEulerUtil {

    def getFibonacciStream() : Stream[Long] = {
        lazy val fib: Stream[Long] = Stream.cons(0, Stream.cons(1, fib.zip(fib.tail).map(t => t._1 + t._2)))
        fib
    }

    def getNaturalNumbers(from: Long, step: Long) : Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(from, result map(_ + step))
        result
    }

    def getPrimeNumbers(): Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(2, getNaturalNumbers(3, 2) filter {
            n => result.takeWhile(p => p * p <= n).forall(n % _ != 0)
        })
        result
    }

    def execute(f: => Any) = {
        println()
        println("--------------------> Starting <---------------------")
        val start = System.nanoTime
        f
        println("------------------> Executed in " + ((System.nanoTime - start) / 1000000000d) + " seconds <-------------------")
    }
}

You can see that we increment all prime number candidates by two starting from '3' now.

Solution

We follow the same idea that was used during problem5 solving - any number may be represented as a multiplication of different numbers of prime factors. That means that if particular number N is divisible by two prime numbers P₁ and P₂ and P₁ is less than sqrt(N) then P₂ is greater than sqrt(N). Implication: if particular number N is not divisible by prime numbers less than srqt(N) than 'N' is prime.

We use the idea above for solving the problem. Solution is to iterate prime numbers and reducing target number by dividing it by all of them that produce no reminder. That process is stopped as soon as we reach sqrt of the current reminder:

P3.scala


package net.projecteuler.p3

import net.projecteuler.util.ProjectEulerUtil._
import Math._

/**
 * @author Denis Zhdanov
 * @since Jan 19, 2010
 */
object P3 extends Application {

    var target = 600851475143L
    var bound = sqrt(target)

    def updateTarget(prime: Long) {
        target /= prime
        bound = sqrt(target)
    }

    def process(prime: Long) : Boolean = {
        target % prime match {
            case 0 => {updateTarget(prime); process(prime)}
            case _ => prime <= bound
        }
    }

    getPrimeNumbers.takeWhile(process _).last // necessary to call because Stream elements are calculated lazily
    println(target)
}

MTGO Zendicar block - Vampires deck

2010-01-17T14:37:00.025+03:00

I like to play Magic: The Gathering (MTG) from time to time. It's nice to play it with friends using paper cards and possible to play with digital cards online - Magic: The Gathering Online (MTGO).

There was a big gap since I played MTGO last time, so, I created a new deck to use within the ZEN Block format tournaments. Today was a first victory with it.

The basic idea is to use a vampire creatures and spells because there are some cool abilities and spells related to them.

Creature

- it's really cool because of ability to return to the battlefield from the graveyard every time you play a new land;

- forces opponent to sacrifice a creature, hence, may be used to destroy creatures with shroud and activate abilities triggered on moving creature to graveyard from the battlefield;

- flying, protection from white and nice ability to drain life from foe (that's one of the features of vampires-based deck I was talking before - more vampires you have more life is drained);

- cheap price, first strike and ability to remove all counters from the target creature. Note that the last may be used to destroy planeswalkers. Very mighty!

- really, really cool guy. Flying, deathtouch, lifelink and life equal to three (means that it can resist popular black spells that hit target creature to 2 damage);

- it's only features are that it's a vampire, cheap price and ability to hit opponent every time he or she enters new creature to the game. However, that's not so impressing. I'm going to drop that card from the deck;

Spells

- very strong spell because it's cheap, can be applied against black creatures and you get a life from it appliance;

- instant creature enhancer with convenient ability to grant life link for additional mana;

- nice to use to kill enemy creatures;

- very strong enhancement that may hit opponent a lot;

- haven't had a chance to use it at a tournament game but believe that it's very powerful. I put it to the sideboard at the moment in order to include to the main deck if I see that the foe uses a cards that brings him or her life;

- this spell lives at sideboard at the moment. I'm planning to use it against blue control decks;

Support

- it's very nice to have your vampires characteristics improved a lot. I have couple of such blades at the deck;

- it's nice to return your vampires from the graveyard;

- haven't had a chance to try his abilities over than 'two damage to target creature or player...' but believe that another skills are also cool;

Jni dll and IDE

2010-01-15T14:39:00.010+03:00

I got a wierd problem today - my java application uses native '*.dll' and it failed to load it with the reason 'Exception in thread "main" java.lang.UnsatisfiedLinkError: C:\projects\ddelink\dll\jWinAPI.dll: Can't find dependent libraries'.

The wierd part is that the application worked fine if I launched the same IDEA-compiled '*.class' files from the same IDEA output location. I checked that values of the 'java.library.path' jvm property and 'PATH' env variable were the same in both cases (launching application from IDE and from command-line).

Eventually the problem was solved by explicitly adding JNI '*.dll' files location to the 'PATH' env variable.

Conclusion: it seems that jvm process launched from command-line is smart enough to use jni *.dll files provided with the jre but it fails to do that in case of launch from IDE (that's true at least for IDEA).

Spring xsd loading algorithm

2010-01-12T22:20:00.020+03:00

People often complain that spring tries to open network connection during application context initialization in order to load '*.xsd' file(s). That shouldn't occur under normal circumstances, however, that is a case especially during application server participation. I'm going to briefly describe low-level details of '*.xsd' loading algorithm used by spring.

'*.xsd' is necessary for describing the rules of spring xml context construction. E.g. the following simple spring xml config snippet defines three spring schemas - 'beans', 'aop' and 'context':

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

<context:component-scan base-package="com.spring.example.aop"/>

<bean id="methodInterceptor" class="com.spring.example.aop.AopMethodInterceptor"/>
    <bean id="pojoAspect" class="com.spring.example.aop.PojoAspect"/>

<aop:config>
<aop:advisor advice-ref="methodInterceptor" pointcut="execution(* com.spring.example.aop.AopService.*(..))"/>
    </aop:config>

<aop:config>
<aop:aspect ref="pojoAspect">
            <aop:before method="pojoAdvice" pointcut="execution(* com.spring.example.aop.AopService.*(..))"/>
        </aop:aspect>
</aop:config>

</beans>

Let's see what happens when we instantiate spring context with such config:

Spring shoud parse the '*.xml';

Spring defines custom EntityResolver for the xml parser - DelegatingEntityResolver;

'DelegatingEntityResolver.resolveEntity()' calls PluggableSchemaResolver.resolveEntity();

'PluggableSchemaResolver.resolveEntity()' calls 'PluggableSchemaResolver.getSchemaMappings()';

'PluggableSchemaResolver.getSchemaMappings()' tries to load properties from all resources named 'META-INF/spring.schemas' ('PluggableSchemaResolver.DEFAULT_SCHEMA_MAPPINGS_LOCATION') found at classpath during calling to PropertiesLoaderUtils.loadAllProperties();

'PluggableSchemaResolver.resolveEntity()' tries to resolve target shema against classpath using the data from loaded properties;

And here is a 'PropertiesLoaderUtils.loadAllProperties()' code:


public static Properties loadAllProperties(String resourceName, ClassLoader classLoader) throws IOException {
    Assert.notNull(resourceName, "Resource name must not be null");
    ClassLoader clToUse = classLoader;
    if (clToUse == null) {
        clToUse = ClassUtils.getDefaultClassLoader();
    }
    Properties properties = new Properties();
    Enumeration urls = clToUse.getResources(resourceName);
    while (urls.hasMoreElements()) {
        URL url = (URL) urls.nextElement();
        InputStream is = null;
        try {
            URLConnection con = url.openConnection();
            con.setUseCaches(false);
            is = con.getInputStream();
            properties.load(is);
        }
        finally {
            if (is != null) {
                is.close();
            }
        }
    }
    return properties;
}

Let's check the processing one more time on 'beans' schema example:

Our xml config defines 'beans' schema location as 'http://www.springframework.org/schema/beans/spring-beans-3.0.xsd';

All contents of classpath resources named 'META-INF/spring.schemas' are loaded;

There is 'META-INF/spring.schemas' file at 'spring-beans.jar', it contains property 'http\://www.springframework.org/schema/beans/spring-beans-3.0.xsd=org/springframework/beans/factory/xml/spring-beans-3.0.xsd' among the others;

'PluggableSchemaResolver' tries to load schema data from classpath resource defines as a target property value ('org/springframework/beans/factory/xml/spring-beans-3.0.xsd');

You can see that there is 'org/springframework/beans/factory/xml/spring-beans-3.0.xsd' resource inside 'spring-beans.jar'. It's loaded and returned as a resolved xml entity;

That's it - target '*.xsd' file is loaded from classpath. Spring tries to load it from the web if it can't be loaded from classpath.
Note: spring uses the same technique for loading namespace handlers necessary for correct context instantiation - see DefaultNamespaceHandlerResolver. That's the reason why you should define custom schema definition and handler at 'META-INF/spring.schemas' and 'META-INF/spring.handlers' files as described at the reference.

ProjectEuler - problem5

2010-01-12T08:53:00.008+03:00

Problem definition

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 number that is evenly divisible by all of the numbers from 1 to 20?

Solution (pen and paper)

The task can be easily solved analytically - we know that every non-prime number may be represented as a multiplication of prime number factors (prime factorization). E.g. we can check that the least common multiple for the natural numbers less or equal to ten (as provided at the problem definition). We can derive prime factorization for all numbers from [1; 10] range:

1 = 1¹
2 = 2¹
3 = 3¹
4 = 2²
5 = 5¹
6 = 2¹ * 3¹
7 = 7¹
8 = 2³
9 = 3²
10 = 2¹ * 5¹

We can conclude that the least common multiple for that numbers is a multiplication of all prime numbers less or equal to ten with max factor occurred at the prime factorizations, i.e.

2³ * 3² * 5¹ * 7¹ = 2520

We can follow the same principle for calculating least common multiple for the numbers less or equal to 20:

1 = 1¹
2 = 2¹
3 = 3¹
4 = 2²
5 = 5¹
6 = 2¹ * 3¹
7 = 7¹
8 = 2³
9 = 3²
10 = 2¹ * 5¹
11 = 11¹
12 = 2² * 3¹
13 = 13¹
14 = 2¹ * 7¹
15 = 3¹ * 5¹
16 = 2⁴
17 = 17¹
18 = 2¹ * 3²
19 = 19¹
20 = 2² * 5¹

result = 2⁴ * 3² * 5¹ * 7¹ * 11¹ * 13¹ * 17¹ * 19¹ = 232792560

Prime numbers generator

Let's create a program that solves the same task. We'll need prime numbers generator for that. Scala allows to create the one via very natural and convenient syntax:

ProjectEulerUtil.scala

package net.projecteuler.util

/**
 * Holds utility methods for the ProjectEuler task classes and objects.
 *
 * @author Denis Zhdanov
 * @since Jan 5, 2010
 */
object ProjectEulerUtil {

    def getFibonacciStream() : Stream[Long] = {
        lazy val fib: Stream[Long] = Stream.cons(0, Stream.cons(1, fib.zip(fib.tail).map(t => t._1 + t._2)))
        fib
    }

    def getNaturalNumbers(from: Long) : Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(from, result map(_ + 1))
        result
    }

    def getPrimeNumbers(): Stream[Long] = {
        lazy val result: Stream[Long] = Stream.cons(2, getNaturalNumbers(3) filter {
            n => result.takeWhile(p => p * p <= n).forall(n % _ != 0)
        })
        result
    }

    def execute(f: => Any) = {
        println()
        println("--------------------> Starting <---------------------")
        val start = System.nanoTime
        f
        println("------------------> Executed in " + ((System.nanoTime - start) / 1000000000d) + " seconds <-------------------")
    }
}

We are interested in 'getNaturalNumbers()' and 'getPrimeNumbers()' methods here.

getNaturalNumbers()
The main interesting thing here is 'Stream.cons(from, result map(_ + 1))'. What do we do here - define an infinite list of lazily calculated eight-byte values where the first value is the one given as a method parameter ('from') and any subsequent value is calculated as a previous value plus one ('result map(_ + 1)').

getPrimeNumbers()
Things get little more complicated here:

define a prime numbers stream with first element '2' ('Stream.cons(2, ...)');
any subsequent prime number candidate is retrieved from the stream of natural numbers and prime number criteria is that it's not divisible to already discovered prime numbers ('filter(n => takeWhile(...).forall(n % _ != 0))');
we check if prime number candidate is really prime number by examining if it is divisible by the already discovered prime numbers that are less or equal to the square root of the candidate ('result.takeWhile(p => p * p <= n)'). This is optimization in comparison with the approach when we check all discovered prime numbers ('result.takeWhile(p => p < n)'). The rationale is that any number that is divisible by the prime number greater that sqrt(candidate) is also divisible by the prime number less than sqrt(candidate). Hence, we can be sure that the number is prime if it is not divisible by prime numbers less or equal to the sqrt(number);

Solution (program)

So, our task is to find out max prime number factors for all prime numbers less than or equal to the target bound and perform multiplication of prime numbers at that factors. Rephrasing, the task is to check all prime numbers less than or equal to the target bound number and find max 'n' from the following inequality:

primeⁿ <= targetBound

We can derive the following formula for 'n' than:

n <= floor(log_prime(targetBound)) = floor(ln(targetBound) / ln(prime))

It's clear that all prime numbers from (sqrt(bound); bound] have max factor equal to one, so, our program performs logarithm-involved processing for all prime numbers less than or equal to sqrt(bound) and simple multiplication for other prime numbers:

P5.scala

package net.projecteuler.p5

import net.projecteuler.util.ProjectEulerUtil._
import Math._

/**
 * @author Denis Zhdanov
 * @since Jan 10, 2010
 */
object P5 extends Application {
    execute {
        val targetBound = 20
        val bound = sqrt(targetBound)

        val partialResult = (1L /: getPrimeNumbers.takeWhile(_ <= bound)) {
            (i, j) => i * pow(j, floor(log(targetBound) / log(j))).toLong
        }

        val result = (partialResult /: getPrimeNumbers().dropWhile(_ <= bound).takeWhile(_ <= targetBound))(_ * _)
        println(result)
    }
}

ProjectEuler - problem6

2010-01-09T22:51:00.009+03:00

Problem definition

The sum of the squares of the first ten natural numbers is,
1² + 2² + ... + 10² = 385

The square of the sum of the first ten natural numbers is,
(1 + 2 + ... + 10)² = 55² = 3025

Hence 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.

Brute force (imperative style)

ArithmeticProgression.scala

package net.projecteuler.util

/**
* @author Denis Zhdanov
* @since Jan 5, 2010
*/
case class ArithmeticProgression(val base: Long, val step: Long) {

    def element(index: Long) = base + index * step

    def sumByElementsCount(elementsNumber: Long) = (base + element(elementsNumber - 1)) * elementsNumber / 2

    def sumByLastFloorElement(element: Long) = sumByElementsCount(1 + (element - base) / step)
}

P3.scala

package net.projecteuler.p3

import net.projecteuler.util.ArithmeticProgression

/**
* @author Denis Zhdanov
* @since Jan 9, 2010
*/
object P3 extends Application {
    val i = ArithmeticProgression(1, 1).sumByLastFloorElement(100)
    var j = 0L
    for (k <- 1 to 100) j += k * k
    println(i * i - j)
}

Brute force (functional style)

package net.projecteuler.p3

import net.projecteuler.util.ArithmeticProgression
import Math._

/**
* @author Denis Zhdanov
* @since Jan 9, 2010
*/
object P3 extends Application {
    val squareOfSum = pow(ArithmeticProgression(1, 1).sumByLastFloorElement(100), 2)
    val sumOfSquares = (0.0 /: (1 to 100))(_ + pow(_, 2))
    println(squareOfSum - sumOfSquares)
}

Algorithm optimization

You see that square of sum is calculated in constant time using the formula of arithmetic progression sum. However, we still have linear complexity for the part that calculates sum of squares. We're going to work out a formula for that.

Sum of cubes formula:

(n + 1)³ = (n + 1) * (n + 1) * (n + 1) = (n + 1) * (n² + 2n + 1) = n³ + 3 * n² + 3 * n + 1

Let's write down sequence of the equation above with parameters n, (n - 1), (n -2), (n - 3), ..., 1:

(n + 1)³ = n³ + 3 * n² + 3 * n + 1
n³ = (n - 1)³ + 3 * (n - 1)² + 3 * (n - 1) + 1
(n - 1)³ = (n - 2)³ + 3 * (n - 2)² + 3 * (n - 2) + 1
...
2³ = 1³ + 3 * 1² + 3 * 1 + 1

Let's summarize left and right part of the equations above and drop identical members. We get the following then:

(n + 1)³ = 1³ + 3 * (n² + (n - 1)² + ... + 1²) + 3 * (n + (n - 1) + (n - 2) + ... + 1) + (1 + 1 + 1 + ... + 1)

We can see that the second element of the right part of the equation above is our target sum (n² + (n - 1)² + ... + 1²). Define it as S, apply arithmetic progression sum formula to the third element and rewrite the equation:

3 * S = (n + 1)³ - 1 - 3 * n * (n + 1) / 2 - n = (n + 1) * ((n + 1)² - 3/2 * n - 1) = (n + 1) (n² + 2n + 1 - 3/2 * n - 1) = n * (n + 1) (n + 1/2) = n * (n + 1) * (2n + 1) / 2

That produces the following formula for our target sum of squares:

S = n * (n + 1) * (2n + 1) / 6

Final version

We can apply the formula deduced above and get the following solution that works with O(1) complexity:

package net.projecteuler.p3

import net.projecteuler.util.ArithmeticProgression
import Math._

/**
* @author Denis Zhdanov
* @since Jan 9, 2010
*/
object P3 extends Application {
    val elementsNumber = 100
    val squareOfSum = pow(ArithmeticProgression(1, 1).sumByLastFloorElement(elementsNumber), 2)
    val sumOfSquares = elementsNumber * (elementsNumber + 1) * (2 * elementsNumber + 1) / 6
    println(squareOfSum - sumOfSquares)
}

ProjectEuler - problem2

2010-01-08T21:17:00.016+03:00

Problem definition;

Brute force (imperative style);

Brute force (functional style);

Brute force algorithm optimization;

Optimized brute fortce (imperative style);

Optimized brute fortce (functional style);

Further optimization;

Target Fibonacci numbers sum formula;

Binet's Formula;

Resulting solution;

Problem definition

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, ...

Find the sum of all the even-valued terms in the sequence which do not exceed four million.

Brute force (imperative style)

Here is a simple program written in imperative style that acts exactly the same as defined at the problem definition - iterates via Fibonacci numbers until the number over than four millions is reached and summarize even numbers:


package net.projecteuler.p2

/**
 * @author Denis Zhdanov
 * @since Jan 6, 2010
 */
object P2 extends Application {
    var i = 1L
    var j = 2L
    var t = j
    var sum = 0L
    while (t < 4000000) {
        if (j % 2 == 0) sum = sum + j
        t = i + j
        i = j
        j = t
    }
    println(sum)
}

Brute force (functional style)

We can rewrite the program above using functional style. It shows how cleaner the code is:

ProjectEulerUtil.scala


package net.projecteuler.util

/**
 * Holds utility methods for the ProjectEuler task classes and objects.
 *
 * @author Denis Zhdanov
 * @since Jan 5, 2010
 */
object ProjectEulerUtil {

    def getFibonacciStream() : Stream[Long] = {
        lazy val fib: Stream[Long] = Stream.cons(0, Stream.cons(1, fib.zip(fib.tail).map(t => t._1 + t._2)))
        fib
    }
}

P2.scala


package net.projecteuler.p2

import net.projecteuler.util.ProjectEulerUtil

/**
 * @author Denis Zhdanov
 * @since Jan 6, 2010
 */
object P2 extends Application {
    val fib = ProjectEulerUtil.getFibonacciStream()    
    println(fib.filter(f => f % 2 == 0).takeWhile(f => f < 4000000).foldLeft(0L)(_ + _))
}

Let's point out what we did here:

define Fibonacci sequence as scala.Stream[Long], i.e. as an unbound list of eight-byte elements that are calculated lazily (ProjectEulerUtil.getFibonacciStream());

use helper object scala.Stream.cons that allows to build a Stream instance for the given head element and tail Stream;

define target Fibonacci stream with the help of Stream.cons where the first element is zero ('Stream.cons(0, ... /* tail Stream */');

define that the second Fibonacci stream element is one ('Stream.cons(0, Stream.cons(1, .../* tails Stream */))')

define the rule for calculating Fibonacci numbers over than the first and the second - 'fib.zip(fib.tail).map(t => t._1 + t._2)'. Here 'fib.zip(fib.tail)' states that we assemble two number sequences together - '0 1 1 2 3 ...' and '1 1 2 3 5 ...' in order to get sequence of pairs - '(0, 1) (1, 1) (1, 2) (2, 3) (3, 5)' (feel free to check Stream.zip() method contract for more details about that). Than we define a rule that produces single element as a sum of the pair of number - 'map(t => t._1 + t._2)' (feel free to check Stream.map() contract for more details about that);

define a rule to skip odd Fibonacci elements - 'fib.filter(f => f % 2 == 0)';

define a rule that we want to get Fibonacci numbers that don't exceed for millions - 'fib.takeWhile(f => f < 4000000)';

apply a function that summarize all given elements starting from the zero to the filtered Fibonacci numbers substream (even numbers that don't exceed for millions) - 'fib.foldLeft(0L)(_ + _)';

Brute force algorithm optimization

Ok, we see that the problem is solved now but solution has a liniar complexity, i.e. the program takes much more time if we are asked to use not four millions as an upper bound but a bigger value. Let's check if the solution can be improved.

Let's write Fibonacci sequence start and analyze it:

0 1 1 2 3 5 8 13 21 34 55 89 144 ...

We can drop the first sequence element (zero) because it doesn't affect net result and check that only every third number is even (it's easy to provide strict proof for that). So, we can optimize the algorithm by avoiding odd values calculation, i.e. we can calculate directly even values. I.e. our task is to work out a formula that allows to calculate F_{n + 6} via F_{n + 3} and F_n values (here F_n is n-th Fibonacci sequence member):

F_n+6 = F_n+5 + F_n+4

F_n+6 = (F_n+4 + F_n+3) + (F_n+3 + F_n+2)

F_n+6 = 2 * F_n+3 + F_n+2 + F_n+4

F_n+6 = 2 * F_n+3 + F_n+2 + (F_n+3 + F_n+2)

F_n+6 = 3 * F_n+3 + F_n+2 + F_n+2

F_n+6 = 3 * F_n+3 + F_n+2 + (F_n+1 + F_n)

F_n+6 = 3 * F_n+3 + (F_n+2 + F_n+1) + F_n

F_n+6 = 3 * F_n+3 + F_n+3 + F_n

F_n+6 = 4 * F_n+3 + F_n

Optimized brute fortce (imperative style)

Let's apply the formula produced above to our solution. Let's start with imperative approach at first:


package net.projecteuler.p2

/**
 * @author Denis Zhdanov
 * @since Jan 6, 2010
 */
object P2 extends Application {
    var i = 2L
    var j = 8L
    var t = j
    var sum = 2L
    while (t < 4000000) {
        sum = sum + j
        t = 4 * j + i
        i = j
        j = t
    }
    println(sum)
}

Optimized brute fortce (functional style)

Let's rewrite the same optimized brute force algorithm using functional style (note that we slightly modified our functional approach in order to exploit scala language syntax sugar):


package net.projecteuler.p2

/**
 * @author Denis Zhdanov
 * @since Jan 6, 2010
 */
object P2 extends Application {
    lazy val fib: Stream[Long] = Stream.cons(2, Stream.cons(8, fib.zip(fib.tail).map(t => t._1 + 4 * t._2)))
    println((0L /: fib.filter(_ % 2 == 0).takeWhile(_ < 4000000))(_ + _))
}

Further optimization

We optimized the algorithm but it still has an O(n) complexity. Let's try to improve it further. Let's check our sequence one more time:

0 1 1 2 3 5 8 13 21 34 55 89 144 ...

We know that the main Fibonacci sequence characteristics is that 'F_n = F_{n - 1} + F_{n - 2}', so, we can conclude that the sum of the target Fibonacci numbers (highlighted) is a half of the sum of all Fibonacci numbers - target numbers follow each other in two elements, that means that every target number is equal to the sum of the previous two numbers. Conclusion: we can calculate sum of all Fibonacci numbers stopping at the last even number that doesn't exceed four millions, divide it by two and get desired result.

Target Fibonacci numbers sum formula

Our task is to work out a formula for Fibonacci numbers sum. Let's write down a following equations sequence:

F₁ = F₃ - F₂

F₂ = F₄ - F₃

F₃ = F₅ - F₄

...

F_n-1 = F_n+1 - F_n

F_n = F_n+2 - F_n+1

We can summarize all parts of the equations above and get the following then:

F₁ + F₂ + F₃ + ... + F_n-1 + F_n = F_{n + 2} - F₂ = F_n+2 - 1

Binet's Formula

Ok, we know that sum of n Fibonacci numbers may be calculated via (n + 2)-th member. That means that we need to know how to calculate any Fibonacci number by it's index. There is a special formula for that - Binet's Formula:

is calculated as a root of the following equation - 'x² = x + 1'

Let's prove the formula. We'll use Math induction for that:

Check that the formula holds true for the first and second Fibonacci numbers;

Proof that the formula is correct for the n-th number assuming that it's correct for the (n - 1)-th and (n - 2)-th numbers

Let's define the following quantities in order to make the proof more readable:

a = (1+sqrt[5])/2,

b = (1-sqrt[5])/2 = -1/a

We get the following then:

F_n = F_n-1 + F_n-2 = (a^n-1 - b^n-1) / (a - b) + (a^n-2 - b^n-2) / (a - b) = (a^n-1 + a^n-2 - b^n-1 - b^n-2) / (a - b) = (a^n-2(a + 1) - b^n-2(b + 1)) / (a - b)

We remember that 'a' is a root of 'x² = x + 1' equation but 'b' is another root of the same equation, i.e. 'a + 1 = a²' and 'b + 1 = b²'. We can apply that to the last equation and get the following:

F_n = (aⁿ - bⁿ) / (a - b)

Resulting solution

There is an important consequence from Binet's Formula - n-th Fibonacci number can be calculated by rounding the following expression result:

Also we remember that every three consequent numbers from our target sequence contain two odd numbers and one even number.

Here is resulting solution:


package net.projecteuler.p2

import Math._

/**
 * @author Denis Zhdanov
 * @since Jan 6, 2010
 */
object P2 extends Application {

    val Phi = 1.6180339887
    val FiveSqrt = sqrt(5.0)

    /**
     * Calculates n-th element of the target sequence.
     * <p/>
     * We use 'n + 1' inside because target sequence is not pure Fibonacci sequence
     * ('1 2 3 5 ...' vs '0 1 1 2 3 4 ...').
     */
    def nthElement(n: Long) = round(pow(Phi, n + 1) / FiveSqrt)

    /**
     * Searches for the index of the target sequence element that is even and don't exceed given bound value.
     */
    def lastIndex(bound: Long) : Int = {
        val i: Int = (log(bound * sqrt(5)) / log(Phi)) toInt
        val result =
            if (bound % 2 == 0 && bound == nthElement(i - 1)) i - 1 // Given bound is even sequence element
            else (0 /: (i - 3 to i - 1).filter(nthElement(_) % 2 == 0))(_ + _) // Check previous three elements
        result
    }

    println((nthElement(lastIndex(4000000) + 2) - 1) / 2)
}

We do exactly the following here:

Provide ability to calculate n-th sequence element ('nthElement()' method);

Provide ability to find index of the max sequence element that is even and less or equal to the given number ('lastIndex()' method);

Calculate result via calculating total sequence elements sum and dividing it by two;

Resulting complexity is O(1).

Spring1 and Spring2 AOP interoperability

2010-01-05T23:45:00.004+03:00

rationale;

Source code;

AopService;

AopMethodInterceptor;

PojoAspect;

spring-config.xml;

SpringStart;

Rationale

I really don't understand the reasons but many developers still use spring1 aop style (explicit ProxyFactoryBean and various Advisor implementations usage). I just want to point out that spring2 aop (aspectj-based) is completely interoperable with the spring1 aop style. I.e. it's possible to perform a graceful migration of old project to the new approach which is more concise and less verbose. I'm going to provide couple of examples of that.

Source code

Source code packaged as a maven2 project may be downloaded here.

AopService.java

Target aop-advised service:


package com.spring.example.aop;

import org.springframework.stereotype.Component;

/**
 * @author Denis Zhdanov
 * @since Jan 5, 2010
 */
@Component
public class AopService {

    public void test() {
        System.out.println("AopService.test()");
    }
}

AopMethodInterceptor.java

Spring1-based advice:


package com.spring.example.aop;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
 * @author Denis Zhdanov
 * @since Jan 5, 2010
 */
public class AopMethodInterceptor implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("AopMethodInterceptor.invoke()");
        return invocation.proceed();
    }
}

PojoAspect.java

Pojo aspect:


package com.spring.example.aop;

import org.aopalliance.intercept.MethodInvocation;

/**
 * @author Denis Zhdanov
 * @since Jan 5, 2010
 */
public class PojoAspect {

    public void pojoAdvice() {
        System.out.println("PojoAspect.pojoAdvice()");
    }
}

spring-config.xml


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <context:component-scan base-package="com.spring.example.aop"/>

    <bean id="methodInterceptor" class="com.spring.example.aop.AopMethodInterceptor"/>
    <bean id="pojoAspect" class="com.spring.example.aop.PojoAspect"/>

    <aop:config>
        <aop:advisor advice-ref="methodInterceptor" pointcut="execution(* com.spring.example.aop.AopService.*(..))"/>
    </aop:config>

    <aop:config>
        <aop:aspect ref="pojoAspect">
            <aop:before method="pojoAdvice" pointcut="execution(* com.spring.example.aop.AopService.*(..))"/>
        </aop:aspect>
    </aop:config>
    
</beans>

SpringStart.java

Driver class:


package com.spring.example;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.spring.example.aop.AopService;

public class SpringStart {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        context.getBean(AopService.class).test();
    }
}

We get the following result if we run the example:


AopMethodInterceptor.invoke()
PojoAspect.pojoAdvice()
AopService.test()

I.e. all spring1-based aspects are successfully intergrated with aspectj + aop scheme configuration approach.

programming addicted

Exploring the world: Eclipse after IntelliJ

Table of contents

Swing color keys

Closing Empathy chat by 'escape;

Empathy opens hyperlinks at new browser window

IntelliJ IDEA: from Windows to Linux

Fanboys!

IDEA candy - column mode

Table of contents

IDEA candy - custom context menu

Table of contents

The Black Keys

Intellij IDEA X is here

Free time

IDEA candy - find usages trick

Table of contents

IDEA candy - Highlighting by exception

Table of contents

IDEA candy - Harnessing debugger

Table of contents

IDEA candy - Live code formatting

Table of contents

IDEA candy - Analyze external stack trace

Table of contents

Groovy features, part 3 - method gotchas

Table of contents

Groovy features, part 2 - java beans

Table of contents

Exploring Groovy, part 1 - common stuff

Table of contents

Apache is hacked

Jet fuel

Kittens

Compound iterators in Scala - present and future

Table of contents

Working with by-name arguments in Scala

Table of contents

Scala method arguments processing - Iterator.++() doesn't work problem

Table of contents

Developers inhabitant is discovered

Kittens

UML class diagrams editor

Shopping

ProjectEuler - problem10

Table of contents

ProjectEuler - problem9

Table of contents

ProjectEuler - problem8

Table of contents

ProjectEuler - problem7

Table of contents

ProjectEuler - problem4

Table of contents

ProjectEuler - problem3

Table of contents

MTGO Zendicar block - Vampires deck

Jni dll and IDE

Spring xsd loading algorithm

ProjectEuler - problem5

Table of contents