If you ever wanted to use XML with Java for whatever be the reason, first check this out.
http://xstream.codehaus.org/tutorial.html
Monday, December 31, 2007
NaN in Double!
From source code, the definition of NaN is
From JLS & API doc:
Note that in most cases, for two instances of class Double, d1 and d2,
the value of d1.equals(d2) is true if and only if
d1.doubleValue() == d2.doubleValue()also has the value true.
However, there are two exceptions:
If d1 and d2 both represent Double.NaN, then the equals method returns true, even though Double.NaN==Double.NaN has the value false.
If d1 represents +0.0 while d2 represents -0.0, or vice versa, the equal test has the value false, even though +0.0==-0.0 has the value true.
This definition allows hash tables to operate properly.
/**
* A constant holding a Not-a-Number (NaN) value of type
* double. It is equivalent to the value returned by
* Double.longBitsToDouble(0x7ff8000000000000L).
*/
public static final double NaN = 0.0d / 0.0;
From JLS & API doc:
Note that in most cases, for two instances of class Double, d1 and d2,
the value of d1.equals(d2) is true if and only if
d1.doubleValue() == d2.doubleValue()also has the value true.
However, there are two exceptions:
If d1 and d2 both represent Double.NaN, then the equals method returns true, even though Double.NaN==Double.NaN has the value false.
If d1 represents +0.0 while d2 represents -0.0, or vice versa, the equal test has the value false, even though +0.0==-0.0 has the value true.
This definition allows hash tables to operate properly.
Why static methods can't be abstract?
An abstract method requires implementation per instance. Static methods pertain to an overall class. A static method in an abstract class belongs to the abstract class, not potential implementations. It therefore doesn't make any sense to allow abstract static methods. Furthermore, static methods cannot be overridden, so again, abstract static methods would be an anomaly.
Sunday, December 30, 2007
EHCache - Where to cache other than Http Session?
Whats it?
Ehcache is a widely used java distributed cache for general purpose caching, Java EE and light-weight containers.
It features memory and disk stores, replicate by copy and invalidate, listeners, cache loaders, cache extensions, cache exception handlers, a gzip caching servlet filter and much more.
Ehcache is available under an Apache open source licence and is actively developed, maintained and supported.
Who is using?
Alfresco An Enterprise Content Management system
Cocoon. A web development framework.
Hibernate. An O/R mapping tool.
Spring. An IOC framework from Rod Johnson.
JPOX. A Java Persistent Objects frameworkd and JDO implementation.
Jofti. A cached object indexing and searching system.
Acegi. A security system for Spring.
Kosmos. Kosmos stands for Komposite Open Source Monitoring Suite..
Tudu Lists. Online list management.
Lutece. Lutece is an Open Source Java/ XML portal.
How to use?
//Get CacheManager through config
URL url = getClass().getResource("/anotherconfigurationname.xml");
CacheManager manager = new CacheManager(url);
CacheManager manager = new CacheManager("src/config/ehcache.xml");
//GetSingleton CacheManager
CacheManager singletonManager = CacheManager.create();
//Add Cache
singletonManager.addCache("testCache");
Cache test = singletonManager.getCache("testCache");
//Add Elements
Element element = new Element("key1", "value1");
test.put(element);
//Remove Cache
singletonManager.removeCache("testCache");
//Shutdown
CacheManager.getInstance().shutdown();
manager.shutdown();
More Info :
Thursday, December 27, 2007
Spring Transaction Management Example!
The service layer handles the business logic & DML actions on Entities.
The service methods are executed through Transaction proxies in order to manage the transaction.In other words,the Transaction Proxy wraps the execution of each transactional[which inserts/updates/deletes] service methods.
The Transaction Proxy is configured with TransactionInterceptor,TransactionManager and TransactionAttributes.
Transaction Attributes [REQUIRED,REQUIRED_NEW,SUPPORTS etc] tells us how the transaction to be handled.
The actual transaction[manage DB connection, execute actual JDBC, commit/rollback] is handled by Transaction Manager which is configured with Datasource.
The transaction proxy is in turn wrapped with Transaction Interceptor. This interceptor uses the Transaction Attributes and Transaction Manager to fulfill the transaction.
The Transaction Interceptor can be accompanied by one or more Pre and/or Post Interceptors.
The PreInterceptors wraps the TransactionInterceptor and therefore they are outside of transaction boundry.There can be one or more preInterceptors and they are executed in sequence as configured in chain.
The PostInterceptors are inside the TransactionInterceptor and they are executed one by one as configured in list.
After execution of all Post interceptors, the actual method implementation of the target object is execcuted.
Example Illustration:
The client[web layer] invokes service methods[which are transactional] as below.
Here the service methods of IUserMaintService is configured on top of TransactionProxy [org.springframework.transaction.interceptor.TransactionProxyFactoryBean],
When a service method 'insertUser' is called, it executes the pre Interceptors if anything configured and then the transactionInterceptor.invoke method which in turn verifies the transaction attributes and create a transaction if required. This is the starting point of transaction boundary.After this, the sequence of post interceptors are getting executed and finally folowed by the 'TARGET implementation' method execution.
org.springframework.transaction.interceptor.TransactionProxyFactoryBean is configured with
-PreInterceptors org.springframework.transaction.interceptor.TransactionInterceptor --uses---->org.springframework.jdbc.datasource.DataSourceTransactionManager and org.springframework.transaction.interceptor.TransactionAttribute -PostInterceptors
-Actual Method Execution
The service methods are executed through Transaction proxies in order to manage the transaction.In other words,the Transaction Proxy wraps the execution of each transactional[which inserts/updates/deletes] service methods.
The Transaction Proxy is configured with TransactionInterceptor,TransactionManager and TransactionAttributes.
Transaction Attributes [REQUIRED,REQUIRED_NEW,SUPPORTS etc] tells us how the transaction to be handled.
The actual transaction[manage DB connection, execute actual JDBC, commit/rollback] is handled by Transaction Manager which is configured with Datasource.
The transaction proxy is in turn wrapped with Transaction Interceptor. This interceptor uses the Transaction Attributes and Transaction Manager to fulfill the transaction.
The Transaction Interceptor can be accompanied by one or more Pre and/or Post Interceptors.
The PreInterceptors wraps the TransactionInterceptor and therefore they are outside of transaction boundry.There can be one or more preInterceptors and they are executed in sequence as configured in chain.
The PostInterceptors are inside the TransactionInterceptor and they are executed one by one as configured in list.
After execution of all Post interceptors, the actual method implementation of the target object is execcuted.
Example Illustration:
The client[web layer] invokes service methods[which are transactional] as below.
//Find service bean through BeanFactory
IUserMaintService userService=ServiceFactory.getUserMaintService();
userService.insertUser(new User());
Here the service methods of IUserMaintService is configured on top of TransactionProxy [org.springframework.transaction.interceptor.TransactionProxyFactoryBean],
When a service method 'insertUser' is called, it executes the pre Interceptors if anything configured and then the transactionInterceptor.invoke method which in turn verifies the transaction attributes and create a transaction if required. This is the starting point of transaction boundary.After this, the sequence of post interceptors are getting executed and finally folowed by the 'TARGET implementation' method execution.
org.springframework.transaction.interceptor.TransactionProxyFactoryBean is configured with
-PreInterceptors org.springframework.transaction.interceptor.TransactionInterceptor --uses---->org.springframework.jdbc.datasource.DataSourceTransactionManager and org.springframework.transaction.interceptor.TransactionAttribute -PostInterceptors
-Actual Method Execution
Dynamic Proxy!
The Proxy pattern is one of the most important design patterns because it provides an alternative to extending functionality with inheritance. That alternative is object composition, where an object (proxy) forwards method calls to an enclosed object (real subject).
Object composition is preferable to inheritance because, with composition, enclosing objects can only manipulate their enclosed object through the enclosed object's interface, which results in loose coupling between objects. In contrast, with inheritance, classes are tightly coupled to their base class because the internals of a base class are visible to its extensions.
Because of that visibility, inheritance is often referred to as white-box reuse. On the other hand, with composition, the internals of the enclosing object are not visible to the enclosed object (and vice-versa); therefore, composition is often referred to as black-box reuse. All things being equal, black-box reuse (composition) is preferable to white-box reuse (inheritance) because loose coupling results in more malleable and flexible systems.
Because the Proxy pattern is so important, J2SE 1.3 (Java 2 Platform, Standard Edition) and beyond directly supports it. That support involves three classes from the java.lang.reflect package: Proxy, Method, and InvocationHandler.
Some basic concepts of Proxy class
> Proxy classes are public, final, and not abstract.
> The unqualified name of a proxy class is unspecified. The space of class names that begin with the string "$Proxy" should be, however, reserved for proxy classes.
> A proxy class extends java.lang.reflect.Proxy.
> A proxy class implements exactly the interfaces specified at its creation, in the same order.
> If a proxy class implements a non-public interface, then it will be defined in the same package as that interface. Otherwise, the package of a proxy class is also unspecified. Note that package sealing will not prevent a proxy class from being successfully defined in a particular package at runtime, and neither will classes already defined in the same class loader and the same package with particular signers.
> Since a proxy class implements all of the interfaces specified at its creation, invoking getInterfaces on its Class object will return an array containing the same list of interfaces (in the order specified at its creation), invoking getMethods on its Class object will return an array of Method objects that include all of the methods in those interfaces, and invoking getMethod will find methods in the proxy interfaces as would be expected.
> The Proxy.isProxyClass method will return true if it is passed a proxy class-- a class returned by Proxy.getProxyClass or the class of an object returned by Proxy.newProxyInstance-- and false otherwise.
> The java.security.ProtectionDomain of a proxy class is the same as that of system classes loaded by the bootstrap class loader, such as java.lang.Object, because the code for a proxy class is generated by trusted system code. This protection domain will typically be granted java.security.AllPermission.
> Each proxy class has one public constructor that takes one argument, an implementation of the interface InvocationHandler, to set the invocation handler for a proxy instance. Rather than having to use the reflection API to access the public constructor, a proxy instance can be also be created by calling the Proxy.newInstance method, which combines the actions of calling Proxy.getProxyClass with invoking the constructor with an invocation handler.
> A proxy instance has the following properties:
Given a proxy instance proxy and one of the interfaces implemented by its proxy class Foo, the following expression will return true:
proxy instanceof Foo
and the following cast operation will succeed (rather than throwing a ClassCastException):
(Foo) proxy
>Each proxy instance has an associated invocation handler, the one that was passed to its constructor. The static Proxy.getInvocationHandler method will return the invocation handler associated with the proxy instance passed as its argument.
>An interface method invocation on a proxy instance will be encoded and dispatched to the invocation handler's invoke method as described in the documentation for that method.
>An invocation of the hashCode, equals, or toString methods declared in java.lang.Object on a proxy instance will be encoded and dispatched to the invocation handler's invoke method in the same manner as interface method invocations are encoded and dispatched, as described above. The declaring class of the Method object passed to invoke will be java.lang.Object. Other public methods of a proxy instance inherited from java.lang.Object are not overridden by a proxy class, so invocations of those methods behave like they do for instances of java.lang.Object.
Below example shows a simple example that utilizes the JDK support for the Proxy pattern:
JDK proxies
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface AnInterface {
public void doSomething();
}
class AClass implements AnInterface {
public void doSomething() {
System.out.println("Inside Method AClass.doSomething()");
}
}
public class Test {
public static void main(String args[]) {
AnInterface realSubject = new AClass();
AnInterface proxy = (AnInterface)Proxy.newProxyInstance(
realSubject.getClass().getClassLoader(),realSubject.getClass().getInterfaces(),
new SimpleInvocationHandler(realSubject));
passMeAProxy(proxy);
}
private static void passMeAProxy(AnInterface anInterface) {
anInterface.doSomething();
}
}
class SimpleInvocationHandler implements InvocationHandler {
public SimpleInvocationHandler(Object realSubject) {
this.realSubject = realSubject;
}
public Object invoke(Object proxy, Method m, Object[] args){
Object result = null;
System.out.println("Before Calling " + m.getName());
try {
result = m.invoke(realSubject, args);
}
catch(Exception ex) {
System.exit(1);
}
System.out.println("After Calling " + m.getName());
return result;
}
private Object realSubject = null;
}
In the preceding example, the static Proxy.newProxyInstance() method creates a proxy for a real subject. Real subjects must implement one or more interfaces, and a reference to a proxy can be passed to any method that expects a reference to one of those interfaces. The main() method passes the proxy to a method that takes a reference to AnInterface, just to prove it can be done. In the preceding example, our simple proxy implements only one interface.
Proxy.newProxyInstance() takes three arguments: the class loader that loaded the real subject, a list of interfaces implemented by the real subject, and a reference to an invocation handler.
Every time you invoke a proxy's method, the proxy calls its invocation handler's invoke() method. The proxy passes itself to the invoke() method, along with a reference to the proxy's method and its list of arguments. In the preceding code, SimpleInvocationHandler.invoke() invokes the specified method on the real subject. Here's the output of the application listed in
Example
Before Calling doSomething
Inside Method AClass.doSomething()
After Calling doSomething
Proxy applicability
The Proxy pattern applies whenever you need to control access to an object. The most common situations include:
1.Remote proxies
2.Virtual proxies
3.Protection proxies - Security Authentication/Authorization
Remote proxies control access to remote objects, such as the Web service proxy.
Virtual proxies - control access to resources that are expensive to create, such as large images.
Protection proxies control what functionality specific users can access.
Classes that implement stable interfaces with few methods are the best candidates for a proxy's real subject because their proxies are easy to implement and maintain.TheJDK's built-in Proxy pattern support makes it much easier to implement proxies whose real subjects have a large number of methods.
Then whats the difference between the Decorator and Proxy patterns. Although you implement both patterns in an almost identical fashion, it's the intent of those patterns that differs. The Decorator pattern constructs objects at runtime by recursively enclosing an object within one or more decorators. The Proxy pattern acts as a stand-in for a real subject, which is set at compile time.
Dynamic Proxies with Spring
Dynamic proxies are extensively supported in Spring framework for following things
Spring AOP [Aspect Oriented Programming] - Interceptors - MethodInvocation is based on Dynamic Proxy
Spring Transaction Management [through TransactionProxyFactoryBean]
Easy Mock with Dynamic Proxy
Easy Mock - Creating mock objects for interfaces & classes for unit testing - creates mock objects using dynamic proxies
lot more .....
another custom example...
package org.nava.jfive.reflect;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Calendar;
/**
* Client for testing
*/
public class Dec27 {
public static void main(String[] args) {
ITest realSubject = new TestImpl();
ITest proxy = (ITest)Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),
realSubject.getClass().getInterfaces(),new TestHandler(realSubject));
proxy.setMe((proxy instanceof Proxy)?"is Proxy instance":"is not proxy instance");
System.out.println("The Result of 'me':"+proxy.getMe());
}
}
/**
* Inteface for Test
*/
interface ITest {
String getMe();
void setMe(String s);
}
/**
* Concreate Implementation for Inteface ITest
*/
class TestImpl implements ITest{
private String me_;
public String getMe() {
return me_;
}
public void setMe(String s) {
me_="The "+ s+" and the real object is :"+this.getClass().getSimpleName();
}
}
/**
* InvocationHandler for Test Proxy
*
*/
class TestHandler implements InvocationHandler{
private Object realSubject = null;
public TestHandler() {
super();
}
public TestHandler(Object real) {
this.realSubject=real;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
System.out.println("---------------------------------------------");
System.out.println("Is Proxy instance of TestImpl:"+(proxy instanceof TestImpl));
System.out.println("Is Proxy instance of ITest:"+(proxy instanceof ITest));
System.out.println("Is Proxy instance of Object:"+(proxy instanceof Object));
System.out.println("Is Proxy instance of Proxy:"+(proxy instanceof Proxy));
System.out.println(Calendar.getInstance().getTime()+" Before Calling " + method.getName());
try {
result = method.invoke(realSubject, args);
}catch(Exception ex) {
System.exit(1);
}
System.out.println(Calendar.getInstance().getTime()+"After Calling " + method.getName());
return result;
}
}
Wednesday, December 26, 2007
Why identifiers have naming restrictions ?
As per Java Language Specification Lexical Structure .....
An identifier is an unlimited-length sequence of Java letters and Java digits, the first of which must be a Java letter. An identifier cannot have the same spelling (Unicode character sequence) as a keyword (§3.9), boolean literal (§3.10.3), or the null literal (§3.10.7).
Identifier:
IdentifierChars but not a Keyword or BooleanLiteral or NullLiteral
IdentifierChars:
JavaLetter
IdentifierChars JavaLetterOrDigit
JavaLetter:
any Unicode character that is a Java letter (see below)
JavaLetterOrDigit:
any Unicode character that is a Java letter-or-digit (see below)
Letters and digits may be drawn from the entire Unicode character set, which supports most writing scripts in use in the world today, including the large sets for Chinese, Japanese, and Korean. This allows programmers to use identifiers in their programs that are written in their native languages.
A "Java letter" is a character for which the method Character.isJavaIdentifierStart(int) returns true. A "Java letter-or-digit" is a character for which the method Character.isJavaIdentifierPart(int) returns true.
Two identifiers are the same only if they are identical, that is, have the same Unicode character for each letter or digit.
Identifiers that have the same external appearance may yet be different. For example, the identifiers consisting of the single letters LATIN CAPITAL LETTER A (A, \u0041), LATIN SMALL LETTER A (a, \u0061), GREEK CAPITAL LETTER ALPHA (A, \u0391), CYRILLIC SMALL LETTER A (a, \u0430) and MATHEMATICAL BOLD ITALIC SMALL A (a, \ud835\udc82) are all different.
Unicode composite characters are different from the decomposed characters. For example, a LATIN CAPITAL LETTER A ACUTE (Á, \u00c1) could be considered to be the same as a LATIN CAPITAL LETTER A (A, \u0041) immediately followed by a NON-SPACING ACUTE (´, \u0301) when sorting, but these are different in identifiers. See The Unicode Standard, Volume 1, pages 412ff for details about decomposition, and see pages 626-627 of that work for details about sorting.
Examples of identifiers are:
String,i3,MAX_VALUE,isLetterOrDigit
An identifier is an unlimited-length sequence of Java letters and Java digits, the first of which must be a Java letter. An identifier cannot have the same spelling (Unicode character sequence) as a keyword (§3.9), boolean literal (§3.10.3), or the null literal (§3.10.7).
Identifier:
IdentifierChars but not a Keyword or BooleanLiteral or NullLiteral
IdentifierChars:
JavaLetter
IdentifierChars JavaLetterOrDigit
JavaLetter:
any Unicode character that is a Java letter (see below)
JavaLetterOrDigit:
any Unicode character that is a Java letter-or-digit (see below)
Letters and digits may be drawn from the entire Unicode character set, which supports most writing scripts in use in the world today, including the large sets for Chinese, Japanese, and Korean. This allows programmers to use identifiers in their programs that are written in their native languages.
A "Java letter" is a character for which the method Character.isJavaIdentifierStart(int) returns true. A "Java letter-or-digit" is a character for which the method Character.isJavaIdentifierPart(int) returns true.
The Java letters include uppercase and lowercase ASCII Latin letters A-Z (\u0041-\u005a), and a-z (\u0061-\u007a), and, for historical reasons, the ASCII underscore (_, or \u005f) and dollar sign ($, or \u0024). The $ character should be used only in mechanically generated source code or, rarely, to access preexisting names on legacy systems.
The "Java digits" include the ASCII digits 0-9 (\u0030-\u0039).
Two identifiers are the same only if they are identical, that is, have the same Unicode character for each letter or digit.
Identifiers that have the same external appearance may yet be different. For example, the identifiers consisting of the single letters LATIN CAPITAL LETTER A (A, \u0041), LATIN SMALL LETTER A (a, \u0061), GREEK CAPITAL LETTER ALPHA (A, \u0391), CYRILLIC SMALL LETTER A (a, \u0430) and MATHEMATICAL BOLD ITALIC SMALL A (a, \ud835\udc82) are all different.
Unicode composite characters are different from the decomposed characters. For example, a LATIN CAPITAL LETTER A ACUTE (Á, \u00c1) could be considered to be the same as a LATIN CAPITAL LETTER A (A, \u0041) immediately followed by a NON-SPACING ACUTE (´, \u0301) when sorting, but these are different in identifiers. See The Unicode Standard, Volume 1, pages 412ff for details about decomposition, and see pages 626-627 of that work for details about sorting.
Examples of identifiers are:
String,i3,MAX_VALUE,isLetterOrDigit
Is String a keyword ?
Following program works great! know the basics
public class Dec26 {
public static void main(String[] args) {
String String="nambi";
System.out.println(String);
}
}
Nutch - Java Search Engine
What is Nutch?
Nutch is an effort to build a Free and Open Source search engine. It uses Lucene for the search and index component. The fetcher (robot) has been written from scratch solely for this project.
Nutch has a highly modular architecture allowing developers to create plug-ins for activities such as media-type parsing, data retrieval, querying and clustering.
Doug Cutting is the lead developer of Nutch.
What is Lucene?
Lucene is a Free and Open Source search and index API released by the Apache Software Foundation. It is written in Java and is released under the Apache Software License.
Lucene is just the core of a search engine. As such, it does not include things like a web spider or parsers for different document formats. Instead these things need to be added by a developer who uses Lucene.
Lucene does not care about the source of the data, its format, or even its language, as long as you can convert it to text. This means you can use Lucene to index and search data stored in files: web pages on remote web servers, documents stored in local file systems, simple text files, Microsoft Word documents, HTML or PDF files, or any other format from which you can extract textual information.
Lucene has been ported or is in the process of being ported to various programming languages other than Java:
Lucene4c - C
CLucene - C++
MUTIS - Delphi
NLucene - .NET
DotLucene - .NET
Plucene - Perl
Pylucene - Python
Ferret and RubyLucene – Ruby
More ....
http://wiki.apache.org/nutch/Nutch_-_The_Java_Search_Engine
Nutch is an effort to build a Free and Open Source search engine. It uses Lucene for the search and index component. The fetcher (robot) has been written from scratch solely for this project.
Nutch has a highly modular architecture allowing developers to create plug-ins for activities such as media-type parsing, data retrieval, querying and clustering.
Doug Cutting is the lead developer of Nutch.
What is Lucene?
Lucene is a Free and Open Source search and index API released by the Apache Software Foundation. It is written in Java and is released under the Apache Software License.
Lucene is just the core of a search engine. As such, it does not include things like a web spider or parsers for different document formats. Instead these things need to be added by a developer who uses Lucene.
Lucene does not care about the source of the data, its format, or even its language, as long as you can convert it to text. This means you can use Lucene to index and search data stored in files: web pages on remote web servers, documents stored in local file systems, simple text files, Microsoft Word documents, HTML or PDF files, or any other format from which you can extract textual information.
Lucene has been ported or is in the process of being ported to various programming languages other than Java:
Lucene4c - C
CLucene - C++
MUTIS - Delphi
NLucene - .NET
DotLucene - .NET
Plucene - Perl
Pylucene - Python
Ferret and RubyLucene – Ruby
More ....
http://wiki.apache.org/nutch/Nutch_-_The_Java_Search_Engine
Unix Simulators in Windows - Cygwin
Cygwin is a Linux-like environment for Windows. It consists of two parts:
1. A DLL (cygwin1.dll) which acts as a Linux API emulation layer providing substantial Linux API functionality.
2. A collection of tools which provide Linux look and feel.
More....
http://www.cygwin.com/
1. A DLL (cygwin1.dll) which acts as a Linux API emulation layer providing substantial Linux API functionality.
2. A collection of tools which provide Linux look and feel.
More....
http://www.cygwin.com/
Unix - List File & Parse File name
Requirement:
Find list of files in current directory and parse the file names to decipher which program to execute
Find list of files in current directory and parse the file names to decipher which program to execute
#!/usr/bin/ksh
echo 'Nambi'
#To find files with "text" in all sub directories from current
#find . -type f -name "text" -print| while read obj
#To find ALL files in all sub directories from current
#find . -type f -print| while read obj
#Just files in current directory
ls -1 | while read fname
do
echo 'File name:'$fname
#Parse file name to get specific output
#echo $fname | cut -c-3
l=`echo $fname | cut -c2-4`
echo $l
done
echo 'End'
Tuesday, December 25, 2007
Rich Domain || Fat Service?
THIS is been discussed in almost all multi-layered application architectures where to put most of the business logic, whether its in domain or in service. More than 80%of the time you can expect it should be a service layers due to various advocations.
This post try to throw some basic questions that everyone should consider ...
1.Is domain just a entity? Or it accompanies the domain service & value objects?
2.Can domain access other service layers? If so, hwo much can you perform unit testing?
3.How much DAO can co-hesive with domain?
4.Where to perform domain validation...is it a domain behaviour or domain service job?
5.Can you instantiate any other domains directly from domain behaviours?
6.How far we can use static in domain? Is it a good practice from unit test perspective?
7.Can a domain have additional behaviours apart from getters/setters of its state?
...of course lot more ... .
This post try to throw some basic questions that everyone should consider ...
1.Is domain just a entity? Or it accompanies the domain service & value objects?
2.Can domain access other service layers? If so, hwo much can you perform unit testing?
3.How much DAO can co-hesive with domain?
4.Where to perform domain validation...is it a domain behaviour or domain service job?
5.Can you instantiate any other domains directly from domain behaviours?
6.How far we can use static in domain? Is it a good practice from unit test perspective?
7.Can a domain have additional behaviours apart from getters/setters of its state?
...of course lot more ... .
Sunday, December 23, 2007
Avoid your IP stolen through Java Decompilers!
How to protect you Intellectual Property of java source code[even in compiled format] in a way that cannot be deompiled fully and stolen
As an example, do not provide your build compiled with debug options. Class files compiled with debug options provides more info on bytecode which facilitates easy decompilation
As an example, do not provide your build compiled with debug options. Class files compiled with debug options provides more info on bytecode which facilitates easy decompilation
Friday, December 21, 2007
Java Caching Services!
JavaSpaces, including Gigaspaces and Blitz.
Declarative caching services including EHCache, JCS, OSCache, GigaSpaces
Declarative caching services including EHCache, JCS, OSCache, GigaSpaces
Thursday, December 20, 2007
Wednesday, December 19, 2007
Jasper Reports!
Reporting is always been a necessary feature of any Enterprise organization. Around 20-30% of software applications certainly include basic to advanced reporting.
There are plenty of utilities available to make reporting easy to integrate with any enterprise architecture.
The default choice of reporting tech has been the 'Crystal Reports' especially when microsoft bundled the product with Visual Studio. The Crystal Reports are marked by Business Objects[now acquired by SAP] and costs around $500 per license.
Jasper Reports comes as a Savior of OPEN source equally comprising all features of commerial products and well integrates with Java with good community participation.
JasperReports provides the necessary features to generate dynamic reports, including data retrieval using JDBC (Java Database Connectivity), as well as support for parameters, expressions, variables, and groups. JasperReports also includes advanced features, such as custom data sources, scriptlets, and subreports.
There have been plenty of releases and the current version is 2.0
Lets look at basic architecture and how to generate a simple report with Jasper.
Basic Objects of Jasper:
JasperDesign: Represents a report's definition. In most cases, you create a JasperDesign from an XML report template, though you can also create it programmatically.
JasperReport: Represents a compiled JasperDesign. The compilation process verifies the report design and compiles the design into a JasperReport object.
JasperPrint: Represents a generated report. You create a JasperPrint from a JasperReport through the fill process in which a report is populated with data from a data source.
JasperManager:
The JasperReports API's flexibility lets you load JasperDesign, JasperReport, and JasperPrint objects from a file or a stream, and also lets you create these objects programmatically. You can print reports to a printer, an image, or a PDF file. The JasperReports library includes a facade class, dori.jasper.engine.JasperManager, with methods that facilitate loading, compiling, filling, and printing reports.
Generating basic Report:
Another way to build report..
Sample JRML file
There are plenty of utilities available to make reporting easy to integrate with any enterprise architecture.
The default choice of reporting tech has been the 'Crystal Reports' especially when microsoft bundled the product with Visual Studio. The Crystal Reports are marked by Business Objects[now acquired by SAP] and costs around $500 per license.
Jasper Reports comes as a Savior of OPEN source equally comprising all features of commerial products and well integrates with Java with good community participation.
JasperReports provides the necessary features to generate dynamic reports, including data retrieval using JDBC (Java Database Connectivity), as well as support for parameters, expressions, variables, and groups. JasperReports also includes advanced features, such as custom data sources, scriptlets, and subreports.
There have been plenty of releases and the current version is 2.0
Lets look at basic architecture and how to generate a simple report with Jasper.
Basic Objects of Jasper:
JasperDesign: Represents a report's definition. In most cases, you create a JasperDesign from an XML report template, though you can also create it programmatically.
JasperReport: Represents a compiled JasperDesign. The compilation process verifies the report design and compiles the design into a JasperReport object.
JasperPrint: Represents a generated report. You create a JasperPrint from a JasperReport through the fill process in which a report is populated with data from a data source.
JasperManager:
The JasperReports API's flexibility lets you load JasperDesign, JasperReport, and JasperPrint objects from a file or a stream, and also lets you create these objects programmatically. You can print reports to a printer, an image, or a PDF file. The JasperReports library includes a facade class, dori.jasper.engine.JasperManager, with methods that facilitate loading, compiling, filling, and printing reports.
Generating basic Report:
// First, load JasperDesign from XML and compile it into JasperReport
JasperDesign jasperDesign = JasperManager.loadXmlDesign("BasicReport.xml");
JasperReport jasperReport = JasperManager.compileReport(jasperDesign);
// Second, create a map of parameters to pass to the report.
Map parameters = new HashMap();
parameters.put("ReportTitle", "Basic JasperReport");
parameters.put("MaxSalary", new Double(25000.00));
// Third, get a database connection
Connection conn = Database.getConnection();
// Fourth, create JasperPrint using fillReport() method
JasperPrint jasperPrint = JasperManager.fillReport(jasperReport,
parameters, conn);
// You can use JasperPrint to create PDF
JasperManager.printReportToPdfFile(jasperPrint, "BasicReport.pdf");
// Or to view report in the JasperViewer
JasperViewer.viewReport(jasperPrint);
Another way to build report..
//Get the JRXML file
String fileName = lookUp(module);
InputStream templatesAsStream = loadTemplateAsStream(fileName);
JasperReport jasperReport = JasperCompileManager.compileReport(templatesAsStream);
JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport,
builder.build(object), new JREmptyDataSource());
byte[] bytes = JasperExportManager.exportReportToPdf(jasperPrint);
Sample JRML file
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jasperReport PUBLIC "-//JasperReports//DTD Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">
<jasperReport name="BasicReport" >
<parameter name="Title" class="java.lang.String"/>
<queryString><![CDATA[select name, cost from product]]></queryString>
<field name="NAME" class="java.lang.String"/>
<field name="COST" class="java.lang.Double"/>
<title>
<band height="50">
<textField>
<reportElement x="0" y="0" width="200" height="50" />
<textFieldExpression class="java.lang.String">$P{Title}</textFieldExpression>
</textField>
</band>
</title>
<pageHeader>
<band>
</band>
</pageHeader>
<columnHeader>
<band height="20">
<staticText>
<reportElement x="180" y="0" width="180" height="20"/>
<textElement>
<font isUnderline="true"/>
</textElement>
<text><![CDATA[NAME]]></text>
</staticText>
<staticText>
<reportElement x="360" y="0" width="180" height="20"/>
<textElement>
<font isUnderline="true"/>
</textElement>
<text><![CDATA[COST]]></text>
</staticText>
</band>
</columnHeader>
<detail>
<band height="20">
<textField>
<reportElement x="180" y="0" width="180" height="20"/>
<textFieldExpression class="java.lang.String"><![CDATA[$F{NAME}]]></textFieldExpression>
</textField>
<textField pattern="0.00">
<reportElement x="360" y="0" width="180" height="20"/>
<textFieldExpression class="java.lang.Double"><![CDATA[$F{COST}]]></textFieldExpression>
</textField>
</band>
</detail>
<columnFooter>
<band>
</band>
</columnFooter>
<pageFooter>
<band height="15">
<staticText>
<reportElement x="0" y="0" width="40" height="15"/>
<textElement/>
<text><![CDATA[Page:]]></text>
</staticText>
<textField>
<reportElement x="40" y="0" width="100" height="15"/>
<textElement/>
<textFieldExpression class="java.lang.Integer"><![CDATA[$V{PAGE_NUMBER}]]></textFieldExpression>
</textField>
</band>
</pageFooter>
<summary>
<band>
</band>
</summary>
</jasperReport>
More intro...
http://www.jasperforge.org/jaspersoft/opensource/business_intelligence/jasperreports/
Wednesday, December 12, 2007
JPA with Hibernat
http://www.developer.com/java/ent/article.php/10933_3577101_1
http://www.onjava.com/pub/a/onjava/2007/02/08/an-introduction-to-hibernate-3-annotations.html
more on
http://www.i-proving.ca/space/Technologies/Hibernate/Hibernate+Annotation+Examples/Collection+of+Elements
http://www.javakaffee.de/blog/2006/11/28/hibernate-annotation-for-a-map-of-some-enum-type-to-some-primitive-type/
http://www.onjava.com/pub/a/onjava/2007/02/08/an-introduction-to-hibernate-3-annotations.html
more on
http://www.i-proving.ca/space/Technologies/Hibernate/Hibernate+Annotation+Examples/Collection+of+Elements
http://www.javakaffee.de/blog/2006/11/28/hibernate-annotation-for-a-map-of-some-enum-type-to-some-primitive-type/
Friday, December 7, 2007
Java Script Engine in JSDK6
Whats it?
The scripting API consists of interfaces and classes that define Java TM Scripting Engines and provides a framework for their use in Java applications. This API is intended for use by application programmers who wish to execute programs written in scripting languages in their Java applications. The scripting language programs are usually provided by the end-users of the applications.
The main areas of functionality of javax.script package include
Script execution: Scripts are streams of characters used as sources for programs executed by script engines. Script execution uses eval methods of ScriptEngine and methods of the Invocable interface.
Binding: This facility allows Java objects to be exposed to script programs as named variables. Bindings and ScriptContext classes are used for this purpose.
Compilation: This functionality allows the intermediate code generated by the front-end of a script engine to be stored and executed repeatedly. This benefits applications that execute the same script multiple times. These applications can gain efficiency since the engines' front-ends only need to execute once per script rather than once per script execution. Note that this functionality is optional and script engines may choose not to implement it. Callers need to check for availability of the Compilable interface using an instanceof check.
Invocation: This functionality allows the reuse of intermediate code generated by a script engine's front-end. Whereas Compilation allows entire scripts represented by intermediate code to be re-executed, Invocation functionality allows individual procedures/methods in the scripts to be re-executed. As in the case with compilation, not all script engines are required to provide this facility. Caller has to check for Invocable availability.
Script engine discovery and Metadata: Applications written to the Scripting API might have specific requirements on script engines. Some may require a specific scripting language and/or version while others may require a specific implementation engine and/or version. Script engines are packaged in a specified way so that engines can be discovered at runtime and queried for attributes. The Engine discovery mechanism is based on the Service discovery mechanism described in the Jar File Specification. Script engine implementing classes are packaged in jar files that include a text resource named META-INF/services/javax.script.ScriptEngineFactory. This resource must include a line for each ScriptEngineFactory that is packaged in the jar file. ScriptEngineManager includes getEngineFactories method to get all ScriptEngineFactory instances discovered using this mechanism. ScriptEngineFactory has methods to query attributes about script engine.
The scripting API consists of interfaces and classes that define Java TM Scripting Engines and provides a framework for their use in Java applications. This API is intended for use by application programmers who wish to execute programs written in scripting languages in their Java applications. The scripting language programs are usually provided by the end-users of the applications.
The main areas of functionality of javax.script package include
Script execution: Scripts are streams of characters used as sources for programs executed by script engines. Script execution uses eval methods of ScriptEngine and methods of the Invocable interface.
Binding: This facility allows Java objects to be exposed to script programs as named variables. Bindings and ScriptContext classes are used for this purpose.
Compilation: This functionality allows the intermediate code generated by the front-end of a script engine to be stored and executed repeatedly. This benefits applications that execute the same script multiple times. These applications can gain efficiency since the engines' front-ends only need to execute once per script rather than once per script execution. Note that this functionality is optional and script engines may choose not to implement it. Callers need to check for availability of the Compilable interface using an instanceof check.
Invocation: This functionality allows the reuse of intermediate code generated by a script engine's front-end. Whereas Compilation allows entire scripts represented by intermediate code to be re-executed, Invocation functionality allows individual procedures/methods in the scripts to be re-executed. As in the case with compilation, not all script engines are required to provide this facility. Caller has to check for Invocable availability.
Script engine discovery and Metadata: Applications written to the Scripting API might have specific requirements on script engines. Some may require a specific scripting language and/or version while others may require a specific implementation engine and/or version. Script engines are packaged in a specified way so that engines can be discovered at runtime and queried for attributes. The Engine discovery mechanism is based on the Service discovery mechanism described in the Jar File Specification. Script engine implementing classes are packaged in jar files that include a text resource named META-INF/services/javax.script.ScriptEngineFactory. This resource must include a line for each ScriptEngineFactory that is packaged in the jar file. ScriptEngineManager includes getEngineFactories method to get all ScriptEngineFactory instances discovered using this mechanism. ScriptEngineFactory has methods to query attributes about script engine.
Bit Shifting!
To shift a number one bit to the right, remove the rightmost bit and add a bit on the left. If the leftmost bit before the shift is 0, add a 0; if it is 1, add a 1.
So looking at your example 32 >> 3:
32 == 0010 0000
Shift this to the right three times, using the method described above. This gives:
0001 0000
0000 1000
0000 0100
So the answer is 0000 0100 == 4.
Note, you always have to take all the bits in the number into account. If your are shifting an int, which is 32 bits, you should look at all 32 bits:
0000 0000 0000 0000 0000 0000 0010 0000
So looking at your example 32 >> 3:
32 == 0010 0000
Shift this to the right three times, using the method described above. This gives:
0001 0000
0000 1000
0000 0100
So the answer is 0000 0100 == 4.
Note, you always have to take all the bits in the number into account. If your are shifting an int, which is 32 bits, you should look at all 32 bits:
0000 0000 0000 0000 0000 0000 0010 0000
Thursday, December 6, 2007
The "NULL" Type
There is also a special null type, the type of the expression null, which has no name. Because the null type has no name, it is impossible to declare a variable of the null type or to cast to the null type. The null reference is the only possible value of an expression of null type. The null reference can always be cast to any reference type. In practice, the programmer can ignore the null type and just pretend that null is merely a special literal that can be of any reference type.
class NameClass
{
static String name="xyz";
static NameClass getClass1()
{
System.out.println("inside method");
return null;
}
public static void main(String[] args)
{
System.out.println(getClass1().name);
}
}
the above code prints : inside method xyz
The variable name is declared as static. static variables and methods are not depends on the object instance
class NameClass
{
static String name="xyz";
static NameClass getClass1()
{
System.out.println("inside method");
return null;
}
public static void main(String[] args)
{
System.out.println(getClass1().name);
}
}
the above code prints : inside method xyz
The variable name is declared as static. static variables and methods are not depends on the object instance
Wednesday, December 5, 2007
Power of Velocity!
Velocity is known as just another open source product from ASF and used Template Engine. But Velocity is much more than that. It can be effectivly used as
1. Template Render
2. Code Generator
3. Rule Engine
etc
Lets have closer look at each of these capabilities
Contemporary technologies for web template engines are Freemarker, Groovy, Velocity, WebMacro and XSLT.
TODO: Comparative study of how these frameworkds work with Java
Also compare with Rules Engines such as Drools and Jess
1. Template Render
2. Code Generator
3. Rule Engine
etc
Lets have closer look at each of these capabilities
Contemporary technologies for web template engines are Freemarker, Groovy, Velocity, WebMacro and XSLT.
TODO: Comparative study of how these frameworkds work with Java
Also compare with Rules Engines such as Drools and Jess
Tuesday, December 4, 2007
THIS & SUPER in Static Context
You cannot call "super" from a static context. Just like you can't use "this" or call any non-static methods in a static context.
Monday, December 3, 2007
Diff - Array of Objects & Collections
Array of Objects - Stores object references.i.e, when you change object value anywhere , the changes are reflected in arrays
Collections - stores object copies. - once object is added to the collection, any changes on the object will not reflect in collection. Applicable to all collection - List/Vector/Set/Map etc
Collections - stores object copies. - once object is added to the collection, any changes on the object will not reflect in collection. Applicable to all collection - List/Vector/Set/Map etc
Java Mandatory Package Struture!
Can you import a class/interface of a default package from any specific packages.
For example, if you have class DefInterface defined without a package and if you want to use this interface in a class org.nava.DefImpl, can below code will work?
package org.nava;
import DefInterface;
class DefImpl implements DefInterface{
}
This doesnot work! Either you have complete package structure or no packages.
Just curious was it ever possible in java?
For example, if you have class DefInterface defined without a package and if you want to use this interface in a class org.nava.DefImpl, can below code will work?
package org.nava;
import DefInterface;
class DefImpl implements DefInterface{
}
This doesnot work! Either you have complete package structure or no packages.
Just curious was it ever possible in java?
How to Serialize Transient variables?
Transient variables are not automatically serialized.
However, we can externally make these variables available in serialized object in following way.
However, we can externally make these variables available in serialized object in following way.
class Animal implements Serializable {
transient int legs, wings;
private void writeObject(ObjectOutputStream os) {
try {
os.defaultWriteObject();
os.writeInt(legs);
os.writeInt(wings);
} catch (IOException e) {
e.printStackTrace();
}
}
private void readObject(ObjectInputStream is) {
try {
is.defaultReadObject();
// swapped:
this.wings = is.readInt();
this.legs = is.readInt();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
------------------
public class AnimalSerializer { public static void main(String[] args) {
List list = new ArrayList();
Animal bird = new Animal("Bird", 2, 2);
Animal fly = new Animal("Fly", 6, 2);
list.add(bird);
list.add(fly);
try {
FileOutputStream fos = new FileOutputStream("anis.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(list);
oos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(list);
list = null;
System.out.println(list);
try {
FileInputStream fis = new FileInputStream("anis.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
list = (List) ois.readObject();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println(list);
}
}
Sunday, December 2, 2007
Canoo WebTest!
Pros:
Simple
Fast
Excellent Reporting
Very low TCO
Runs everywhere
No display needed
Easy to extend
Straightforward integration
Doesn't accept (too) badly formed html
Cons:
Javascript support not as good as in "normal" browser
Doesn't accept (too) badly formed html
Tried with LCN application with around 90% of the form elements were not recognized. Either we develop bad way or Canoo is so strict.
Looks like may not be suitable for usual web applications whereas bad html is almost unavoidable since Rich browsers doesn;t complains them
Also, java scripts are not heavily supported and with WEB 2.0 developments, its becoming difficult to program within restricted tags. Needs to develop lot of custom steps for any Enterprise applications
Simple
Fast
Excellent Reporting
Very low TCO
Runs everywhere
No display needed
Easy to extend
Straightforward integration
Doesn't accept (too) badly formed html
Cons:
Javascript support not as good as in "normal" browser
Doesn't accept (too) badly formed html
Tried with LCN application with around 90% of the form elements were not recognized. Either we develop bad way or Canoo is so strict.
Looks like may not be suitable for usual web applications whereas bad html is almost unavoidable since Rich browsers doesn;t complains them
Also, java scripts are not heavily supported and with WEB 2.0 developments, its becoming difficult to program within restricted tags. Needs to develop lot of custom steps for any Enterprise applications
True North!
Discover your Authentic Leadership - Bill George[Harvard) with Peter Sims(Stanford)
Authentic Leadership
Leading your professional/personal/family/community life as INTEGRATED single life following your TRUE NORTH!
What is True North!
True North is the internal compass that guides you successfully through your life.It represents who you are as a human being at your deepest level.It is your orienting point-your fixed point in spinning world-that helps you stay on track in life.
Your True North is based on what is most important to you, your most cherished values,your passion and motivations, the sources of satisfaction in your life.
Discovering your True North takes a lifetime of commitment and learning!
Five Dimensions of Authentic Leader
1. Pursuing purpose with passion
2. Practicing solid values
3. Leading with heart
4. Establishing enduring relationships
5. Demonstrating self-discipline
Leadership is a Journey
Three phases of life with leadership:
1. Preparing for Leadership [Age 0-30]
2. Leading [31-60]
3. Giving Back [61-90]
Losing Sight of Your True North
1. Imposters - lacking self awareness & self esteem due to cunning & aggression
2. Rationalizers - deviating from values
3. Glory seekers - motivated by seeking world's acclaim.
4. Loners - fail to build personal support with whom you can always be yourself truly.
5. Shooting Stars - lacking the grounding of an integrated life
Moving from [0-30] to [31-60] - Transformation from "I" to "WE"
The is the first step towards authentic leadership is to discard the myth that leadership means having legions of supporters following our direction as we ascend to the pinnacles of power. Authentic leadership is about empowering others on their journeys.
Only when leaders stop focussing on their personal ego needs are they able to develop other leaders.They feel less competitive with talented peers and subordinates and are more open to other points of view, enabling them to make better decisions.As they overcome their need to control everything, they learn that people are more interested in working with them. A lightbulb goes on as they recognize the unlimited potential of empowered leaders working together toward a shared purpose.
This tranformation from "I" to "WE" is crucial to step on actual "LEADING" phase of life.
Discovering Your Authentic leadership
Guided by following directions
1. Self Awareness
What is my life story? At the end of my life how would I like see my life journey? What are my current Strengths& Weeknesses? What are my developmental needs ?
2. Values and Principles
What are my most deeply held values?
Values: The relative importance of things that matter in your life.
Principles: A Set of standards used in leading others, derived from your values.Principles are values translated into action
3. Motivations
What motivates me? How do I balance external[money/fame/glory/status] with my internal [satisfaction/sense of acheivement] motivations?
Find out what you are good at and what you like to do.
4. Support Team
Who are the people I can count on to guide and support me along the way?
5. Integrated Life
How can I integrate all aspects of my life and find fulfillment?
Make conscious choices & trade-offs to balance all parts of your life-infact its single Integrated life. This is essential in order to excel in all aspects as integrated.
Authentic Leadership
Leading your professional/personal/family/community life as INTEGRATED single life following your TRUE NORTH!
What is True North!
True North is the internal compass that guides you successfully through your life.It represents who you are as a human being at your deepest level.It is your orienting point-your fixed point in spinning world-that helps you stay on track in life.
Your True North is based on what is most important to you, your most cherished values,your passion and motivations, the sources of satisfaction in your life.
Discovering your True North takes a lifetime of commitment and learning!
Five Dimensions of Authentic Leader
1. Pursuing purpose with passion
2. Practicing solid values
3. Leading with heart
4. Establishing enduring relationships
5. Demonstrating self-discipline
Leadership is a Journey
Three phases of life with leadership:
1. Preparing for Leadership [Age 0-30]
2. Leading [31-60]
3. Giving Back [61-90]
Losing Sight of Your True North
1. Imposters - lacking self awareness & self esteem due to cunning & aggression
2. Rationalizers - deviating from values
3. Glory seekers - motivated by seeking world's acclaim.
4. Loners - fail to build personal support with whom you can always be yourself truly.
5. Shooting Stars - lacking the grounding of an integrated life
Moving from [0-30] to [31-60] - Transformation from "I" to "WE"
The is the first step towards authentic leadership is to discard the myth that leadership means having legions of supporters following our direction as we ascend to the pinnacles of power. Authentic leadership is about empowering others on their journeys.
Only when leaders stop focussing on their personal ego needs are they able to develop other leaders.They feel less competitive with talented peers and subordinates and are more open to other points of view, enabling them to make better decisions.As they overcome their need to control everything, they learn that people are more interested in working with them. A lightbulb goes on as they recognize the unlimited potential of empowered leaders working together toward a shared purpose.
This tranformation from "I" to "WE" is crucial to step on actual "LEADING" phase of life.
Discovering Your Authentic leadership
Guided by following directions
1. Self Awareness
What is my life story? At the end of my life how would I like see my life journey? What are my current Strengths& Weeknesses? What are my developmental needs ?
2. Values and Principles
What are my most deeply held values?
Values: The relative importance of things that matter in your life.
Principles: A Set of standards used in leading others, derived from your values.Principles are values translated into action
3. Motivations
What motivates me? How do I balance external[money/fame/glory/status] with my internal [satisfaction/sense of acheivement] motivations?
Find out what you are good at and what you like to do.
4. Support Team
Who are the people I can count on to guide and support me along the way?
5. Integrated Life
How can I integrate all aspects of my life and find fulfillment?
Make conscious choices & trade-offs to balance all parts of your life-infact its single Integrated life. This is essential in order to excel in all aspects as integrated.
Subscribe to:
Posts (Atom)