Let me start by giving credits to Walter Jia who wrote the article Unit test Struts applications with mock objects and AOP. This was a great article which pushed me in the right direction. I wanted to use Maven instead of Ant, which meant I had to configure a pom.xml. There are a few details which you need to know to migrate to Maven. I wanted to stay close to the original example, so I didn’t upgrade EasyMock and JUnit yet.

Project layout

Below is the project structure based on the standard directory layout described by Maven. The aspect-folder is defined by the aspectj-maven-plugin. You could put the .aj-file inside the src/test/java, but this way you keep the files in their own folder.
The org.acme.StrutsActionPreExecuteListener is a helperfile, but it’s java so I’ve put it in the src/test/java folder.

• StrutsTest2
  • src/main/java
    • com.foo.bar.ActionService
    • com.foo.bar.SimpleAction
  • src/main/webapp
    • WEB-INF
      • struts-config.xml
      • web.xml
  • src/test/aspect
    • org/acme/StrutsActionPreExecuteNotifier.aj
  • src/test/java
    • com.foo.bar.SimpleActionTest
    • org.acme.StrutsActionPreExecuteListener
  • pom.xml

The Pom.xml

I hope you’ll all understand the dependency-section, so I’ll just focus on the build-section.
First of all, the MockStrutsTestcase expects a WEB-INF/web.xml and a WEB-INF/struts-config.xml on the classpath. I want to make use of the files which will be deployed with the war as well. So I’ve defined these two files as testResources. If you want to use a specific test-version, you have to make these files inside src/test/resources/WEB-INF and they’ll be picked by Maven by default.

<testResources>
    <testResource>
        <directory>src/main/webapp</directory>
        <includes>
            <include>WEB-INF/*.xml</include>
        </includes>
    </testResource>
</testResources>

I already mentioned the aspectj-maven-plugin, which we need to include as well. It’s pretty straight-forward. Include the plugin and add an execution-section. Defining the plugin goals (in our case only test-compile) is enough. This goal is bound to the process-test-sources phase of Maven, so there’s no need to specify a phase inside the exection-section.

<plugin>
 <groupId>org.codehaus.mojo</groupId>
 <artifactId>aspectj-maven-plugin</artifactId>
 <version>1.2</version>
 <executions>
  <execution>
   <goals>
    <goal>test-compile</goal>
   </goals>
  </execution>
 </executions>
</plugin>

It looks like we’re done. But if we run the tests, both tests will fail because of a NullPointerException. The service isn’t injected, which means the preActionExecuteOccured method isn’t called.
So here’s the pitfall. It’s not (only) the test class which has to be compiled with AspectJ, especially the Action class needs to be compiled like this as well, but only for testing! So we have to tell Maven to use these files too. This is done by configuring the aspectj-maven-plugin.
Add to the execution-section the following lines:

<configuration>
  <weaveMainSourceFolder>true</weaveMainSourceFolder>
</configuration>

This way the Action is added to the test classes and will be compiled by the aspectj-maven-plugin. Note that this Action is not the one that will be packaged, since Maven uses seperate folders for main classes and test classes.
You might want to finetune this, because now all (re)source files on the main path will be added to the test classpath, so some fileoverwriting might occur.

The complete build-section will look like this:

<build>
  <testResources>
    <testResource>
      <directory>src/main/webapp</directory>
      <includes>
        <include>WEB-INF/*.xml</include>
      </includes>
    </testResource>
  </testResources>
 <plugins>
  <plugin>
   <groupId>org.codehaus.mojo</groupId>
   <artifactId>aspectj-maven-plugin</artifactId>
   <version>1.2</version>
   <executions>
    <execution>
     <goals>
      <goal>test-compile</goal>  <!– use this goal to weave all your test classes –>
     </goals>
     <configuration>
       <weaveMainSourceFolder>true</weaveMainSourceFolder>
     </configuration>
    </execution>
   </executions>
  </plugin>
 </plugins>
</build>

The Strutstest2.zip can be downloaded from Box.net

Dalam artikel terdahulu saya telah memberikan beberapa contoh penggunaan metodologi AOP dengan menggunakan beberapa cara, salah satunya dengan menggunakan spring classic aop. Dengan menggunakan spring classic aop kita harus membuat proxy dengan mendefinisikan secara eksplisit kebutuhan akan kelas kelas untuk membuat proxy tersebut. Nah, dengan Spring AspectJ kita dapat dengan mudah mendefinisikan agar melakukan scanning terhadap kelas-kelas yang dianggap sebagai sebuah aspek dan membuatkan proxy untuk masing-masing kelas tersebut.
Sebuah kelas aspek dapat ditandai dengan sebuah anotasi @Aspect. Sebuah kelas aspek juga dapat ditandai dengan melakukan injeksi secara langsung didalam sebuah container. Untuk mengimplementasikan automatic proxy maka kita dapat mendefinisikan sebuah element xml seperti berikut :

 <aop:aspectj-autoproxy/>

Berdasarkan contoh sebelumnya mari kita langsung saja ke listing berikut :
Kita buat sebuah interface Kalkulator :

public interface Kalkulator {

    public double kali(double x, double y);

    public double bagi(double x, double y);
}

Kemudian lakukan implementasi dari interface tersebut :

public class KalkulatorImpl implements Kalkulator {

    public double bagi(double x, double y) {
        if (y == 0) {
            throw new IllegalArgumentException("Pembagi tidak boleh 0");
        }
        double hasil = x / y;
        return hasil;

    }

    public double kali(double x, double y) {
        double hasil = x * y;
        return hasil;
    }
}

Setelah itu kita buatkan sebuah kelas aspek untuk mengatur log yang terjadi :

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/**
 *
 * @author kris
 */
@Aspect
public class KalkulatorAspect {

    private Log log = LogFactory.getLog(this.getClass());

    @Before("execution(* *.*(..))")
    public void runBefore(JoinPoint joinPoint) {
        log.info("Method " + joinPoint.getSignature().getName() + " () telah dijalankan");
    }

    @AfterReturning(pointcut = "execution(* *.*(..))", returning = "result")
    public void runAfterReturning(JoinPoint joinPoint, Object result) {
        log.info("Method " + joinPoint.getSignature().getName() + " () telah dijalankan dengan hasil : " + result);
    }

    @AfterThrowing(pointcut = "execution(* *.*(..))", throwing = "e")
    public void runAfterThrowing(JoinPoint joinPoint, Throwable e) {
        log.info("Terjadi error " + e + " didalam method " + joinPoint.getSignature().getName());
    }
}

Jika melihat kode diatas maka ada beberapa advice yang digunakan. @Before,@AfterReturning,@AfterThrowing. Seperti dalam artikel yang lalu, advice Before akan dijalankan sebelum target method dieksekusi, advice AfterReturning akan dijalankan setelah target method dieksekusi. Advice AfterThrowing akan dieksekusi jika terjadi kesalahan dalam target method tersebut. Mungkin kita juga menemukan beberapa istilah baru didalam listing diatas, antara lain adalah JoinPoint.
JoinPoint dapat diartikan sebagai sebuah execution point yang tepat didalam sebuah pointcut. Lalu, apa itu poincut ? Poincut dapat diartikan sebagai sebuah penunjuk untuk mengarahkan advice tertentu kedalam execution points agar menujuk pada target kelas dan target method tertentu. Jadi poincut dapat berupa wildcard(*) sebagai penunjuk modifier, return type, paket dan nama kelas tertentu. Seperti halnya wildcard yang lain yang berarti apa saja, hal ini juga berlaku pada poincut yang biasa disebut juga denga reguler expression.
Kemudian kita perlu mendaftarkan kelas-kelas yang terlibat didalam container :

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    <aop:aspectj-autoproxy/>

    <bean id="kalkulator" class="org.kris.aspectj.basic.KalkulatorImpl"/>

    <bean class="org.kris.aspectj.basic.KalkulatorAspect"/>

</beans>

Setelah itu kita dapat membuatkan kelas utamanya sebagai berikut :

public class MainClass {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("org/kris/aspectj/basic/container.xml");
        Kalkulator kalkulator = (Kalkulator) context.getBean("kalkulator");
        kalkulator.kali(2, 2);
        kalkulator.bagi(2, 0);
    }
}

Hasilnya :

….
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@39b8d6f7: defining beans [org.kris.aspectj.basic.KalkulatorAspect#0,kalkulator,org.springframework.aop.config.internalAutoProxyCreator]; root of factory hierarchy
Nov 27, 2009 12:18:58 PM org.kris.aspectj.basic.KalkulatorAspect runBefore
INFO: Method kali () telah dijalankan
Nov 27, 2009 12:18:58 PM org.kris.aspectj.basic.KalkulatorAspect runAfterReturning
INFO: Method kali () telah dijalankan dengan hasil : 4.0
Nov 27, 2009 12:18:58 PM org.kris.aspectj.basic.KalkulatorAspect runBefore
INFO: Method bagi () telah dijalankan
Nov 27, 2009 12:18:58 PM org.kris.aspectj.basic.KalkulatorAspect runAfterThrowing
INFO: Terjadi error java.lang.IllegalArgumentException: Pembagi tidak boleh 0 didalam method bagi
Exception in thread "main" java.lang.IllegalArgumentException: Pembagi tidak boleh 0
        at org.kris.aspectj.basic.KalkulatorImpl.bagi(KalkulatorImpl.java:18)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
….

Dari hasil diatas kita dapat melihat urutan advice yang akan dijalankan dan result yang dihasilkan. Pada artikel selanjutnya saya akan mengupas lebih jauh penggunaan aspectj didalam spring. Ditunggu ya……. 

Cantal är en av de äldsta franska ostarna med en historia som sträcker sig 2000 år tillbaka. Dagens Cantal tillverkas av både rå eller pastöriserad komjölk och fick sin AOC 1956. Sedans dess har AOCn ändrats ett antal gånger, senast 2007, och numera även AOP. Detta innebär att det idag finns lite olika namn på osten beroende på lagringstid.

• Cantal jeune (ung), lagrad 1-2 månader
• Cantal entre-deux (mellan de två), lagrad2-6 månader
• Cantal vieux (gammal), lagrad mer än 6 månader

Dessutom kan den kallas Fourme de Cantal. Osten som hör hemma i familjen pressade ostar och korna som ger mjölken vandrar omkring i Centralmasssivet på mellan 700 och 1000 meters höjd. Centralmassivet ligger som kanske hörs på namnet i mellersta och södra Frankrike. Cantal tillverkas i form av cylindrar med en diameter på 36-42 cm och höjden 25-40 cm, vikten kan variera mellan 35-45 kg. Osten har en lite salt smak och som ung är den väldigt mild för att i sinmest lagrade variant ibland vara rejält stark och stickig i smaken. Själv föredrar jag mellanvarianten som är den som syns på bilden.

Det kan vara fatalt att glömma sin Cantal är temat på en serie reklamfilmer som sänds på fransk tv. «Chantal t’as pas oublié le Cantal?» är titeln på filmerna och det är alltid Chantal som glömt att ta med sig Cantal. Nedanstående film finns i två versioner, förutom den jag lagt in även en med ett snällare avslut. Denna kanske är lite för brutal.

Интро

В последнее время решил немного освежить свои знания в ASP.NET, в связи с чем углубился в процессы генерации кода контролов по разметке (*.ascx, *.aspx) и обнаружил что можно делать очень интересные решения, о которых  о хочу поведать. Итак сегодня мы узнаем, как подружить наш Dependency Injection контейнер с генерируемым контролами кодом.

Поехали

В качестве DI-контейнера будет выступать Microsoft Unity, но это не принципиально, всё что будет касаться DI не зависит от используемого контейнера.

Проблема состоит в следующем – есть некоторый ASP.NET Control, в который мы хотим внедрит зависимости, а так же воспользоваться услугами Service Locator’а для управления интересующими нас зависимостями.

В Microsoft Unity есть некоторые средства для того, чтобы сделать это не прилагая особенных усилий: мы можем произвести инъекцию в свойство элемента управления, нас интересующее примерно следующим образом:

1. Отметить атрибутом Dependency необходимое свойство
   public class MyControl : UserControl
   {
           [Dependency]
           public MyPresenter Presenter
           {
               get { return _presenter; }
               set
               {
                   _presenter = value;
                   _presenter.View = this;
               }
           }
   }

2. Проинициализировать элемент управления можно следующим образом

   protected override void OnInit(EventArgs e)
   {
       base.OnInit(e);
       _сontainer.BuildUp(GetType(), this);
   } 

3. Позаботиться о местоположении контейнера в вашем приложении, я предлагаю использовать для этого HttpApplication, унаследовавшись от которого и произведя небольшие модификации файла global.asax мы получаем необходимое нам хранилище для контейнера, обращаться с ним необходимо примерно следующим образом

   ((Sapphire.Application)HttpContext.Current.ApplicationInstance).Container

Решение вполне пригодное, однако пуристические воззрения не дают оставить решение на данной стадии, и думаю, что просто необходимо заменить инъекцию свойства на инъекцию в конструктор, тем более подобный подход – это далеко не то, что мы можем выжать из Unity.

Т.е. наш интерес состоит в том, чтобы класс MyUserControl выглядел примерно так (думаю сборщику страницы это не совсем понравится)

Предлагаю этим и заняться. Начнём с того, что у элементов управления, описанных в разметке страницы, при генерации страницы указываются их конструкторы без параметров, интересно, как можно управлять данным процессом, первоначально, покопавшись в web.config я предполагал сделать это через:

Однако реализация своего PageBuildProvider’а – довольно серьезное занятие, думаю отложить это для серьезной на то необходимости. Однако благодаря BuildProvider’ам можно генерить к примеру слой доступа к данным, для этого надо:

Написать и зарегестрировать обработчик для какого-нибудь своего расширения, к примеру *.dal и сделать что-нибудь наподобее http://www.codeproject.com/KB/aspnet/DALComp.aspx

кстати подобная логика реализована в SubSonic http://dotnetslackers.com/articles/aspnet/IntroductionToSubSonic.aspx

так же интересная реализация наследования страницы от generic типов http://stackoverflow.com/questions/1480373/generic-inhertied-viewpage-and-new-property

ещё можно, к примеру генерировать исключения, объекты передачи данных и многое другое, ограничением является лишь ваша фантазия.

Вообщем, данный вариант нам не подходит, необходимо сделать что-нибудь проще, и есть отличное решение, с помощью атрибута ControlBuilder мы можем указать свою логику сборки элемента управления из разметки, это будет выглядеть примерно так

Теперь разберемся с реализацией  MyControlBuilder, этот тип должен наследовать от ControlBuilder и с помощью перегрузки ProcessGeneratedCode мы с вами сможем указать сборщику на необходимость использования нашего кода вместо вызова конструктора без атрибутов элемента управления:

самое интересно скрывает метод ReplaceConstructorWithContainerResolveMethod

следуя по коду можно обратить внимание, что он заменяет вызов конструктора на вызов генерик-метода Build, в котором мы и обратимся к нашему контейнеру с просьбой вызвать наш элемент управления и проинициализировать его конструктор необходимыми зависимостями.

Однако это ещё не решении задания, т.к. есть метод динамической загрузки элемента управления Page.LoadControl(), для него придётся написать свой вариант

Вот мы и справились с поставленной задачей, однако это ещё не всё. А почему теперь не воспользоваться всеми преимуществами Unity, и не внедрить в наш элемент управления AOP времени исполнения с помощью Unity Interception.

К примеру мы можем сделать следующее

Это будет означать, что обработка исключений должна добавляться на лету, к тому ж предоставляя нам возможность её изменения во время исполнения, для начала пусть её реализация будет примерно следующая

Ну и конечно же надо сконфигурировать контейнер для создания наших прокси-обработчиков

Ресурсы

Sapphire.Application – для чего всё это реализовывалось http://github.com/butaji/Sapphire/tree/master/trunk/Sapphire.Application/

Дэвид предлагает реализации связывания с данными следующего поколения “Databinding 3.0” на основе аналогичного подхода http://weblogs.asp.net/davidfowler/archive/2009/11/13/databinding-3-0.aspx

Reality

Rather than ruminate on how long it’s been since I last posted on this forum (17 days – I’ve been spending my “writing block” on translation projects, my dissertation and a filmography for a book), I will elaborate on a few of the major events that have marked the last two weeks.

Our film AOP, a mockumentary about a secret West German fetish, debuted at the HFF “Konrad Wolf” as part of the end of orientation festivities on Friday October 23rd.  It went over lukewarm compared with the other “Knaller” made by the other nine groups (at least 3 of which took place in a bathroom), but director Maurice M. Mohn swore to me that the film “wasn’t unsuccessful” at the party afterwards.  Speaking of THAT party:  it was held after 11:00 p.m. at a sketchy, illegal club in Kreuzkölln with no fire exits, no windows, a sketchy fridge full of bottled beer and nothing but techno beats (the latter being a plus against the other factors).  I sort of plowed my way through the packed bathroom line to reach the exit around 2:30 after quaffing a few cheap beers and yelling my way through several conversations in the smoky darkness.  An experience, to be sure.

I went to a wonderful Fulbright brunch on Sunday October 25^th held by the generous Luisa Greenfield and Ming Tsao in Kreuzberg, where I met Jacob Comenetz, a former Fulbrighter now working at the Bundespresseagentur (more on him to come) and got a pile of great book recommendations from Ming about writing about the electronic music aesthetic (you want that list? Send a comment my way!).  Later that day, I picked up Kat at the Berlin Tegel airport, who successfully got her very heavy baggage out of the terminal without a cart (or my help, since that’s how European airports work) and we ate out at Tuk-Tuk, the Indonesian restaurant down the street from us.

Having Kat around has been great for many reasons.  Here are a few:

* Cessation of married-man-long-distance loneliness;

* More satisfying sleep;

* The apartment is now warmer;

* Increased intake of generally nutritious food that tastes good;

* New impulse to plan social events and outings, and I can show her all the old stuff I’ve gotten to know;

* Celebrating birthdays and holidays is much more meaningful again!

In the first week (Oct. 26 – Nov. 1st), I purposefully overscheduled us with many social events, including coffee with Kira and Beverly and dinner with the same, carving pumpkins with Katie Weeks and Hilary Bown, Luisa’s film screening on Friday night, and a Fulbright alumni Halloween party at Joe’s Bar in Prenzlauer Berg on Saturday night with Jacob.  I did so to make Kat feel at home and connected here, which also conversely made me feel more at home and connected here as well.  Speaking of Luisa’s screening, we had a great turn-out for the two shorter, more experimental films (Light and Bridegroom… see below) but, since we started over an hour late, over half the audience missed the wonderful mess that was John Ford’s Seven Women (1966).  We hope that everybody returns for our continuing Ford/Straub pairings, as well as other assorted film gems we manage to procure.  As for the Halloween party, Kat and I went as a vampire-zombie duo who hated each other through our expressions on our T-shirts:  “Vampires Bite” and “Zombies Need Brains.”  Ha ha.

This last week has presented us with opportunities to walk around and shop (such as in Kreuzberg’s famous Bergmannstrasse), watch movies together (many reviewed below) and get our visas (by waking up at 3 a.m. and surmounting the evil LABO).  All in all a good time, and I anticipate more to come.

Professionally speaking, I’ve had some ups and downs the last two weeks.  Ups:  I spent four hours with Herr Dieter Kosslick, director of the Berlinale, and two hours with Dr. Gottfried Langenstein, director of ARTE; I’ve found hundreds of newspaper articles with revealing insights on the reception of the Indianerfilme in East Germany; I’ve met up with Reinhild Steingröver of the University of Rochester and established contact with several other scholars working on parallel topics to my dissertation.  Downs: I lost my first month’s worth of book/film notes due to a faulty data back-up attempt, so I’ve got another 10 hours of work to do in reconstructing it.  This is the way it goes.

And one final note:  if you’re ever on Akazienstrasse in Schöneberg, DO NOT eat at the South Indian restaurant called Chennai Dosai, not only because their food is not particularly good, but because they played the opening track from the Hrithik Roshan sci-fi Bollywood film Koi Mil Gya (2003) on a loop THE ENTIRE TIME WE SAT THERE.  It was a unique form of tourist torture, though I’m sure they weren’t expecting a customer who knew the film.

Fantasy

Posse (dir. Mario van Peebles, USA 1993)

Woody Strode, Big Daddy Kane, and many other prominent African-Americans star in this somewhat violent, misogynist and cliché Western.  Its primary contradiction lies in its seeming original mission – to re-insert African-Americans into a Western film tradition absolutely dominated by actors coded as “white” -  and its aesthetic outcome – a cheap Leone treasure/revenge plot with a lot of melodramatic cheese and macho strutting from Van Peebles.  The fact that I couldn’t really read the blocky explanatory text at the end didn’t really detract from the palpably saccharine coating that Van Peebles put on this piece of macho-masculine self-glorification.

The Treasure of Silver Lake (dir. Harald Reinl, FRG/France/Yugoslavia 1963)

The film that started the whole Euro-Western trend, and a completely necessary entry in the cinema books next to adventure films such as Errol Flynn’s Captain Blood (1935)or Lucas’ and Spielberg’s Raiders of the Lost Ark (1981).  The superhuman duo of Winnetou (Pierre Brice) and Old Shatterhand (Lex Barker) stumble upon an injustice committed (the murder of Götz George’s German immigrant father) and a treasure to discover.  Let’s just say that, on a superficial level, the film absolutely delivers:  colorful landscapes, bold action sequences, and plot twists that still convince the 8 year-old inside of you.  You only think about the crazy exoticism of the whole charade afterwards…

The Sons of Great Bear (dir. Josef Mach, GDR 1966)

The East German response to Reinl and Wendlandt’s Winnetou films, The Sons of Great Bear is the most “historically accurate” of all the DEFA Indianerfilme and also one of the most visually compelling.  That being said, Mach had little idea how to direct an action sequence, so the ending fight scene is confusing and frustrating to say the least, not to mention more-or-less tacked on to Liselotte Welskopf-Henrich’s original source material.  The press reviews made sure to note how much actor Gojko Mitic’s physique looked like the “real-life” Shoshone, though their basis on which to judge that comes from other Westerns’ portrayal of Native Americans.  Hmmm….

Little Big Man (dir. Arthur Penn, USA 1970)

Thomas Berger’s picaresque about the only white survivor of Little Bighorn, a man brought up by the Cheyenne (a.k.a. the human beings) named Jack, is expertly executed by Penn, if awkwardly assembled as a whole.  General Custer’s portrayal in the film is nothing short of brilliant – an arrogant prick more than a proper villain – and the Cheyenne are given a lot of positive screen-time.  Of course, Dustin Hoffman’s Jack dominates the majority of the film, with mixed results.

Battleship Potemkin (dir. Sergei Eisenstein, Russia 1925)

Restored 35mm print containing all the original scenes?  Check.
Live accompaniment by an adept pianist?  Check.
Kat’s first time seeing a leftist modernist classic?  Check.
I really can’t say anything more, other than that the Kino Arsenal has a special place in my heart.

Trick ‘r Treat (dir. Michael Dougherty, USA 2008)

A kind of Four Rooms treatment of Halloween, Trick ‘r Treat is a very smooth movie with regard to horror clichés, playing on one’s expectations, and the usual twists and turns one expects of even the slasher genre nowadays.  One should watch this with one’s tongue firmly in cheek, even through all the horrifying bits.  I say no more.

The Omen (dir. Richard Donner, UK/USA 1976)

Um… Gregory Peck’s character is kind of dumb?  This is at least what the film suggests, after one is led through a constant barrage of corroborating evidence that demonstrates his son is the antichrist, and he still doesn’t seem to get it.  Oh well:  there are many other films with evil children that work with the formula that The Omen put forth, so I suppose it’s influential.

League of Extraordinary Gentlemen (dir. Stephen Norrington, USA 2003)

This was the second time I’ve seen the film, and the second time I’ve seen it in Berlin (the last time was with Mary Brandel in 2003 – and I hated it then too.)  Alan Moore’s excellent graphic novel was to be transformed into a grand piece of pulp, and instead turned into a nightmarish gobbledy-gook of lame special FX (including the atrocious Venice sequence), too many characters running around (including “Tom Sawyer,” their worst revision), and sequel-baiting (the *ahem* “ending”).  Stuart Townsend is about the only redeeming feature of this feature, and that’s because he’s so damn charming in any case.

V for Vendetta (dir. James McTeigue, UK/Germany 2006)

Another slightly second-rate “good” film from the Wachowski Brothers, V for Vendetta continuously bills itself as a smart action thriller which raises bits of moral ambiguity for the postmodern cinema-goer, but is ultimately far too utopian about the power of the masses to stomach.  Alan Moore wasn’t nearly as idealistic as this, and far more critical of the respective places within society that Evie, V and the masses inhabit.  You can tell through the exquisite detail of the sets that the Babelsberg people worked on this one, though.

Genau Gleich (dir. Burkhart Wunderlich, Germany 2009)

A film that I’m currently subtitling for Burkhart about an incestuous relationship between German-Polish twins and an old woman on a bench waiting for Elvis.  An absolutely brilliant concluding shot is likely to give this one high marks at the Berlinale if, indeed, we manage to get the film into competition.

Light (dir. Marie Menken, USA 1964)

Dizzying Christmas lights, spinning motion, elliptical editing.  The lost American avant-garde.  Shall we see it again?

The Bridegroom, the Comedienne and the Pimp (dir. Jean-Marie Straub, Daniele Huillet, FRG 1968)

I must’ve seen this film something like eight or nine times since I’ve come to UMass.  Nevertheless, the mixture of prostitutes against an industrial backdrop, Ferdinand Bruckner’s “The Pains of Youth” by Fassbinder’s antitheater group, and the intense chase/marriage sequence at the end never fail to incite thoughts of alternatives to mainstream cinema and new spatial configurations of narrative.

Seven Women (dir. John Ford, USA 1966)

Ford’s last film is an outright laugh riot starring Anne Bancroft as a self-confident doctor who winds up in a doomed community of American missionaries in Mongolia.  Oh wait – this wasn’t supposed to be funny?  Then perhaps there’s too much Sirkian irony in this overstuffed, full-color studio epic, which is probably why the film was buried after its creation:  Ford’s film is trapped between gender and a hard place.   Oh yeah, and there’s actually eight women, but one of them happens to be Chinese…

Coraline (dir. Henry Selick, USA 2009)

Coraline is a well-executed animated feature in glorious 3D that was screened at the HFF as part of our overall 3D research project.  Many of the fantastic landscapes, both interiors and exteriors, are enhanced by the 3D effects, but these effects don’t overwhelm the adaptation from the original text.  What does overwhelm the adaptation is the inclusion of a male character who has to save Coraline’s butt in the end, classifying it as yet another film with a strong female character who needs a man to both tame and save her.  Why can’t Hollywood ever be done with its male heroes?

G-Force (dir. Hoyt Yeatman, USA 2009)

Most 3D films rely on re-vamped spatial relations that make tighter spaces seem even tighter and wide open spaces seem glorious.  So what better means of exploring tight spaces and big vistas than making a supremely small cast, through whose eyes we must view the world?  Such is the visual premise of G-Force, which has guinea pig commandos saving the world from a silly plot in a classic Jerry Bruckheimer fashion.  Nevertheless, the effects are convincing and most of the side-plots are not particularly annoying.  I would say:  Mr. Yeatman’s background in visual FX for advertising and trailers paid off in a big way for the film, though its effects scenes are so pronounced as to make all of the dialog sequences seem drawn-out and dull.  Definitely a movie that attempts to satiate a hyper-active age group.  Critics who don’t fully “get” 3D films and who are thoroughly in Pixar’s camp are liable to hate it,  but I can root for it from the sidelines.

Spring의 IoC적인 특징은 AOP를 구현하는 핵심적인 원리가 되어 왔습니다.
AOP란 무엇입니까? 사실, AOP는 그닥 어려운 개념은 아닙니다. AOP는 그동안의 전통적인 프로그래밍에서 개발자들이 느끼고 있던 불편함을 개선한 새로운 프로그래밍 패러다임이라고 보여집니다.

AOP가 필요한 이유를 설명하기 전에 일반적인 형태의 프로그램을 작성하는 방식을 살펴보겠습니다.

우리가 은행업무를 위한 프로그램을 작성한다고 가정해 보겠습니다. 은행업무에는 기본적인 입/출금업무가 있을 것이고 계좌이체업무도 있을 것입니다. 이러한 업무들이 바로 은행업무에 있어서 본질적인 비즈니스 기능이라고 할 수 있을 것입니다. 하지만, 이런 업무들만 있는 것은 아니지요. 누군가 돈을 찾아갔다면 그 정보도 남겨야 할 것이고 ID도용이 발생했다면 원인을 밝혀내야 하며, 온라인 뱅킹이 발생했다면 정상적으로 거래은행에 입금이 되었는지도 체크해야 합니다.

이와같이 은행업무를 위한 프로그램에는 핵심 비즈니스 기능뿐 아니라 부가적이라고 말할 수도 있는 보안, 인증, 로그 , 중복체크등과 같은 기능들도 통합되어 있어야만 비로소 완전하게 구현되었다고 말할 수 있습니다. 어쩌면은 은행 본연의 업무를 위한 코드들보다 부가적인 측면을 다루는 코드가 더 많아질수도 있겠습니다.

하지만 이 부가적인 기능을 다루는 코드는 비즈니스 로직과는 상관관계가 없는 경우가 많아서 여러업무에 중복적으로 사용되는 것이 일반적이지요. 보통 개발이 진행되면 진행될수록 사실 핵심 비즈니스로직보다는 이러한 부가적인 처리에 사용되는 코드가 문제가 되기도 합니다. 시스템 전체에 걸쳐서 사용되고 있기 때문에 수정도 힘들고 관리도 힘들게 됩니다.

AOP세계에서는 상기 설명했던 기능중에서 비즈니스로직을 구현한 기능들을 Primary(Core) concern이라고 부릅니다. 보안, 인증, 로그등과 같은 부가적인 기능으로서 시스템 전반에 산재되어 사용되는 기능들은 Cross-cutting concern이라고 부르고 있습니다. 바로 AOP의 핵심이 여기에 있습니다. 바로 AOP는 우리에게 있어서 골치거리인 Cross-cutting concern을 어떻게 다룰 것인가에 대한 새로운 패러다임을 제고하고 있습니다.

사실 AOP가 등장하기 전에는 Primary concern과 Cross-cutting concern이 같이 하나의 프로그램에 구현되어져 왔습니다. 당연히 비즈니스 로직과 상관없는 코드들이 여기저기 산재해 있게 되었기에 가독성과 유지보수성에 악영향이 있을 수 밖에 없었을 것입니다. 생산성 저하와 비용증가는 당연한 결과였겠지요.

하지만, AOP세계에서는 다릅니다. AOP는 Primary concern과 Cross-cutting concern을 별도의 코드로 구현합니다. 최종적인 프로그램은 이 둘을 조합하여 완성하게 되는 것이죠. 이것은 하나의 프로그램에 각각의 코드들이 혼재해 있는 것과는 명확히 다른 것입니다. 사실 이렇게 되기를 많은 개발자들이 마음속으로 바래마지 않았을 것이지만 그 방법을 몰랐었습니다. AOP는 모든 개발자들이 바랬던 이상을 구현해 놓은 것에 불과(?)한것이지요.

이제, AOP세계에서 새로운 용어들이 등장하게 되었습니다. 바로 Advice와 Code , Point-Cut 그리고 Weaving입니다.

Code는 Primary(Core) concern을 구현해 놓은 코드를 이야기합니다. Advice는 Cross-cutting Concern을 구현한 코드를 지칭하고 있습니다. 그럼, Point-cut은 무엇일까요? 바로 Advice와 Code를 연결해주는 설정 정보를 말합니다. 다시 말하면 Point-cut은 Code의 어느 위치에 Advice를 위치할 것인가에 대한 것입니다. 마지막으로 Weaving은 이 둘(Code와 Advice)를 조합하여 완성된 어플리케이션을 만드는 과정을 이야기합니다.

정리해 볼까요?

• Code : Primary(core) concern을 구현한 코드
• Advice:  Cross-cutting concern을 구현한 코드
• Jointpoint:Code와 Advice를 연결해주는 설정 정보, Advice가 적용 가능한 지점(메소드 호출, 필드값 변경)
• Point-cut: Jointpoint의 부분집합으로서 실제 Advice가 적용되는 Jointpint
• Weaving : Code, Advice, Point-cut등을 조합하여서 어플리케이션을 만들어 가는 과정

이 용어들을 이해하는 것으로도 벌써 AOP세계의 절반은 여행하셨다고 볼 수 있습니다. 사실 이 용어를 이해한다면 AOP는 그닥 어려운 것이 아닐 수 있습니다. 따라서 위의 용어들은 반드시 숙지하시길 권면드립니다.

그럼 왜 AOP(Aspect Oriented Programming)이라고 하는 걸까요?

AOP의 Aspect는 Advice와 Point-cut을 함께 지칭하는 단어입니다. 따라서 AOP는 Advice와 Point-cut에 대한 이야기를 하고 싶었던 것이네요.

Spring의 AOP패키지는 이러한 AOP개념을 멋드러지게 구현한 것으로서 그 배경에는 IoC 또는 DI가 자리하고 있습니다.

Spring AOP도 여러 AOP 프레임워크중의 하나입니다. 따라서 나름의 특징이 있습니다. 간단히 소개를 해보자면 다음과 같습니다.

• 자체적인 프록시 기반의 AOP 지원

필드값 변경과 같은 Joinpoint는 사용할 수 없고 메서드 호출 Joinpoint만 지원합니다. Spring AOP는 완전한 AOP를 지원하는 것이 목적이 아니라 엔터프라이즈 어플리케이션을 구현하는데 필요한 정도의 기능 제공을 목적으로 하고 있습니다.

•  Spring AOP는 자바 기반

AspectJ는 별도의 문법을 알아야 하지만 Spring AOP는 자바를 기반으로 하고 있기때문에 다른 언어를 익힐 필요가 없습니다.

Spring AOP는 내부적으로 프록시를 이용하여 AOP가 구현되기 때문에 메서드 호출에 대해서만 AOP를 적용할 수 있다는 점이 아쉬운 점이라고 할 만하지만, 크게 문제될 것은 없다는 개인적인 생각입니다.

• Why Spring?

그 많은 Java진영의 프레임워크중에서도 단연 가장 화두가 되어 있는것은 Spring입니다. 우리가 Spring을 주목하는 이유는 여러가지가 있을 수 있습니다만, 제가 생각하는 것을 정리해 보자면 다음과 같습니다.

•  Spring은 다른 프레임워크가 하지 못하는 중요한 부분을 제시하고 있다

 Spring은 특히 비지니스 오브젝트를 관리하는 방법을 제시하는 면에 포커스를 맞추고 있습니다.

•  Spring은 테스트가 쉬운 코드를 작성하도록 도움주는 방식으로 디자인되어 있다

 특히, TDD방식의 프로젝트에 이상적인 프레임워크입니다.

• Spring은 아주 중요한 통합기술이다

Spring의 중요한 역할에 대해서는 Big벤더와 Small벤더에 모두 인정받고 있습니다.  Spring의 목적은 기존에 존재하는 기술들을 보다 쉽게 사용할 수 있고 , 통합할 수 있도록 기반을 제공하는 것입니다. 결코 필요하다고 해서 새로 무언가를 개발해서 제공하지 않습니다. 필요한 것들은 대부분 OpenSource로 제공되기 때문에 그것을 재활용할 수 있도록 여지만 만들어 놓는 것이지요. 예를 들면 log4j라든가 Hibernate등이 있을 수 있겠네요.

• 아키텍쳐관점에서의 Spring의 이점들

Spring을 사용하게 되면 얻게되는 혜택들을 좀 살펴보겠습니다.  사실 현학적인 말들과 멋드러진 기술이야기보다도 현실적으로 내가 얻을 수 있는 혜택이 중요하겠지요.

• Spring은 미들티어 오브젝트들을 효과적으로 조직할 수 있다

Spring의 환경설정 관리 서비스들은 어떤 아키텍쳐 레이어에서도 사용될 수 있습니다. 

• Spring은 다양한 커스텀 Properties 파일들의 필요성을 제거해준다

머리속에 숨어있는 보이지는 않지만 가려운 석캐(아실려나??)처럼 프로젝트를 어렵게 만드는 존재인 system properties 또는 Magic properties keys들에게서 해방되게끔 해줍니다. 어떻게? 바로 Inversion of Control(IoC)과 Dependency Injection(DI)를 통해서 말이죠.

• Spring은 가능한한 어플리케이션들이 Spring에 의존적이지 않게 프로그램이 가능하도록 디자인되어 있다

Spring에서 사용되는 대부분의 비지니스 오브젝트들은 Spring에 의존관계가 존재하지 않습니다.

• Spring을 이용해서 제작된 어플리케이션들은 쉽게 테스트가 가능하다

Spring TestContext Framework 와 JUnit3.8등이 지원해줍니다.

• Spring은 데이타 접근에 있어서 일관성이 있는 프레임워크를 제공한다

JDBC를 사용하던 OR맵핑(TopLink,Hibernate)등을 사용하던지 말이지요. 

• Spring은 가장 가벼운 구조로서 문제들을 해결할 수 있도록 도와준다

Spring은 EJB의 대안으로서 제시될수 있습니다. 예를 들면, Spring은 EJB컨테이너를 사용하지 않고 명확한 트랜잭션 관리를 위해서 AOP를 사용할 수 있습니다.

사실, 가장 핵심적인 것으로서 Spring은 Plain Old Java Objects(POJOs)를 이용하여서 어플리케이션을 개발하도록 고안된 기술이라는 점입니다. 이것이 제가 Spring에 끌리게 된 결정적인 이유입니다. 개발자는 비지니스로직이 포함된 POJO콤포넌트만을 집중해서 개발한다면 나머지는 프레임워크에서 알아서 처리해주겠다는 것입니다. Spring은 개발자가 가장 간단한 방식으로 문제에 집중해서 개발이 가능하도록 해줍니다.
정말일까요?? ㅎㅎ

* 이 내용은 Rod Johnson이 기고한 글 Introduction to the Spring Framework 2.5 란 글에서 참고하였습니다.

Hello All.
Hope that you all are doing best in all aspects of your life…

This is a second part of tutorial on aspect oriented programming. In last part, we discussed little about object oriented approach to design and develop computer based system and some issues with this approach. We talked about issues those are not concerned with a developer of specific module but he/she has to care those things, we saw a small chunk of code and realized that same lines of code are repeating in different classes/methods time and again and a developer has to write them even when those lines are not concerned with core logic of that method or developer’s expertise.

In this part i will present aspect oriented approach to cope with such issues and to design/develop your application’s architecture with much better way. Again, may be my writing style, sentences structure, grammar, spells are not up to the mark, but it doesn’t matter, neither i’m going to tech you English nor it is an English literature class, so don’t worry , i will try to focus on contents and concept so kindly accept my apology in advance.

Concern
orite, lets start … we know that every class, method or package in our software system has some responsibility in over all flow of application. Like some packages/classes for session management, some classes to obtain and mange database connections, some classes act like delegates, some work at middle layer to control transaction management etc … there are many other classes too that we develop as per user interface or to perform some other functionality. Anyone can guess the purpose of a class or method by just looking at its name (if good programming practices are in practice). Mean every class/method has something to concern with it, and in any application there are many possible concerns like managing role/permissions, fetching data as per specific criteria at specific screen, to control navigation, to handle session management and many others. So concern mean anything important that has to be done in software system. Any logic, any piece of code, or even a complete module.

Cross Cutting Concerns
While analyzing the user requirements and business scenarios in client’s world, you can analyze different concerns that you have to handle … and while you list down them you will realize that there are few things that are overlapping in each module or in different business scenario, or more precisely they span over different module or concerns. They present in all modules or help other modules to perform their concerning task properly. Such overlapping things or concerns are called cross-utting concerns. Means they cross cut different modules or concerns and present across the application in same form. In other words, These cross-cutting concers are pieces of logic that have to be applied at many places but actually don’t have anything to do with the core business logic of that particular class or method.

Issues with Cross Cutting Concerns
At this point I’m assuming that you have understand the term of concern and cross-cutting concerns. Again in short, concern is any functionality/logic/module/code that you have to implement to achieve some business goal; cross-cutting concerns are those concerns that are spread over the application and replicates in different concerns, got that!!! Good.

The biggest issues with cross cutting concerns are that they replicates in all applications, exists in different part of your code in more or less same form. Let consider the previous example again to clarify this point.

method Fetch_Employee_Data{

log start of method;
open data base session;
create query to fetch data;
log query and its parameters;
call to database to fetch data;
close database session;
log returned data from database;
log end of method;
return results;

}

Consider the above piece of code (in natural language). Last time we analyze that the bold lines can be found in every method of your application that fetch data from database, and wants to log different activities/interaction with database server. In any application, the logging and mechanism of interacting with database are major activities that have to perform again and again. In others words, logging and database interaction are two major concerns. Plus these concerns are also cross-cutting concerns because they are spreading across the application. In every method you can find them. You have no other option other than to write these lines of code in every method. What maximum you can do is to make separate classes and write all code there. Whenever you need logging and database interaction, just call methods of those classes. But again the problem is that you have to write call to those classes in every method; even a single line. This single line of code is much costly when you have to write them in every method of your class. One thing more, what if you need to have little change in that line? Again you have to edit/modify all those methods?

This thing become worst when a person that hasn’t concerned with such issue but he/she has to care about them. A person who has primary responsibility to write an optimal query to fetch data from database against a certain criteria but he/she is wasting his/her time in managing logging and database connectively issues. Is that fair? Absolutely not ..

The ideal solution for such issues is to identify and separate those piece of code/logic that span over the whole system, means their cross-cutting behavior or attribute should eliminate. Is there any way in OOP to do that? There isn’t unfortunately.

Aspect Oriented Programming Approach

No doubt Object-oriented programming (OOP) is a mainstream programming paradigm now a days. It provides software re-usability by providing design and language constructs for modularity, encapsulation, inheritance, and polymorphism. Though OOP has credit in implementing large scale projects and system, still it has some problems. It is practically proved that developers faces some problems in maintaining their code while working on large scale projects. An attempt to do a minor change in the program design may require several updates to a large number of unrelated modules. In other words, they have to change/update those modules that has no concern with core logic of required changes; more technically, they have to update many cross-cutting concerns at many places of code while doing a minor change in existing system. Hence OOP don’t have any concrete solution for managing and handling cross-cutting concerns in a software system. In object-oriented programming the natural unit of modularity is the class, and a cross-cutting concern is a concern that spans multiple classes (logging, context-sensitive error handling, performance optimization, and design patterns)

Aspect oriented approach provides solutions for such issues. It provides a way to design a software system architecture while considering the issue of cross-cutting concerns. It cleanly separate the cross-cutting concerns among different modules and treat them as autonomous construct hence remove their cross-cutting behavior.

To understand the core of AOP approach, again consider the previous example. If I remove the bold lines then remaining method will look like

method Fetch_Employee_Data{

create query to fetch data;
call to database to fetch data;
return results;

}

Here the developer hasn’t any worry about how connection with database is handling, how the logging happen. He just has to write those lines of code that belongs to core logic of that method. In other words, he is just concerned with core logic and doesn’t need to worry about other things. Doesn’t look good han??? AOP says that the class or method should perform only its concerned task and shouldn’t worry about other things. It provide a way to modularize different aspects of a system in least cohesive fashion.

How this happen? In AOP world, you pick all cross-cutting concern and develop them as separate entity, and when you need them in your code, just inject their functionality at run time. Looks strange?? i know at first glass it does. ok i try to clear by an example. Again consider the same example. In our Fetch_Employee_Data method we introduced logging to log all interaction with database server. We noticed that we have to write same line of code in every method. Now AOP says that pick these line of code, put them in separate entity, and wherever you need that logging functionality, just tell the compiler to inject logging in your method at your mentioned location; sounds good han …. it is indeed …. see you don’t need to write same code time and again in each method but only once in separate entity and compiler is injecting it in every method you mention. I will tell you latter how to write separate entity and how to tell compiler to inject at run time but right now just try to grasp core idea behind aspect oriented approach and how it is different from object oriented.

To me AOP is some kind of meta-programming. It complements object-oriented programming by facilitating another type of modularity that pulls together the widespread implementation of a cross-cutting concern into a single unit. These units are termed aspects, hence the name aspect-oriented programming. By compartmentalizing aspect code, cross-cutting concerns become easy to deal with. Aspects of a system can be changed, inserted or removed at compile time, and even reused. One thing to be noted is, that AOP does not replace OOP but adds certain decomposition features. I say it a nice add-on to OOP.

In next part i will tell you about major term used in aspect oriented programming. You learn how to pick cross-cutting concerns from system and write them as aspect; and how to tell compiler to inject them at run time. Till now i was talking in much generic fashion just to clear the concept, in next part i will discuss things pragmatically so be ready….

Kärt barn har många namn och det gäller definitivt den goda osten Mont d’Or som har anor från 1800-talet.

Le Mont d’Or är namnet på en bergstopp i Jurabergen men även namnet på en fransk ost med AOC- och AOP-status. Denna franska ost kan även säljas under namnet Vacherin du Haut-Doubs medan man på andra sidan sluttningen av Mont d’Or tillverkar en i princip identisk ost vid namn Vacherin Mont d’Or med schweizisk AOC-status.

Osten har anor sedan 1800-talet och lär ha tillkommit sedan tillgången på getmjölk blivit för dålig i området. En getost kallad Chevrotin blev då ersatt av komjöksosten Vacherin. Namnen är logiska då get heter chevre och ko heter vache på franska. Tillverkningen skedde i godan ro på båda sidor gränsen men på 1970-talet lyckades schweizarna skaffa sig ensamrätten till namnet Vacherin Mont d’Or. Av någon anledningen så valde då fransmännen att ha två namn på sin ost, Mont d’Or respektive Vacherin du Haut-Doubs.

Alla tre säljs i träaskar tillverkade av gran och lagringstiden är ungefär densamma, ca tre veckor. De franska ostarna är till skillnad från sin schweiziska kusin tillverkade av opastöriserad mjölk. 1987 Schweizarna började pastörisera sin ost efter att det upptäckts att ett parti av osten spred salmonella. Efter denna åtgärd så öppnades även möjligheten för dem att exportera osten till USA dit det annars är omöjligt med tanke den korta lagringstiden. Volymmässigt så är Frankrike överlägset med en årsproduktion på ca 4 000 ton mot Schweiz 600 ton.

Sedan råkar det finnas en schweizisk ost vid namn Vacherin Fribourgeois, men den har inga större likheter med Mont d’Or-ostarna. Den är dock ett vanligt val när det vankas ostfondue.

Den franska osten Mont d’Or hör hemma i departementet Doubs i östra Frankrike och gränstrakterna mot Schweiz. Osten är gjord av opastöriserad komjölk och kan kategoriseras som en tvättad ost. Den har dock inte som många andra tvättade ostar  ett rödaktigt yttre utan ett mer gulbrunt skal.  Denna ost får bara tillverkas under perioden 15 augusti till den 15 mars och försäljning får ske mellan den 10 september och den 10 maj. Efter minimum 21 dagars lagring på granplanka omsluten av granbark så säljs den i en ask som även den är gjord av gran. Storleken på askarna varierar från 11 till 33 cm i diameter och vikten från 480 gram till 3,2 kg (ask inkluderad!). AOC-status sedan 1981.

Mont d'Or

Vi avnjöt den på det troligen vanligaste sättet, “ugnsbakad”. Man gör ett hål i toppen och häller på vitt vin och gärna lite pressad vitlök, efter ca 20 minuter i ugnen kan man ta ut en härligt doftande och mycket krämig Mont d’Or som avnjuts tillsammans med kokt potatis och charkuterier. Vår vänlige vinhandlare hade tre förslag på vin; Rousette de Savoie, Crépy eller en Riesling från Alsace. Vårt val föll på en Crépy och den satt som en smäck.

Mont d’Or är även som hörs på namnet ett berg och det har sin högsta punkt 1463 meter över havet. Namnförvirringen kring denna ost är ganska total och i ett kommande inlägg så skall jag försöka reda ut begreppen kring de franska och schweiziska varianterna på denna ost.

For a long time an idea travelled in my head. But now it arrived.

In my several Ant build files I have constructs like

<javac source=”${javac.source}” debug=”${javac.debug}” target=”${javac.target}” …

and the according properties defined in an external file. Now have a compile run for the source code and the test code and you have doubled this amount of configuration. And I thought that just writing a <javac> and starting with an -autoconf option would be easier.

The idea is: apply the properties directly before the task execution.

So I could implement a method call in oata.Task.perform() direclty before calling the execute() method.
Hhm …. I don’t want to change the Ant core that deeply because so many external tasks exist and I don’t want to (maybe) break their build.

Another idea is using an AOP framework like AspectJ for jumping in: before <? extends Task>.execute() : applyAttributeValues()
(I am not familiar with AspectJ but you get the idea.)
But then I would depend on the AOP library. That’s nothing for the Core. And Ant options should not depend on any further libraries.
I could implement it as a task:

  <project><autoconf/><javac/></project>    

Better. But I have to learn AspectJ … so not for now…

On the Hudson dev-mailinglist I heard from the Hudson Clover Plugin. It gatheres code coverage from Ant jobs WITHOUT configuring the job itself.-It adds a BuildListener which stores the srcdir and destdir values from <javac> tasks.
Nice idea …. use the Listeners taskStarted(event) and taskFinished(event) methods for doing AOP-stuff.

This results in the <autoconf> task, currently in the sandbox and feedback is welcome.

The goal:

• apply attribute values from properties
• do not overwrite user specified values
• switch on/off the behaviour
• support name prefix for using different values for different targets

While the last two points are easily to implement (add/remove the listener, use a prefix for property search) the first two are difficult.

apply attribute values from properties / which attributes are supported by a given task?

Why is this difficult? Just ask mytask.getClass() for declared setters ….

The problem is that you don’t get the task object. Due lazy instantiation/configuration the only thing you get from the BuildEvent is an UnknownElement. And therefore you cannot just ask getClass() for the class object you need.

I saw three different strategies according to that value:

• if it is a <macrodef> I could ask it directly for its <attribute>s
• if it is a normal task I ask the class object
• if it is a <presetdef> I ask the class object from preset.getTypeClass()

do not overwrite user specified values

I could ask an object for its values, but which are set by the user and which are just implementation defaults? From the Java perspective you cannot distinguish between them…

My strategy is using a “clean” object (I called it template object) and compare its values with the values from the given object.

Hi guys,

It’s been a while since an update or a release (while not that long), so I’ll shed some light.

XviD4PSP fails on me now so I can’t rely on it anymore for encodes. I’ve moved on to HandBrake which works on both Windows and Ubuntu. Hopefully, this can throw up way better encodes for you guys. As always, if you want to help out with releases, feel free to speak up. Leave comments, register, leave comments on torrents, etc. Any sort of help is appreciated.

In other updates, I contacted the guy for the Nogizaka Haruka joint and he hasn’t replied as of yet. I’m giving until the end of the week until I start batching whatever is available. I just scrolled down the update list and InuYasha Ep 2, Nogizaka (no official fansubs yet – HorribleSubs don’t count), Queen’s Blade EP3 will be next in the pipe. Asura Cryin 2 will be dropped and that’s pretty much about it.

Keep your eyes out for the next few releases.

Banon är regionen Provence-Alpes-Côte d’Azurs bidrag till de franska AOP och AOC-ostarna. AOC sedan 2003 gör den till en av de yngre AOC-ostarna men den har anor ända sedan medeltiden då den finns omnämnd i gamla skrifter. Tillverkningen sker i området kring den lilla byn Banon som ligger i departementet Alpes-de-Haute-Provence.

Den presenteras inlindad i torkade blad från kastanjträdet som hålls på plats med hjälp av snöre gjort av palmblad. När man öppnar upp de brunt höstfärgade bladen hittar man en cirkulär ost på 100 gram som lagrats i minimum 15 dagar, därav minst de sista 10 dagarna inlindad i kastanjebladen. Det förkommer även att den badas med eau-de-vie innan den lindas in i bladen. Till konsistensen så skiljer sig osten från de “vanliga” getostrana genom att den är väldigt krämig och nästan rinnig en lätt ammoniaksmak kan både doftas och kännas vid avsmakning av osten som är ganska stark. Osten är inte någon av mina favoriter och den påminner om annan ost som jag också har lite svårt för nämligen Pérail de Brebis. En fårost som tillverkas i Midi-Pyrénées och har en liknande konsistens.

Givetvis finns det även legender kring osten Banon. Den romerske kejsaren Antonius Pius (86-161)  dog i en magsjukdom efter att ha ätit för mycket ost och osten han åt för mycket av skall ha varit just Banon.

Working on transferring from blogger

<bean id=”test” class=”*.*.finder() />

Recently I was tasked with looking into configuring one of the webapps I work on to leverage caching. Here is a simple example of how one can accomplish this using Spring AOP and ehcache.

Dependencies (not complete list)

• aspectjweaver-1.5.3.jar
• ehcach-1.6.2.jar
• spring-support-2.0.7.jar
• spring-aop-2.5.5.jar

I already had a bunch of the other Spring dependent jars that are not listed. Grab a copy of the ehcach.xml from their site and place it in your classpath, for me that is src/main/resourses. Not all of the options in the ehcache.xml are required but I highly recommend reading the comments in the file so you have a good understanding of the options you have.

Now to create an Interceptor class that will be responsible the caching logic. For this we will use something very simple such as:

public class MethodCacheInterceptor implements MethodInterceptor {

private Cache cache;

@Requiredpublic void setCache(Cache cache) {this.cache = cache;}

public Object invoke(MethodInvocation invocation) throws Throwable {String targetName  = invocation.getThis().getClass().getName();String methodName  = invocation.getMethod().getName();Object[] arguments = invocation.getArguments();Object result;

String cacheKey = getCacheKey(targetName, methodName, arguments);Element element = cache.get(cacheKey);

if (element == null) {//call target/sub-interceptorresult = invocation.proceed();

//cache method resultelement = new Element(cacheKey, (Serializable) result);cache.put(element);}return element.getValue();}

private String getCacheKey(String targetName,String methodName, Object[] arguments) {StringBuffer sb = new StringBuffer();sb.append(targetName).append(".").append(methodName);if ((arguments != null) && (arguments.length != 0)) {for (int i=0; i sb.append(".").append(arguments[i]);}}return sb.toString();}}

That’s it for coding, now we just need to wire it all together.

Now for the pointcut setup:

Pretty simple, in my upcoming post I will give an example of how to use AOP to invoke a timed event which will be used to ping the Cache in this example to retrieve statistics.

What are your first steps if you are injured on the job?

If you are injured on the job, here are some steps you should take to file a worker compensation claim and to preserve your rights under workers comp law:

• Report the injury to your employer by telling your supervisor right away.
• Get emergency treatment if you need it. Your employer may tell you where to go for treatment.
• Tell the health care provider who treats you that your injury or illness is job-related.
• Complete and file a WC-14, with the State Board of Workers’ Compensation and send a copy of the form to your employer and their workers’ compensation insurance carrier.

Report any accident to your employer (boss, foreman, or supervisor) immediately. This is important because if you wait longer than 30 days, you might lose the benefits due you under Atlanta worker compensation law.

If you are injured while working, contact an Workers’ Compensation lawyer to assist you in claiming compensation for medical treatment, lost wages, and any permanent damage or disfigurement all of which are covered by Atlanta worker compensation law.

http://www.javalobby.org/java/forums/t44746.html

I followed a bit of the Association of Online Publishers conference from my desk today, sporadically and passively as work demanded.

Quotes and broad themes turned up regularly on Twitter, and in among them came a tweet from Adam Tinworth about a Kevin Anderson post that ‘builds an important point out of a few of the less obvious quotes’.

I followed the link, only thinking afterwards how the overall reading experience recalled the transition from commentator to summariser (US: color commentator) in cricket coverage.

On the production side, of course, what happened is five, six, maybe seven multiverses distant from that.

How often is it worth formalising the commentator-summariser dynamic in live web coverage, so that tweets, pics and links from a ‘ball-by-ball’ person dovetail near-live with insight pieces from a blogger?

It would have to be some event, especially given that solo live blogs already do the com-sum mix quite well – and in cricket coverage, among other places…

PS: Yes, you could also talk reporter-section head rather than commentator-summariser, but the latter doesn’t come with any management-tree baggage.

PPS: I daresay that there are sports other than cricket, and that they have commentators and summarisers too. I wish them well.

The AOP conference today had plenty of speakers addressing the likely move from Cost Per Thousand (CPM) models towards more Cost Per Engagement (CPE). On the face of it, this is a welcome shift. It is in line with the increasing demand for media spend to be clearly associated with performance – with achieving the objective of the campaign. P&G is leading the way, with recent briefs offering to pay media owners more for delivering ”engaged users”. (NMA 17 Sept 09)

So far so good.

But when advertisers place media budget with an agency, the agency control is only in delivering the best possible marketing effort, driving volumes of qualified prospects to the website. After that, it is the responsibility of the website to convert the prospect into a sale, be that a purchase, a download or subscribing to a newsletter. And that is in the hands of the website owner, not the marketers.

If the CPE model is to work, advertisers must address the Sale, not just the Marketing. And that means a shift in mindset – when consumers are confident that clicking on an ad will take them to a place that is a good experience, engaging, easy to use, maybe we’ll see clickthrough rates finally start to rise again.

Meanwhile, CPE pits Marketing against Sales and that is not a recipe for driving performance.