Oracle - Diff between CHAR,VARCHAR and VARCHAR2

Coming soon...

Refer as of now
http://www.orafaq.com/faq/what_is_the_difference_between_varchar_varchar2_and_char_data_types

File Operations with Oracle

How to read a file using PL/SQL


declare
input_buffer varchar2(4000);
successful_output_file utl_file.file_type;
begin
successful_output_file := utl_file.fopen ('/tmp','mytest.txt', 'W');
input_buffer := 'ask'||'|'||'nava';
DBMS_OUTPUT.PUT_LINE(input_buffer);
utl_file.put_line(successful_output_file,input_buffer);
utl_file.fclose(successful_output_file);
end;


How to write to file using PL/SQL


declare
input_buffer varchar2(4000);
input_file utl_file.file_type;
begin
input_file := utl_file.fopen ('/tmp','mytest.txt', 'R');
utl_file.get_line(input_file,input_buffer);
DBMS_OUTPUT.PUT_LINE(input_buffer);
utl_file.fclose(input_file);
end;


Powerful SQL with Excel

Known for their integrity, VB scripts works great for any operations with MS-Excel spreadsheets.

Following simple funtion, can Query/Process the records from excel sheet. You can do most of the operations that you may want to do through table data just from a spreadsheet.

Assume, your excel file is C:\Book2.xls and the Work Sheet name is Sheet1


strConnectString ="Driver={Driver do Microsoft Excel(*.xls)};DBQ=C:\Book2.xls"
strSQL = "select * from [Sheet1$]"
Set objEnv = UDF_GetRecordset1(strConnectString,strSQL)
If Not objEnv.EOF Then
'msgBox('DataArray = objEnv.GetRows(objEnv.Recordcount)')
DataArray = objEnv.GetRows()
For row=0 To (objEnv.recordCount-1)
MsgBox "RowNum:"&row+1
For col=0 To (objEnv.Fields.count-1)
' MsgBox DataArray(col,row)
Next
Next
End If



Public Function UDF_GetRecordset1(strConnection,strSQL)
Dim objConn,objRec ' Variable declaration
Set UDF_GetRecordset1 = Nothing
Err.Clear
Set objConn = CreateObject("ADODB.Connection")
objConn.Open strConnection
If Err <> 0 Then
Set objConn = Nothing
Exit Function
End If
Set objRec = CreateObject("ADODB.Recordset")
objRec.CursorType = 1
objRec.Open strSQL,objConn
If Err <> 0 Then
strSQL
'MsgBox('step31')
Set objRec=Nothing
Set objConn = Nothing
Exit Function
End If
Set UDF_GetRecordset1 = objRec
Set objRec=Nothing
Set objConn=Nothing
End Function




This script can be tested with any VB Script editors- EditPlus.

Known issues:
Numeric field overflow
http://support.microsoft.com/kb/815277

XML Serialization

Classic Defintion:
The reversible process of encoding a data structure as a sequence of bytes

Marshall & Unmarshall:
Marshalling is the process of generating XML document from the instance of Java Class(or any other language in context) and as unmarshalling is interpreting java object from xml document.

Usage:
Wherever xml <--> java occurs heavily. For example, SOAP clients or any other XML intensive processing in java

Frameworks:
Breeze XML Binder, a tool produced by Breeze Factor
http://www.breezefactor.com/.
JAXB Reference Implementation, created by SUN
http://java.sun.com/xml/jaxb/.
Castor:an open source project under ExoLab
http://www.castor.org/spring-xml-intro.html
http://www.ibm.com/developerworks/xml/library/x-xjavacastor2/
XML Beans: Apache Open Source
http://www.onjava.com/pub/a/onjava/2004/07/28/XMLBeans.html

Comparision:
http://www.xml.com/pub/a/2003/09/03/binding.html
http://dev2dev.bea.com/pub/a/2004/05/ryan_xml.html


Known Issues:

1. The language of XML Schema is much richer than the object model of Java,
2. Not all XML names can be turned into Java identifiers, xsd:enumeration declarations cannot be nicely mapped into Java types (even since Java 5),
3. Some Java types are by nature explicitly unportable.
4. XML is a hierarchical data structure, and can only describe trees or lists of data, while Java classes almost invariably refer to other objects, oftencreating cyclic graphs of references.
5. Each node in an XML message can have a separate namespace, which cannot be expressed in Java.

O/X Mapping:
The upcoming improvements are to provide a way to map Object to XML document to overcome most of the known issues

Java Portal/Portlet Specification - JSR 168 (1.0) JSR 286 (2.0)

JSR-168 is a collection of Java APIs for portlet developers. There are a number of reasons to design JSR-168 portlets that adhere to the specification. Portability is an obvious benefit. Code written according to the specification will be easier to move to among portal servers. The majority of Java-based portal servers support JSR-168 portlets.

Another benefit is easier federation. Exposing JSR-168 Portlets via Web Services for Remote Portlets (WSRP) producers is easier when portlets adhere to the JSR-168 specification. WSRP provides a standard to federate portlet content via Web services. JSR-168 and WSRP 1.0 portlet capabilities are tightly coupled. JSR-168 to WSRP portlet bridges utilize JSR-168's URL rewriting APIs. This article illustrates best practices for developing JSR-168 portlets for portability.

---

JSR 286 is a futuristic view of portlet specification 2.0 and the major working areas for JSR 286:

Coordination (Events support, Sharing session beyond portlet application, Sharing render parameters across portlets)
WSRP 2.0 alignment
Better support for Web Frameworks (JSF, Struts, Spring, WebWork)
AJAX Support

This aligns with J2EE 1.4, integrate other new JSRs relevant for the portlet, and align with the WSRP specification V 2.0


More : http://jcp.org/en/jsr/all

XML Schema Languages

1.DTD Data Type Definition

Basic.

2.XML Schemas (XSD)
Widely used

3.RELAX NG
RELAX NG is a schema language for XML. The key features of RELAX NG are that it:

is simple
is easy to learn
has both an XML syntax and a compact non-XML syntax
does not change the information set of an XML document
supports XML namespacezs
treats attributes uniformly with elements so far as possible
has unrestricted support for unordered content
has unrestricted support for mixed content
has a solid theoretical basis
can partner with a separate datatyping language (such W3C XML Schema Datatypes)


4.Schematron
The Schematron differs in basic concept from other schema languages in that it not based on grammars but on finding tree patterns in the parsed document. This approach allows many kinds of structures to be represented which are inconvenient and difficult in grammar-based schema languages. If you know XPath or the XSLT expression language, you can start to use The Schematron immediately.

Webservice development Styles

Webservices can be developed in any of following two ways.

1. Contract-First
The artifacts of external world - WSDL (web service description language) and other schema references are created first and these config definitions are implemented in any of the programming languages (java,.net etc) afterwards.


2. Contract-Last
Here actual services are coded in any of the programming languages and the XML artifacts(wsdl) are created based on the prgrammed services.

Example
For example, Spring web service supports Contract First style whereas web service development from any of IDEs (RAD etc) encourages coding first and generates contract based on the programmed services.

Which is good?
Lets assume the webservices are implemented in Java, the basic difference between these two styles are whether XML is generated from java or Java is genereated from XML.

There is a fundamental difference between hierarchial languages such as XML and object oriented language as Java. Following factors advocates Contract-First better than of Contract-Last atleast from java perspective.

1. Unportable Types:
Few Java types such as TreeMap cannot be converted directly to XML.
2. Cyclic Graph:
Class A refers B and B refers back A. Its difficult to handle these scenarios in XML whereas its very common in java which makes Contract-Last (java->xml) tougher.
3. Reusability:
The XML configurations can be defined in individual XSD files and can be imported to WSDL so that these individual XSD configurations can be reused if required in any other WSDL files.

Javascript Text Parsing


var inputText='this is testin\r\ng of the enivonem of NSHOWKAT@1STNA\r\nTIONALMERCHANT.COM \r\nNSHOWKAT@1STNATIONALMERCHANT.COM';

var ans=inputText.replace(/\r\n/g,"");



Blogger Help - How to create scrollbars for your blogs

Use following style in div tag style="width:420px;height:270px;overflow:scroll;white-space: nowrap;"

WebSphere webservice deployment!

How to configure/deploy servlet based webservices on WebSphere?

Any application on WebSphere is deployed as EAR.

Lets assume The enterprise archive (EAR) is NeoServiceEAR.ear

This has following entries:

NeoServiceEAR/META-INF
NeoServiceEAR/META-INF/application.xml
NeoServiceEAR/NeoService.war

The application.xml has just one web module(NeoService.war)configuration on it.

The web (war) module can have default META-INF and the WEB-INF should contain following files.

NeoService/
NeoService/META-INF/
NeoService/META-INF/Manifest.mf
NeoService/WEB-INF/
NeoService/WEB-INF/classes (directory to have all classes required)
NeoService/WEB-INF/lib(directory to have all runtime libraries)
NeoService/WEB-INF/wsdl (directory - contains webServiceInterfaceClassName.wsdl )
NeoService/WEB-INF/wsdl/webServiceInterfaceClassName.wsdl
NeoService/WEB-INF/web.xml
NeoService/WEB-INF/webservices.xml
NeoService/WEB-INF/webServiceInterfaceClassName_mapping.xml
NeoService/WEB-INF/ibm-webservices-bnd.xmi
NeoService/WEB-INF/ibm-webservices-ext.xmi

JSR 94 - Java Rule Engine API

Introduction:

"The api prescribes a set of fundamental rule engine operations. The set of operations is based upon the assumption that most clients will need to be able to execute a basic multi-step rule engine cycle, which consists of parsing rules, adding objects to an engine, firing rules and getting resultant objects from the engine. The set of operations also supports variations of the basic cycle, particularly variations that would occur in J2EE server deployments."


Goals:


Facilitate adding rule engine technology to Java applications.

Increase communication and standardization between rule engine vendors.

Make Java applications more portable from one rule engine vendor to another.

Provide implementation patterns for rules-based applications for the J2SE
platform.

Support rule engine vendors by offering a harmonized API that meets the needs
of their existing customers and is easily implemented.

Architecture:


The interfaces and classes defined by the specification are in the javax.rules and
javax.rules.admin packages. The javax.rules package contains classes and
interfaces that are aimed at runtime clients of the rule engine. The runtime client API
exposes methods to acquire a rule session for a registered rule execution set and
interact with the rule session. The administrator API-javax.rules.admin exposes methods to load an execution set from these external resources: URI, InputStream, XML Element,
binary abstract syntax tree, or Reader. The administrator API also provides methods
to register and unregister rule execution sets. Only registered rule execution sets are accessible through the runtime client API.

Major Rule Engine Vendors:
JBoss Business Process management suite - jBPM
PagaRULES - PegaRULES Process Commander


Following code illustrates how a Java application can use this API to integrate with any JSR-94 implemented Rule Engine


import javax.rules.RuleServiceProviderManager;
import javax.rules.StatefulRuleSession;
import javax.rules.StatelessRuleSession;
import javax.rules.admin.RuleAdministrator;
import javax.rules.admin.RuleExecutionSet;

// external imports
import org.jcp.jsr94.tck.model.Customer;
import org.jcp.jsr94.tck.model.Invoice;

/**
* This class implement a simple example using a rule execution set
* from the Test Compatibility Kit.
*
* See for the TCK for more information on the object model and the
* rule execution set.
*
* This example requires the following jar file to be present on your
* classpath:
* jsr94.jar
* jsr94-ri.jar
* jsr94-tck.jar
* xerces.jar
* jess.jar (The reference implementation)
*
* To run this example execute the following command in the lib
* directory of the jsr94 distribution:
* java -jar jsr94-example.jar
*/
public class Example
{
// The rule service provider uri as defined by the reference
// implementation.
private static final String RULE_SERVICE_PROVIDER = "org.jcp.jsr94.jess";

/**
* Main entry point.
*/
public static void main( String[] args )
{
try
{
// Load the rule service provider of the reference
// implementation.
// Loading this class will automatically register this
// provider with the provider manager.
Class.forName( "org.jcp.jsr94.jess.RuleServiceProviderImpl" );

// Get the rule service provider from the provider manager.
RuleServiceProvider serviceProvider = RuleServiceProviderManager.getRuleServiceProvider( RULE_SERVICE_PROVIDER );

// get the RuleAdministrator
RuleAdministrator ruleAdministrator = serviceProvider.getRuleAdministrator();
System.out.println("\nAdministration API\n");
System.out.println( "Acquired RuleAdministrator: " +
ruleAdministrator );

// get an input stream to a test XML ruleset
// This rule execution set is part of the TCK.
InputStream inStream = org.jcp.jsr94.tck.model.Customer.class.getResourceAsStream( "/org/jcp/jsr94/tck/tck_res_1.xml" );
System.out.println("Acquired InputStream to RI tck_res_1.xml: " +
inStream );

// parse the ruleset from the XML document
RuleExecutionSet res1 = ruleAdministrator.getLocalRuleExecutionSetProvider( null ).createRuleExecutionSet( inStream, null );
inStream.close();
System.out.println( "Loaded RuleExecutionSet: " + res1);

// register the RuleExecutionSet
String uri = res1.getName();
ruleAdministrator.registerRuleExecutionSet(uri, res1, null );
System.out.println( "Bound RuleExecutionSet to URI: " + uri);



// Get a RuleRuntime and invoke the rule engine.
System.out.println( "\nRuntime API\n" );

RuleRuntime ruleRuntime = serviceProvider.getRuleRuntime();
System.out.println( "Acquired RuleRuntime: " + ruleRuntime );

// create a StatelessRuleSession
StatelessRuleSession statelessRuleSession =
(StatelessRuleSession) ruleRuntime.createRuleSession(uri,
new HashMap(), RuleRuntime.STATELESS_SESSION_TYPE);

System.out.println( "Got Stateless Rule Session: " +
statelessRuleSession );

// call executeRules with some input objects

// Create a Customer as specified by the TCK documentation.
Customer inputCustomer = new Customer("test");
inputCustomer.setCreditLimit(5000);

// Create an Invoice as specified by the TCK documentation.
Invoice inputInvoice = new Invoice("Invoice 1");
inputInvoice.setAmount(2000);

// Create a input list.
List input = new ArrayList();
input.add(inputCustomer);
input.add(inputInvoice);

// Print the input.
System.out.println("Calling rule session with the following data");
System.out.println("Customer credit limit input: " +
inputCustomer.getCreditLimit());
System.out.println(inputInvoice.getDescription() +
" amount: " + inputInvoice.getAmount() +
" status: " + inputInvoice.getStatus());

// Execute the rules without a filter.
List results = statelessRuleSession.executeRules(input);

System.out.println( "Called executeRules on Stateless Rule Session: " + statelessRuleSession );

System.out.println( "Result of calling executeRules: " +
results.size() + " results." );

// Loop over the results.
Iterator itr = results.iterator();
while(itr.hasNext()) {
Object obj = itr.next();
if (obj instanceof Customer)
System.out.println("Customer credit limit result: " +
((Customer) obj).getCreditLimit());
if (obj instanceof Invoice)
System.out.println(((Invoice) obj).getDescription() +
" amount: " + ((Invoice) obj).getAmount() +
" status: " + ((Invoice) obj).getStatus());
}

// Release the session.
statelessRuleSession.release();
System.out.println( "Released Stateless Rule Session." );
System.out.println();

// create a StatefulRuleSession
StatefulRuleSession statefulRuleSession =
(StatefulRuleSession) ruleRuntime.createRuleSession( uri,
new HashMap(),
RuleRuntime.STATEFUL_SESSION_TYPE );

System.out.println( "Got Stateful Rule Session: " + statefulRuleSession );
// Add another Invoice.
Invoice inputInvoice2 = new Invoice("Invoice 2");
inputInvoice2.setAmount(1750);
input.add(inputInvoice2);
System.out.println("Calling rule session with the following data");
System.out.println("Customer credit limit input: " +
inputCustomer.getCreditLimit());
System.out.println(inputInvoice.getDescription() +
" amount: " + inputInvoice.getAmount() +
" status: " + inputInvoice.getStatus());
System.out.println(inputInvoice2.getDescription() +
" amount: " + inputInvoice2.getAmount() +
" status: " + inputInvoice2.getStatus());

// add an Object to the statefulRuleSession
statefulRuleSession.addObjects( input );
System.out.println( "Called addObject on Stateful Rule Session: "
+ statefulRuleSession );

statefulRuleSession.executeRules();
System.out.println( "Called executeRules" );

// extract the Objects from the statefulRuleSession
results = statefulRuleSession.getObjects();

System.out.println( "Result of calling getObjects: " +
results.size() + " results." );


// Loop over the results.
itr = results.iterator();
while(itr.hasNext()) {
Object obj = itr.next();
if (obj instanceof Customer)
System.out.println("Customer credit limit result: " +
((Customer) obj).getCreditLimit());
if (obj instanceof Invoice)
System.out.println(((Invoice) obj).getDescription() +
" amount: " + ((Invoice) obj).getAmount() +
" status: " + ((Invoice) obj).getStatus());
}

// release the statefulRuleSession
statefulRuleSession.release();
System.out.println( "Released Stateful Rule Session." );
System.out.println();

}
catch (NoClassDefFoundError e)
{
if (e.getMessage().indexOf("JessException") != -1)
{
System.err.println("Error: The reference implementation Jess could not be found.");
}
else
{
System.err.println("Error: " + e.getMessage());
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
}


More info:
http://jcp.org/aboutJava/communityprocess/first/jsr094/index.html

Thread-Safe - volatile, synchronized & atomic

The usual way of ensuring thread safety is though locking mechanism via synchronized blocks/methods
Example:

public class MySync {
private int value;

public int getValue(){
return value;
}
//Sync Method
public synchronized void setValue(int v){
value=v;
}

public void performCriticalTask(){
String task="KILL";
//Sync Block
synchronized(this){
//TODO: perform critical task with locking 'this'
}

}
}

Though this is a proven method,too much of locking can be a overhead for the system performance.

There are other alternatives which can be explored and carefully used along with locking for better thread-safe systems.

1. Use of volatile variables
2. Use of new JDK 5 feature java.util.concurrent.atomic

volatile:

Marking a variable as volatile means that the current value is always referred irrespective of state of the object. This means that threads will automatically see the most up-to-date value for volatile variables thus facilitating simpler way of thread safety.However this can be used only under following restricted set of circumstances.

1. Writes to the variable do not depend on its current value.
2. The variable does not participate in invariants with other variables.

Basically, these conditions state that the set of valid values that can be written to a volatile variable is independent of any other program state, including the variable's current state.

So, where can we use volatile safely.

status flags

Perhaps the canonical use of volatile variables is simple boolean status flags, indicating that an important one-time life-cycle event has happened, such as initialization has completed or shutdown has been requested.

Many applications include a control construct of the form, "While we're not ready to shut down, do more work," as shown following example:

Using a volatile variable as a status flag

volatile boolean shutdownRequested;

...

public void shutdown() { shutdownRequested = true; }

public void doWork() {
while (!shutdownRequested) {
// do stuff
}
}

It is likely that the shutdown() method is going to be called from somewhere outside the loop -- in another thread -- and as such, some form of synchronization is required to ensure the proper visibility of the shutdownRequested variable. (It might be called from a JMX listener, an action listener in the GUI event thread, through RMI, through a Web service, and so on.) However, coding the loop with synchronized blocks would be much more cumbersome than coding it with a volatile status flag as in Listing 2. Because volatile simplifies the coding, and the status flag does not depend on any other state in the program, this is a good use for volatile.

One common characteristic of status flags of this type is that there is typically only one state transition; the shutdownRequested flag goes from false to true and then the program shuts down. This pattern can be extended to state flags that can change back and forth, but only if it is acceptable for a transition cycle (from false to true to false) to go undetected. Otherwise, some sort of atomic state transition mechanism is needed, such as atomic variables.

the "volatile bean" pattern

The volatile bean pattern is applicable in frameworks that use JavaBeans as "glorified structs." In the volatile bean pattern, a JavaBean is used as a container for a group of independent properties with getters and/or setters. The rationale for the volatile bean pattern is that many frameworks provide containers for mutable data holders (for instance, HttpSession), but the objects placed in those containers must be thread safe.

In the volatile bean pattern, all the data members of the JavaBean are volatile, and the getters and setters must be trivial -- they must contain no logic other than getting or setting the appropriate property. Further, for data members that are object references, the referred-to objects must be effectively immutable. (This prohibits having array-valued properties, as when an array reference is declared volatile, only the reference, not the elements themselves, have volatile semantics.) As with any volatile variable, there may be no invariants or constraints involving the properties of the JavaBean. An example of a JavaBean obeying the volatile bean pattern is shown in following example.

A Person object obeying the volatile bean pattern

@ThreadSafe
public class Person {
private volatile String firstName;
private volatile String lastName;
private volatile int age;

public String getFirstName() { return firstName; }
public String getLastName() { return lastName; }
public int getAge() { return age; }

public void setFirstName(String firstName) {
this.firstName = firstName;
}

public void setLastName(String lastName) {
this.lastName = lastName;
}

public void setAge(int age) {
this.age = age;
}
}

Volatile variables are a simpler -- but weaker -- form of synchronization than locking, which in some cases offers better performance or scalability than intrinsic locking. If you follow the conditions for using volatile safely -- that the variable is truly independent of both other variables and its own prior values -- you can sometimes simplify code by using volatile instead of synchronized. However, code using volatile is often more fragile than code using locking. The patterns offered here cover the most common cases where volatile is a sensible alternative to synchronized. Following these patterns -- taking care not to push them beyond their limits -- should help you safely cover the majority of cases where volatile variables are a win.

Java 5 Atomicity

The volatile cannot be used for thread-safe counters due to the fact that "Volatile can write to the variable do not depend on its current value". While the increment operation (x++) may look like a single operation, it is really a compound read-modify-write sequence of operations that must execute atomically -- and volatile does not provide the necessary atomicity. Correct operation would require that the value of x stay unchanged for the duration of the operation, which cannot be achieved using volatile variables.

JDK 5 enables this by providing new package java.util.concurrent.atomic.This is a small toolkit of classes that support lock-free thread-safe programming on single variables.

This package comprises of classes -AtomicInteger; AtomicLong; AtomicReference; AtomicBoolean; array forms of atomic integer; long; reference; and atomic marked reference and stamped reference classes, which atomically update a pair of values.

Following example illustrates how to use AtomicInteger for any CAS operations

package org.nava.jfive.concurrent;

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomicOperation {
private AtomicInteger value;

public static void main(String[] args) {
MyAtomicOperation myOp=new MyAtomicOperation();
myOp.setValue(new AtomicInteger(10));
TestThread tt1=new TestThread(myOp);
TestThread tt2=new TestThread(myOp);
tt1.start();
tt2.start();
}


public AtomicInteger getValue() {
return value;
}

public void setValue(AtomicInteger value) {
this.value = value;
}

}

class TestThread extends Thread {

MyAtomicOperation myOp;

public void run(){
int test=myOp.getValue().incrementAndGet();
System.out.println(Thread.currentThread().getName()+"|"+test);
}
public TestThread(MyAtomicOperation myOp) {
super();
this.myOp = myOp;
}

}


InfoQ

http://www.infoq.com/

Tracking change and innovation in the enterprise software development community

New thoughts on Build Mechanism!

ANT looks like default choice for any java project build. However we do see couple of disadvantages of using XML based scripting tool. The XML scripts have error-prone syntaxes as well as the declarative nature is not as sweet as any traditional programming languages.

So, what are the other alternatives available today?

1. Maven
Apache project. Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project's build, reporting and documentation from a central piece of information.

http://maven.apache.org/

2. Rake
Rake is task based (similar to ANT) build mechanism using Ruby. Though it does not have many pre-defined task as that of Ant, the people who already using ruby would find it more comfortable. Above all it provides plain english-like scripting syntaxes

3. Raven
This is infact based on Rake and uses Ruby scripting. To make the life of Java developers easier, Raven adds a set of predefined tasks that implement the most common needs for a Java build system, like compiling or resolving jar dependencies. Just like a library, but instead of being a set of classes and methods, it's a set of reusable tasks that are well-suited for Java builds.

Infact, Raven packaged with JRuby (a Ruby interpreter written in Java),

http://raven.rubyforge.org/

4. Antwrap

Invoking existing Ant tasks(defined in XML) along with Raven (ruby build scripts)

Antwrap is a Ruby library that can be used to invoke Ant tasks.Antwrap runs on both the native Ruby and the JRuby interpreters. Antwrap is compatible with Ant versions 1.5.4, 1.6.5 and 1.7.0. It lets you reuse all existing Ant tasks that have already been created, but with a much nicer syntax than XML. So, you could use Raven for everything that's already included and Antwrap when an existing Ant task does what you're looking for, all within the same script.

http://antwrap.rubyforge.org/


5. Buildr
Buildr is a build system for Java applications.It's an Apache Incubator project and completely overlaps with Raven and thus based on Ruby Rake.(on Ruby scripting)

Fast; Reliable; Full of Ruby; Easier Dependency Injection-build only what is changed; All Unit Test support;Library tasks equivalent to Ant- Anything you do with Ant can do with Buildr.

http://incubator.apache.org/buildr/

Is Buildr future of Java Builds?

Confluence - Enterprise Wiki

Confluence is enterprise-class WIKI solution.

A wiki is a simple, practical web application
that makes it easy for you and your
teammates to collaborate and manage
knowledge. With a wiki, your team can:
• share, manage, and comment on
information
• easily make edits that update instantly
• track every change or rollback to a
previous version
• access content securely anytime from
anywhere through a browser
• find information quickly, unlike emails.

Developed and promoted by Atlassian and costs around $1200 for minmum license

Features:

Pages: Easy to create, easy to edit, easy to organise.
Spaces: Discrete areas for different groups or projects.
News: Share timely information in notices, bulletins, and blogs.
Mail: Archive and index team email conversations.
Attachments: Attach, track and search all file types.
Comments: Turn any page into a team discussion.
Organisation: Flexible page structures, cross reference, index,
search…hierarchify!
Search: Everything is searchable. Pages, attachments,
comments…everything.
Images: Display images, diagrams, mind maps and more.
Links: Connect, cross-reference.
Administration: Powerful, simple admin. No geniuses required.
Security: Enterprise-grade permissioning and control.
Openness: Plays well with others via SOAP and XML-RPC.
Integration: From daily workflow tools to enterprise systems,
customise and fit your needs.
RSS: Produce and consume RSS newsfeeds.
Plugins: Just a wiki? No, an application platform.
Polish: Not just a pretty face. It works well. It feels right.

Pega Rules Process Commander - PRPC

www.pega.com

Byte Circle

Interesting math operations on byte to illustrate the binary computation


byte x=64;
byte y=3;
byte z= (byte)(x*y);
System.out.print(z);

Output:
if y=1,z -> 64
y=2, z-> -128
y=3, z-> -64
y=4, z -> 0
y=5, z-> 64



Check the following bit circle for more ...

When does static block executed?

The static blocks are executed as soon as the class is loaded whereas the instance blocks are executed when the object is instantiated(just before the constructor)


public class Jan2b {
static int i;
static {
out.println("The static i value@static block:"+i);
}
{
out.println("The static i value@instance block:"+i);
}

Jan2b(){
out.println("The static i value@constructor block:"+i);
}

public static void main(String[] args) {
out.println("The static i value@main:"+i);
Jan2b j=new Jan2b();
}
}

Output:

The static i value@static block:0
The static i value@main:0
The static i value@instance block:0
The static i value@constructor block:0



String.intern()

There have been lots of posts regarding String literals and String objects.Yet another one to reveal some more depth.

We knew the String literals first lookup to String constant pool if it exists, before actually creating a new instance whereas string object creation with "new" always creates a new String and add that to the string constant pool.

So, how can we force the String objects created with "new" to lookup to Constant pool before actually creating new instance?

There comes the native method intern

The source comment says...


/**
* Searches an internal table of strings for a string equal to this String.
* If the string is not in the table, it is added. Answers the string contained
* in the table which is equal to this String. The same string object is always
* answered for strings which are equal.
*
* @return the interned string equal to this String
*/

public native String intern();



This can be illustrated via following example,

String s="TEST";
String t="TEST";
String k=new String("TEST").intern();
String p=new String("TEST");
if(s==t)
out.println("s=t");
if(s==k && k==t)
out.println("s=k & k=t");
if(s==p || t==p)
out.println("s=p Or t=p");

if(p==k)
out.println("p=k");

Output:
s=t
s=k & k=t


This shows, the String objects created with explicit "new" does not lookup the String constant pool unless specified as intern!

String Literal (String a="string") & String Object (String a=new String("string"))

Are both String literal & String Object eligible for garbage collection.

Check the below class operating both on String literal and String object.


class GC{
public static void main(String args[]) {
String str1 = "abc";
String str2 = new String("abc");

str1=str2=null;
}
}

Only one Object is eligible for GC.
Reason:
In the above code,
1. String1 is the String literal. (this is also object )
2.String2 is the Object.

3. When ever you create a String by using
String str1 = "abc";
Str1 is going to store in Heap Memory.
Str1 is referencing to the String Constant pool.

4. String str2 = new String("abc") is not referencing to the String constant pool.

5. so, when ever we make that strings as null, then
str1=str2=null;

6. Both the string will be null.
7. String2 is eligible to GC, because String1 is still has a reference in String constant pool
8. So, what ever may be the string which has a reference to String constant pool, is
not eligible for GC.

Thus String literals are not eligible for GC.