Temperies Blog

(Español) Hello world! Selenium2 + .Net

nvillarreal — Tue, 07 Feb 2012 14:54:01 +0000

Sorry, this entry is only available in Español.

Primeros Pasos en JMeter

cbaquero — Fri, 27 Jan 2012 17:03:37 +0000

Sorry, this entry is only available in Español.

NoSQL databases: What you should know about

Nicolás Tourne — Thu, 14 Jul 2011 20:48:49 +0000

Relational database model has been co-existing with us for around a quarter of a century -so much time, right?-, but a new class of database has emerged in the enterprise. I’m talking about NoSQL.

What is NoSQL?

NoSQL, also known as “non-relational” or “cloud”, is a broad class of database management system with significant differences from a classic relational database management system (RDBMS). The stored data not require fixed table schemas. It usually avoids join operations and typically scale horizontally.

Architecture with NoSQL

NoSQL database is characterized by a move away from the complexity of SQL based servers. The logic of validation, access control, mapping querieable indexed data, correlating related data, conflic resolution, maintaining integrity constraints and triggered procedures is moved out of the database layer. This enables NoSQL databases engines to focus on exceptional performance and scalability.

A key concept of NoSQL systems is to have DBs focus on the task of high-performance scalable data storage, and provide low-level access to data management layer.

Pros & Cons

Pros

Improve performance – Performance metrics have shown significant improvements vs relational access. For example, this performance metric compares MySQL vs Cassandra:
Facebook Search
MySQL > 50 GB Data
- Writes Average: ~300 ms
- Reads Average: ~350 ms
Rewritten with Cassandra > 50 GB Data
- Writes Average: 0.12 ms
- Reads Average: 15 ms
Scaling – NoSQL databases are designed to expand transparently and they’re usually designed with low-cost commodity hardware in mind.
Big data handling – Over the last decade, the volumes of data has been increased massively. NoSQL systems can handle big data in the same way as the biggest RDBMS.
Less DBA time – NoSQL databases are generally designed to requiere less management: automatic repair, data distribution and simpler data models.
Reduce costs – RDBMS uses expensive proprietary servers and storage systems, while NoSQL databases user clusters of cheap commodity servers. So, the cost per gigabyte or transaction/second for NoSQL can be many time less.
Flexible data models – NoSQL key-value stores and document databases allow the application to store virtually any structure it wants in a data element.

Cons

Maturity – RDBMS systems are stable and richly functional. But most NoSQL alternatives are in pre-production versions with many key features yet to be implemented.
Support – Most NoSQL systems are open source projects. There’re a couple of small companies offering support for each NoSQL database.
Analytics & BI – NoSQL databases do not offer facilities for ad-hoc query and analysis. Commonly used business intelligence tools do not provide connectivity to NoSQL systems.
Administration – Although the design goal of NoSQL system is to provide a zero-admin solution, it’s true that requires a lot of skill to install and a lot of effort to maintain.
Expertise – As NoSQL systems is a new paradigm, all developers are in a learning mode.

Use a RDBMS or a NoSQL Database?

Depends mainly on what you’re trying to achieve. It’s certainly mature enough to use. But few applications really need to scale that massively. For most, a traditional RDBMS is sufficient. However, with internet usage becoming more ubiquitous all the time, it’s quite likely that applications that do will become more common (though probably not dominant).

NoSQL Implementations

There are currently more than 122 NoSQL databases. They can be categorized by their manner of implementation:

Wide column store / column families – Cassandra, Hadoop, Hypertable, Cloudata, Cloudera, Amazon SimpleDB, SciDB
Document store – MongoDB, CouchDB, Terrastore, ThruDB, OrientDB, RavenDB, Citrusleaf, SisoDB
Key Value / Tuple store – Azure Table Storage, MEMBASE, Riak, Redis, Chordless, GenieDB, Scalaris, BerkeleyDB, MemcacheDB.
Eventually consistent Key Value store – Amazon Dynamo, Voldemort, Dynomite, KAI
Graph databases – Neo4J, Infinite Graph, Sones, InfoGrid, HyperGraphDB, Trinity, etc

And others, and others…

Early Adopters of NoSQL

Social media corporations as the primary traiblazers of NoSQL implementations. The list includes:

Facebook
Twitter
MySpace
Google (Hadoop, Google App Engine)
Amazon (Dynamo)

Books & Papers Recomended

Professional NoSQL (Wiley/Wrox. 2011)
NoSQL Database Technology (CouchBase. 2011)
NoSQL Handbook (Mathias Meyer)
No Relation: The Mixed Blessings of Non-Relational Databases (Ian Thomas Varley. 2009)
Cassandra: The definitive guide (Even Hewitt. 2010)
CouchDB: The Definitive Guide: Time to Relax (J. Chris Anderson, Jan Lehnardt, Noah Slater. 2010)
Hadoop in Action (Chuck Lam. 2010)
HBase: The Definitive Guide (Lars George. 2011)
MongoDB in Action (Kyle Banker. 2010)
Beginning SimpleDB (Kevin Marshall, Tyler Freeling. 2009)

Conclusions

NoSQL databases solve problems which born with the global digital data growth, where the DBAs have been dealing with the well-known RDBMS.
Outside of scalability, it really seems that NoSQL databases do not have a killer feature.
Although, I think this is a new opportunity to become a professional on this paradigm.

The right way to use Javascript.

Santiago Fuse — Fri, 08 Jul 2011 19:58:22 +0000

The Javascript closure and the Module Pattern application.

There can be different and several ideas about which is the best way to use Javascript in our pages towards encapsulate behaviors and actions of the elements in the DOM, and sure there are diferent points of view about this. I think and believe as several people know that Module Pattern may be is the best way or at least the clearest . I usually make one file for each page within a Module Pattern named as the page.

Summarizing, the main idea of these examples is shows a way or “right” way to use Javascript and no matter which library or framework ( Jquery, Mootools, YUI, etc ) are you using. It is using closures in Javascript and the Module pattern to encapsulate the behaviors and functionalities of a given page.

The Javascript Closure.

I’m not going to suppose you have knowledge in Javascript Closures, in fact I’m going to define them and show you some simple examples of this powerful tool, or better, behavior.

See the following definition (variable scope).

A closure are the local variables for a function – kept alive after the function has returned.

It is simple to understand, the local variables still are in the variables stack and can be access after the function returns, the good way to understand always is by examples, please see the following examples.

var a = function(param){
    var internalParameter = param;
    return function(){
        alert(internalParameter);
    } ;
}
var b = a(9);
b(); // Shows 9.

As you can see in the previous example (you should see the number 9), the returned function still has access to the variable internalParameter when the function “a” has returned and the alert will be 9 as we would expect , this is one of the basic examples of the use of closures and this is the beginning of understanding and using the Module Pattern, in fact Module Pattern is one of the bigest example of closure in javascript.

By the way before we continue with the pattern I will show you some other examples of closure.

function add(x) {
  var temp = 10;
  return function addToReturn(y) {
      alert( x + y + (temp++));
  };
}
var a = add(10);
a(10);
a(10);
a(10);

The previous example will give us 3 alerts, will be 30, 31 and 32 and the variable temp is our closure in this case.

function addButtons(numOfButtons) {
    var i, button;
    for(j = 0; j < numOfButtons; j++) {
        button = document.createElement("button");
        button.innerHTML = "Button " + i;
        button.onclick = function() {
            alert('You just clicked Button, buttons count ' + numOfButtons );
        };

        document.body.appendChild(button);
    }
}
addButtons(6);

The previous code will add 6 buttons in the document and each button will have an event, when you click will show you just the number 6.

The Module Pattern.

Now, whe’re going to define and make some examples (I’ ll try to be clear) about Module Pattern, the most clear definition I have found is “The Module Pattern means you define a variable as an anonymous function that gets immediately called with (). You define private functions and variables and return your public variables and functions as properties and methods of an anonymous object“.

To summarize the definition in a more clear way, this pattern allows us to scope variables and methods with both private and public visibility, bellow I’m going to create an example to figure out the pattern, please see the following example being “page” the name of the page (would be great if you use the name of the page as the name of the module pattern , is a good custom).

/* page.html */
My page

/* page.js */
var page = function() {

    var helloWorld = function() {
        alert('Hola mundo');
    }

   /* Public interface object */
   var oPublic = {
       init: function() {
           helloWorld();
        }

   };
   return oPublic;
}();

$(document).ready(function(){
  page.init();
});

If you take a look at the previous code, the variable page has parentheses at the end of its declaration, it means the function is “auto executed” and the object with the public interface is returned.
In this case for example, when the page has been loaded the method init() is executed, the variable page is the object returned by the first function and if you remember the definition of closures in javascript the method init() still has access to the function hellowWorld which was declared into the first function, it is really clear and powerful whether we want to handle or add events, add delegations, add elements etc when the page is loaded, all the functionality and functions will be into the closure and looks like as “private” that will be called for public functions or methods in the public interface (oPublic).

Please to clarify take a look at the following example.

var myObject = function(){
    var privateVar = 1;
    function privateFunction(){
        alert('Hi, Im a private function called by the public function ');
    };

    function publicFunction(){
        privateFunction;
    }

    return {
        publicFunction:publicFunction,
        publicVar:publicVar,
    }
}();

Other more real example (I dont want you to understand all the example, is only to see a little example in real use)

var pageComments = function() {

    var createReplyArea = function(elContainer, nCommentId) {
        var sHtml = 'textArea and buttons to add or cancel the new reply';
        $(elContainer).html(sHtml);
    };

    var textAreaCountdown  = function(elTextArea, elRemainingChars) {
         var sTextContent = $(elTextArea).val(),
         nCharsCount = sTextContent.length,
         nRemainingChars = 512 - nCharsCount;

        if(nCharsCount > nMaxCharacters) {
            $(elTextArea).val(sTextContent.substring(0, nMaxCharacters));
            $(elRemainingChars).text(0);
        } else {
            $(elRemainingChars).text(nRemainingChars);
        }
    }; 

    /* Public interface object */
    var oPublic = {
        var init: function() {
            $('comment-container').delegate('a.reply', 'click', function(event) {
                event.preventDefault();
                event.stopPropagation();
                var elTarget = event.currentTarget,
                elContainer = $(elTarget).parent().find('div.comment-reply-wrapper'),
                nCommentId = $(elTarget).parent().find('input').val();
                if(!$(elContainer).children().length) {
                    createReplyArea(elContainer, nCommentId);
                }
           });

           $('div.comment-widget').delegate('textarea', 'keyup keypress change paste select', function(event) {
               var elTarget = event.currentTarget,
               elRemainingChars = $(elTarget).parent().siblings().find('span.remaining-characters');
               textAreaCountdown(elTarget, elRemainingChars);
               event.stopPropagation();
           })
       }
   };
   return oPublic;
}();

$(document).ready(function(){
    pageComments.init();
});

When the page has been loaded the public init function is called and adds the handle of the click event to add the new reply area on each “a.reply”, also each text area has handled the key events to count and limit characters that we enter, you could see a clear example of closure and module pattern because the function returns the public object with the init() function and the createReplyArea and textAreaCountdown function are not public but, the element of the DOM still have access to these functions by the events after the function has returned.

However there are different ways to do the module pattern, for example different ways to write the object to return, for example see the following declaration.

var f = function() {
    var obj = {};
    obj.methodOne = function(){ alert(privateVar); }
    return obj;
}();

And the last example to close the idea, you have a page named liks.html with one DIV (class=”link-container”) within links (class=link) and you want to handle for each link the “click” event.

/* page.js */
var linksPage = function() {

    var handleLink = function(target) {
        alert(target);
    }

   /* Public interface object */
   var oPublic = {
       init: function() {
           $('link-container').delegate('a.link', 'click', function(event) {
               event.preventDefault();
               event.stopPropagation();
               handleLink(event.currentTarget);
           }
           /* May you want to do the same with mootools
              $('link-container').addEvent('click:relay(a.link)',
                  function(event, clicked){
                  });
           */
       }
   };
   return oPublic;
}();

$(document).ready(function(){
  linksPage.init();
});

This code will handle the click event in all links (class=”link”) into the page, and when you click whichever link will show you an alert with the link-object.

This is all for this moment, see you in the next tutorial.

Using HTML5 Now

Juan Gaya — Mon, 16 May 2011 15:07:37 +0000

Introduction

There has been a lot a discussion lately about using or not HTML5 right now or to wait for greater adoption of it, we are not going to have that discussion here, I’m taking side and say that it should be used right now and not wait for complete adoption and have some of the benefits of HMTL5 today and be prepared for tomorrow.

So you have decided to update or create your site to HTML5 like all the cool kids are doing, great. What now? This article will focus on all the necessary steps in order to make your site in HTML5 but still compatible with the older browsers, and to take advantage of all the features you want even if they are not implemented in all the majors browsers yet.

If you want the short version and can’t wait or don’t want to know the all thing you should go to Initializr that have everything pack up and ready to go, another option is Boilerplate that have all you’re going to need to set up your project.

Now if you want to know how to do it on your own, or want to understand how some of it work keep reading.

As you probably now HTML5 is not just html markup, it also encloses under the name all the new JS API and the latest version of CSS, CSS3. So you will have to check for all the availability of all of these things and to provide fallbacks for all of them.

Chapter 1 – The Markup

Let’s start with the markup of the page and move are way up, shall we. First let’s look exactly what are the new tags that we have available, there are quite a few and several seems very useful for any site, you are probably wanting to use them now, right? Now let’s look at the reality of the adoption in browsers, go I’ll wait.

Ready? Ok, so bad news right, we have a problem in our hands, adoption is not complete yet, and we have to deal with the old browsers as well. If you try the simplest approach, just write the markup to see what happens, you will get two different types of results:

In all browsers but IE the nodes will get inserted in the correct order in the DOM with no default styling, but it will let you give it any style you want.
In all versions of IE prior to 9 the behavior towards unknown DOM elements was add them as an empty node, and all its children were added as siblings of the unknown element, as a second problem IE won’t let you add styling to the element.

Luckily there is a workaround for this problem up to IE6, if you create the unknown element with JavaScript, IE will start to let you use it and give it style.


    
        
        
    
    
        
            IE Unknown Element workaround example
            Some dummy text

Just creating the element once per page is enough to use it, and you don’t have to insert it into the DOM. To make it easier for the rest of us there is a written solution by Remy Sharp called html5shiv just adds this to your web page:

Add that file in each page at the top not at the bottom because it should be run before the DOM is ready, or the tags in your HTML won’t get recognized in time. And with that the first (of many) problem is solved.

Canvas

Now let’s try to use some of the more multimedia specific tags and its APIs, let’s begin with the canvas element. First we need to know if canvas is supported in the browser, currently the only browser that doesn’t have canvas support is IE prior to version 9, to solve that you can use a JavaScript library called explorer canvas that lets you use canvas in IE with he majority of the functionality of it.

With this we have the canvas up and running, but if we want to detect if a particular API is present in the browser we should try it first, to do that we create a canvas in the DOM and if it is supported the getContext() method will exist, let’s see it in code:

function useCanvas(){
    return !!document.createElement(‘canvas’).getContext(‘2d’);
}

Then we try for the desired API in this case FillText:

function supports_canvas_text() {
    if (!useCanvas()) { return false; }
    var myCanvas = document.createElement('canvas');
    var context =myCanvas.getContext('2d');
    return typeof context.fillText == 'function';
}

We can use that function to use that functionality and in case that is not there have a fallback but making such a function for every API we want to test is cumbersome fortunately there a great library that we can use for this and for much more called modernizr that is a feature detection script that let you check for the availability of native implementations for next-generation web technologies. Using it instead of the previous function:

if (Modernizr.canvastext) {
    // its supported normal code
} else {
    // fallback code
}

We can use Modernizr to check for all of the new features in the browsers that can render or utilize them, and still have easy and reliable means of creating fallbacks (that you should decide and do) for the browsers that cannot.

Audio

The use of the tag audio is pretty straightforward you just have to name the source file and that’s it if you want to use the default controls of each browser.

Now for the fallback plan you can use flash or quick time, adding the embedded object inside the audio tag and that’s it for the most basic set up. Other way to go is using modernizr to check for audio support and add the flash player through JavaScript.

if (!Modernizr.audio) {
   // add fallback flash to the DOM
}

For a most comprehensive example visit HTML5Rocks or if you want a simple player to build on top of, check this one.

Video

The use of the video tag is very similar to the audio tag, the main problem with it is the lack of a codec standard across all browsers because of that you have to make several versions of the video with different codecs, webM, ogg and X264 are the most used and with those 3 you are pretty much covered, just as the audio tag the fallback is flash. Now what you are expecting, the example code:


  
  
  
  
        
        
        
        
        
        Your browser can’t play HTML5 video. Download it instead.

For a full demo of this and a more helpful description you should look at http://camendesign.com/code/video_for_everybody. If you don’t want to get into the specifics and wants a pre created solution you should check http://praegnanz.de/html5video/ there is a great comparison between some of the more popular solution out there.

Forms

One of the aspects that have been greatly improved in HTML5 are the forms, including new input types , new form elements and some new form and input attributes. As with the previous elements that we have seen the main problem is adoption and the older browsers.

The good news here is that if use the new input type as mail or url the browsers that do not have them yet will treat them as text inputs so the page will not break, but we have to keep doing the validation with JavaScript as always, so you can change your input types in your current page and the final user will not see the difference, but your page will be ready for the future. To see if the input type is supported by the browser so you won’t load unnecessary JavaScript you can use modernizr. The same can be said about the input attributes if you use them and the browser don’t have support for it, the browser will ignore it and that’s it .

Example of detection with Modenizr:



// In your JavaScript:
if (!Modernizr.inputtypes.date){
    // if no native support, use a datepicker script
    createDatepicker(document.getElementById('birthday'));
}

//For input attributes

// if placeholder isn't supported:
if (!Modernizr.input.placeholder){
    // use a input hint script
    setInputHint(document.getElementById('username'),'Enter Username');
}

Finally I highly recommend that you read http://diveintohtml5.org/forms.html for a more complete documentation about this, and the entire book if you are interested in learning more about HTML5.

We’ll continue with this in chapter 2 to see what we can use of CSS3 and how. See you then.

Interacting with the Wiimote – WiiSim Tennis

Fabricio Lettieri — Fri, 04 Mar 2011 13:49:12 +0000

The Temperies IT’s TechLab area allows its members to explore new mass use technologies available in the market to provide new products and services with a bonus of innovation.
The Wiimote is a non conventional device that features a range of new applications providing the user a new experience of interacting with the computer.

This work was done by Andrés Gariglio y Fabricio Lettieri (Temperies IT developer) in conjunction with engineers Cristian García Bauza and Juan Pablo D’Amato from PLADEMA institute (UNICEN Tandil), these latter two are members of our TechLab.

Introduction

Human interaction with computer systems is no longer an impractical and unprofitable experience and is opened to new ways of communication. The current non conventional devices, such as the figures and gestures recognizer device called Kindle for the Xbox and multi touch devices, provide a new user experience. The same evolution of the practicality of the human kind forces to create new interaction devices.

The device issued here is the control of the Nintendo Wii console: the Wiimote.

It’s a wireless device that communicates via Bluetooth to any receiver that captures this signal. While Nintendo has not released its specification, there is an online community that is dedicated to hacking the device for home-brew. Thanks to this conjunct effort there are many APIs for communication and use of the wiimote in many programming languages.

Features

The Wiimote is capable of detecting movement by acceleration in three dimensions using accelerometer technology.

It has an infrared camera that records the movement of up to four infrared sensors.

This technology makes the Wiimote one of the most sophisticated input devices compatible with PCs available today at a suggested retail price of u$s 40.

Our Application

WiiSim Tennis born as a tennis simulation and training game using the Wiimote as the input of gesture recognition.

The application consists of two main components
- Profile Editor.
- Training tennis game.
Check out this homemade video for a contest conducted named Wiideojuegos: http://www.youtube.com/watch?v=SPMjjjUbd4s
To view all other videos of the contest visit the following link: http://www.youtube.com/user/WiideojuegosUPM#p/a/u/2/Ku_onwqGKt0

Captures of our application:

Profile Editor.

Trainning tennis game.

The application’s development plan consists of the following tasks:

1. Study and selection of an API to capture data from the wiimote using bluetooth connection.
2. Analysis of different approaches to obtaining and processing data.
3. Design and development of PC-communication library Wiimote.
4. Analysis of proper sampling strategies taking account time variations.
5. Development of a tool for creating, gesture recognition and comparison, extraction of statistics, and history according to a user profile.
6. Interactive 3D rendering.
7. Game menu, screens, and multimedia content.

The development environment was Codegear Delphi 2007.
We used the following components for the system modules:

• Rendering engine: Impromptu graphics engine, developed in PLADEMA Institute, 2004-2010. Impromptu presents a higher level abstraction of OpenGL which allows creating neat and tidy applications.
• Physical behavior: Newton Game Dynamics through a communication layer, the latter developed in PLADEMA Institute, 2009.
• Communication Wiimote: Component TJvHidDeviceController from the JEDI components package.

Dynamic Time Warping (DTW)

For comparison of gestures the DTW algorithm was implemented because of its simplicity and excellent performance. This method measures similarities between two data streams, which can vary in length and speed, adding the distances between them in each time interval. The calculation of distance is no point to point but the point of least distance, which provides elasticity (warping) of the comparison.

Following figure shows two data sets being compared. The arrows indicate the desired alignment points.

Elastic comparison between two data sets.

New Oracle Lucene Domain Index release based on Lucene 3.0.2

Marcelo Ochoa — Wed, 16 Feb 2011 19:44:53 +0000

Just a few words to announce a new release of Oracle Lucene Domain Index, this zip is valid for 10g and 11g database version (10g using back-ported classes from 1.5 to 1.4)
This release is compiled using Lucene 3.0.2 version and incorporates a set of new features added, here the list:

Added a long awaited functionality, a parallel/shared/slave search process used during a start-fetch-close and CountHits function
Added lfreqterms ancillary operator returning the freq terms array of rows visited
Added lsimilarity ancillary operator returning a computed Levenshtein distance of the row visited
Added a ldidyoumean pipeline table function using DidYouMean.indexDictionary storage
Added test using SQLUnit

The bigger addition is the Parallel-Shared-Slave search process, this architectural change was in my to-do list for a long time and finally I added in this release
The idea behind this is to have a new Oracle process started by the DBMS_SCHEDULER sub-system during the database startup process and stopped immediately before shutdown.
Now this process is responsible for implementing the ODCI methods start-fetch-close/count-hit on behalf of the client process (process associated to an specific user session) which connect to the shared-slave process by using RMI.
With this new architecture we have two principal benefits:

Reduce memory consumption
Increase Lucene Cache Hits

Less memory consumption because the internal OJVM implementation is attached to a client session, so the Java space used by Lucene structures is isolated and independent from another concurrent session, now all Lucene memory structures used during index scan process are created in a shared process and then not replicated.
Also if one session submits a Lucene search, this search is cached for subsequent queries, all subsequent queries coming from the same client session or any other which are associated to the same index and with the same Query string implies a hit.
I’ll explain more in detail this new architecture in another post also showing how many parallel process can work together when using Parallel Indexing and Searching.
On the other hand next week I’ll be at the Oracle OpenWorld 2010 in SFO presenting the session:

Schedule: Tuesday: 09:30AM
Session ID: S315660
Title: Database Applications Lifecycle Management
Event: JavaOne and Oracle Develop
Stream(s): ORACLE DEVELOP
Track(s): Database Development
Abstract: Complex applications, such as Java running inside the database, require an application lifecycle management to develop and delivery good code. This session will cover some best practices, tools, and experience managing and delivering code for running inside the database, including tools for debugging, automatic test, packaging, deployment, and release management. Some of the tools presented will include Apache Maven, JUnit, log4j, Oracle JDeveloper, and others integrated into the Oracle Java Virtual Machine (JVM) development environment.

See you there or at any of networking planned events

Dealing with JDK1.5 libraries on Oracle 10g

Marcelo Ochoa — Tue, 08 Jun 2010 19:24:11 +0000

Modern libraries are compiled with JDK 1.5 and the question is How to deal with these libraries on an Oracle 10g OJVM.
Some examples are Lucene 3.x branch or Hadoop. The solution that I tested is using a Java Retro Translator and some complementary libraries.
I have tested this solution in Lucene Domain Index 3.x branch with success.
As you can see on the CVS there is build.xml file which performs all the retro translator steps. Here an step by step explanation of the process:

Load all required libraries provided by Retro translator project which implements features not available on JDK 1.4/1.3 runtime, this is done on the target load-retrotranslator-sys-code. This target loads many libraries on SYS schema due are immutable, or with low probability of change. It will change if we upgrade a retro-translator version. All libraries are then compiled to assembler using NCOMP utility, target ncomp-runtime-retrotranslator-sys-code.
Then we can convert libraries compiled with JDK1.5, in this build.xml file the Lucene and Lucene Domain Index implementation, to a JDK1.4 target runtime. This is done on the targets backport-code-lucene and backport-code-odi, on first target We converts all Lucene libraries excluding JUnit and Test code, these libraries require as a dependency JUnit and retro-translator jars. Second target converts Lucene Domain Index jar depending on Lucene core and Oracle’s libs. The back-port operation generates a file named lucene-odi-all-${version}.jar with Lucene and Lucene Domain Index code ready to run on JDK1.4 runtime.
Once We have the code back-ported to a JDK1.4 runtime We can upload and NCOMP into Oracle 10g, this is done on targets load-lucene-odi-backported-code and ncomp-lucene-all.

And that’s all!!, the code works fine on my Oracle 10.2 database – Linux , finally users of 11g and 10g databases can deploy Lucene Domain Index implementation using one distribution file.