TechBook

JProfiler

2011-12-16T16:50:00.000+05:30

JProfiler is a tool useful for analyzing the performance problems and memory leaks of a java project. When Jprofiler is run it asks us to choose the jvm on which we want to analyze the performance.

It provides visual representation for the virtual machine load in terms of active and total bytes, instances, threads, classes, Garbage Collector activity.

It is a commercially licensed Java profiling tool developed by ej-technologies targeted at Java EE and Java SE applications

http://resources.ej-technologies.com/jprofiler/help/doc/help.pdf

Some design perspectives

2011-11-29T17:48:00.000+05:30

When an application/product is evaluated, it has to be done in various perspectives. If it fails in one of these, it will be considered as a bad design. Several industry standards exist for this. Some important ones are :

1.Functionality - it should render a decent coverage of various functionalities it boasts to provide. The extent of functionalities which can satisfy its clients depends on the business domain and various terminologies in that. For example, if we consider an online website where we can order books, it should have a good search functionality so that customers can search the books they want by various parameters such as author's name, title, publications, keywords etc.

2.Usability - software should be easy to use. If people need special training to use a software it may not be a good fit for the public in general. One important aspect in this is user interface. But usability is much broader than just the user interface.

3. Accessibility - in certain countries, it is mandated that people with disabilities should be able to use a software. Software should adhere to such guidelines.

4. Security - software that is exposed on the internet should take extra care to ensure that there is no security threat for the users who want to provide their personal information. Again, there are third parties who can certify whether the site is vulnerable for security threats.

5.Performance - If the software has too many functionalities but takes too much time to load, it is again a bad thing. Ideal standard is that a screen/page should not take more than 8 seconds to load. The standard may vary, however it should take as little time as possible.

6.Scalability - refers to how many users(or load) an application can support simultaneously. We all know about those websites which crash when they are needed most.

7.Internationalization - refers to how many languages can the software support. When the software has global presence, it is desired to provide support for multiple locales.

8.Maintainability/Upgradability - this aspect of software is equally important because once the software is developed, it is very likely to undergo a lot of changes over a period of time. If the design of software is not good enough to accommodate new features, it may become a nightmare for developers to support the software.

Code Performance

2011-11-14T12:23:00.001+05:30

Many performance related issues become difficult to debug, if we do not know how to measure the time take to execute a piece of code. If we introduce a couple of simple lines in our code base,it can be measure with a decent accuracy.

ThreadMXBean threadMxBeam = ManagementFactory.getThreadMXBean();
long timeBefore = threadMxBeam.getCurrentThreadCpuTime();

//Code whose performance has to be tested goes here.

long timeAfter = threadMxBeam.getCurrentThreadCpuTime();
System.out.println("======Time Taken to execute this code==" +(timeAfter-timeBefore));

There is another API which gives time in milli seconds. But some developers say that it is not so effective.

long startTimeStamp = System.currentTimeMillis();

//Code whose performance has to be tested goes here.

long endTimeStamp = System.currentTimeMillis();
long timeTaken = (endTimeStamp - startTimeStamp);

When performance issues are discovered at a later stage of the project, fixing them can have a significant impact on the codebase. Whilst it may not be practical to expect our code to be very performant in the beginning itself, if we can keep a few things in our mind while coding, there is a chances to reduce such occurrences.

Some ways to improve the performance:

1. Use of database indexes optimally. It should be examined for all SQL that gets run. If you select on a table using a single field that is not indexed then an entire table scan is done which would take a very long time on larger tables. If you’re selecting using two values then at least one should be indexed as that way the DB would initially go through the index and then restrict those results using the second field. The more often an SQL is executed the more critical that it is indexed, although it should also be noted that indexes will slow down the inserts slightly.

2. Avoid unnecessary java looping. Instead, try to restrict them in the database itself before bringing them to the java layer.

3. Use sql joins instead of multiple queries. This can reduce the number of database calls.

4. Use caching for frequently read tables. For example, if a common table such as person has to be read on every page, it may be worth storing the required person's details in a cache in data access layer. If data is present in the cache, no need to query the database again. Another way is to put the details in a session. But potential security issues also have to be given due importance while considering this.

5.Avoid unnecessary lines of code. Sometimes it is possible that mistakenly, some java lines are present even though they are not necessary for every flow. Such lines should be optimized.

6. Carefully considering the && and || conditions in the if blocks. The condition which executes faster should come first. Since, success or failure of this condition will decide whether to execute the next condition or not.

7. Avoid unnecessary object instantiation. Split large methods into smaller ones wherever possible, since it is believed to improve garbage collection.

Setting up data for testing performance issues

2011-10-21T14:59:00.001+05:30

Loading huge volume of data into the database to carry out performance testing is a big challenge. Actual data in production may not available to either testers or developers due to privacy issues. So, only options left are populate the data by writing some test cases or sql scripts or go for filling the data manually.

There will be more challenges again in the filling up the data through test cases. Usually, we make use of loops to execute a piece of code that inserts data into various tables. But this data will be very much likely to be identical and not diverse as in real time. If we want to fill in diverse data junits should be more robust. Otherwise, with identical data, most of the queries or conditions in the code base will be by passed in all flows, and a holistic performance behavior of the code base cannot be known.

Once test data is filled, extracting that into some xml or similar files through some build targets is an option, if that is supported by the prevalent infrastructure of the project. Even the data dump options provided by databases such as oracle or db2 can also be used to pull out the same. Here, care should be taken to ensure that database versions of the source and destination are same.

It will be cumbersome, impractical and sometimes even risky to check the data table by table and extract data from only those tables required for testing. Typically in a enterprise project, database tables will be so closely interlinked that, we may end up needing data in most of the tables to account for data integrity. So, a better option is always to export data in the entire schema and them import the same.

If data is inserted through junits or scripts, it is more likely that it will have security errors with respect to creation and view of data. Because, junits or scripts do not cater to login authentication, authorization etc, instead dump some data into database just to test other functionality. If the same data is imported on test runtime where there will be more powerful security checks, there could be issues in logging into the application itself.

Despite all these issues, performance testing is very important and to conduct this it is equally important to set up a reasonable volume of data. How this can be achieved will always be an interesting question to the project architects.

PermGen

2011-08-23T20:10:00.000+05:30

In the JVM, PermGen holds the metadata about classes that have been loaded/created. This information is garbage collected like the other parts of the heap, however there are rough edges that can prevent this from happening, class loaders in particular.

PermGen is not a part of the region called heap.Actually, in Sun's JVM Permanent Generation (PermGen) is completely separate from the heap.

This area is filled of your app classes metadata and many other things that do not depend on the application usage.

For the HotSpot Java VM, the memory pools for serial garbage collection are the following.

Eden Space (heap): The pool from which memory is initially allocated for most objects.
Survivor Space (heap): The pool containing objects that have survived the garbage collection of the Eden space.
Tenured Generation (heap): The pool containing objects that have existed for some time in the survivor space.
Permanent Generation (non-heap): The pool containing all the reflective data of the virtual machine itself, such as class and method objects. With Java VMs that use class data sharing, this generation is divided into read-only and read-write areas.
Code Cache (non-heap): The HotSpot Java VM also includes a code cache, containing memory that is used for compilation and storage of native code.

Some of the common causes:

Custom classloaders that don't carefully free up older classes after loading new ones.
Classes remaining in PermGen after redeploying an application multiple times (more common in Dev than Prod)
Heavy use of Proxy classes, which are created synthetically during runtime. It's easy to create new Proxy classes when an a single class definition could be reused for multiple instances.

Exception in thread main java.lang.OutOfMemoryError: PermGen space signifies too many classes loaded or being generated; or the String.intern table is too big. Increase using the -XX:MaxPermSize option.

-XX:PermSize=256M -XX:MaxPermSize=128M

How do I know what classes are being loaded or unloaded? Use the command line options
-XX:+TraceClassloading and -XX:+TraceClassUnloading http://java.sun.com/docs/hotspot/gc1.4.2/faq.html

http://stackoverflow.com/questions/2051734/why-is-permgen-space-growing
http://download.oracle.com/javase/1.4.2/docs/tooldocs/windows/java.html

An interesting way of instantiation

2011-06-24T15:59:00.002+05:30

When you do not have access to instantiate a class through a factory or so, one possible way is to declare an inner private class which extends the class to be instantiated.

For example, we have a class "Vehicle" which is marked abstract and hence cannot be instantiated directly. There is a "VehicleFactory" which is meant for giving an instance of this class.

Now, I want to to create an instance of "Vehicle" class in my class without using VehicleFactory. Here is how:

public class Myclass{

private MyVehicle myVehicle = new MyVehicle();

private class MyVehicle extends Vehicle{
}

public static void main(String args[]){
Myclass myClass = new Myclass();
myClass.myMethod();
}

public void myMethod(){
myVehicle.drive();
}
}

Can you think of some advantage of this kind of usage ?

Significance of selecting a proper collection class OR danger of using collections with hashing

2011-05-27T12:56:00.003+05:30

In java, lot of people are fond of the ‘Set’ collection class. The most commonly used implementation class of Set is HashSet. It is easy to use and is believed to have good performance. It is good for returning data from the data access layer.(though it may not be of use with ORDERBY clauses).

But one thing people might forget is that it uses hashing algorithm. So the order in which you store the data is not maintained. There are instances where we get different results when executed at different times. This could be because of iterating through a collection such as HashSet. There are chances of its usage going unnoticed and at times it becomes difficult to debug it out. But as a good practice, it is better to use some predictable collections like ArrayList unless absolutely necessary.

Performance may not be a big issue with the blinding fast advancements in the processing and storage technologies. But making the application work consistently and predictably is the most important responsibility of a developer. Definitely there is no use of a software which works very fast and consumes very less memory if it doesn't do what is expected.

A tale of two queries

2011-05-18T14:50:00.001+05:30

Consider following two queries

1) SELECT * FROM MYSTORIES WHERE STORY LIKE 'X'

2) SELECT * FROM MYSTORIES WHERE STORY ='X'

Both will find the exact match and give the same result. However some interesting things are

1) The first query doesn't work on DB2 but works on Oracle.
2) The second query works fine on both DB2 and Oracle.
3) There is a performance overhead in using like without a wild card (i.e %)
4) Any good optimizer would reduce the first expression to the second.

Note that in the above example the field 'STORY' is of data type CHARACTER

Junit - the saviour

2011-05-05T12:00:00.001+05:30

Usually, in maintenance projects, we fix defects, test them and deliver. But sometimes it so happens that fixing one defect might cause some other previous fix to fail. When deadlines are tight, developers can't afford to test all possible complex scenarios at the last moment, and no sensible developer would intentionally break some existing fix for introducing a new fix. But it still happens inadvertently.

If you are a seasoned developer, you would have encountered some testers who re-open old defects just one day before the release schedule. Testers always escape saying their favourite sentence 'It was working earlier and now it is not working'. You might have to burn the mid night oil to see which of your recent change has caused this last moment catastrophe.

There is a proven method which is so simple and obvious but when it comes to following it, described as "vehemently impractical" by developers. Yes, you are right. It is about writing junits.

For every defect, developer should write a junit first to simulate the scenario. The junit would fail and the fix would pass it. This would also save you from running all steps through the application each time, setting up the required data etc. More importantly, this junit would safe guard your fix for ever. Even if you introduce 100 new fixes in future, if any of these causes your old fix to break, this loyal junit would raise an alarm by failing itself.

Writing junits by test scenarios may not be encouraged everywhere since it is not a standard. It is seen more as testers job to write automated scripts for these. But if you want to avoid those last bad moments in your release, this approach is highly advisable. How you negotiate with your manager to get time for such things is up to you and your manager !!

Environment Variables

2011-05-03T14:25:00.000+05:30

Environment Variables are set as User Variables or System Variables. They override over the environment variables which might be set while running our build targets. This can lead to confusion sometimes. For example lets say we have an environment variable ENVVAR_VAR1 set to pathX as user/system variable. We have a target batch file to run the build say build.bat which internally sets the ENVVAR_VAR1 to pathY. Now, actually pathX will take priority.

Setting up too many environment variables explicitly as User Variables or System Variables could be very misleading. It is always a good practice to set them through the batch as required for the context instead of setting them permanently.

Merging

2011-04-13T17:53:00.003+05:30

When we work on various versions of the code, replication of what was delivered on the previous release on to the current release and future releases becomes a matter of critical importance.

Suppose there are 3 releases going on parallel - V1.3, V1.2.1, and V2.0 An issue was found while testing V1.2.1 which is an emergency release. The fix is delivered on V1.2.1 immediately. Now, the same fix has to be replicated on V1.3 which is a future point release in progress. The fix should also be replicated on V2.0 which is a major release which too is in progress by another team. Following things are worth considering while doing this.

1) It is possible that the files in V1.2.1 would have changed in V1.3 and would have significantly changed further in V2.0. So when the fix delivered on V1.2.1 is copied to that on V1.3 and V2.0 care should be taken not to break the newly developed functionality.

2) It is always advisable to go for manual merge instead of automatic(through tools or through the version controller). Because even a very small change can impact a lot and may become difficult to debug in future, resulting in wastage of time.

3) Unit tests should be written in such cases for the scenario fixed on emergency release. Inclusion of these unit tests would ensure that the same scenario would work fine on all other future versions.

4) Customers who have already taken a previous version when they want to upgrade to newer version, should not face problems with compilation if there are any changes done on method signature or such things causing the existing code to break. In such cases, the old code (methods) should continue to be supported (can be deprecated if needed) and new methods should be provided to get this additional feature. Details regarding why the changes were done and what would happen if the new code is not taken etc should be clearly documented for customers.

This may not be of major significance where there is only one client using the entire code(as in software services companies). But if there are multiple clients (e.g in software product companies) handling simultaneous releases could be challenging. Strong processes should be in place and should be strictly followed in such cases.

Remote debugging

2011-03-29T11:41:00.003+05:30

If a runtime environment is not set up in the local machine, sometimes it becomes difficult to debug some issues. For example consider an enterprise application deployed on a websphere server on a remote machine. If there is an issue reproducible on this environment the developer may not be able to debug and find out what the issue is. This is because the enviroment is remote and developer has the code base on his machine. Developer might have his own development environment say - Tomcat server. However, it is possible to remotely debug the issues existing on the remote production machine. For this, the developer should have the same version of code base in his eclipse as that present on the runtime environment. Once that is confirmed he needs to do the following. In WebSphere web console, left navigation, 1. Servers -> Server Types -> WebSphere application servers 2. Under Server Infrastructure section -> expand Java and Process Management -> Process definition 3. Under Additional Properties section -> click Java Virtual Machine 4. Checked the 'Debug Mode' 5. In Debug arguments textbox, put this -Xdebug -Xnoagent -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8888 6. Restart WebSphere server instance. Now, WebSphere is started in debug mode, and listening on port 8888. (Later, Eclipse will connect to this port for debugging) In Eclipse IDE, under your project source 1. Click on 'Run', 'Debug Configurations' 2. Select 'Remote Java Application', right click and select 'New' 3. Renamed a new name , e.g 'WebSphere 7 Instance' 4. In 'Connection Type', select default, 'Standard (Socket Attached)' 5. Host, put your WebSphere host IP 6. Port, put 8888. 7. Click on the debug button. Now, Eclipse debugger is started and connected to port 8888. Now, as you run the application on the remote machine, the code can be debugged in single steps. Taken from http://www.mkyong.com/websphere/remote-debugging-with-eclipse-websphere-7/

Including selected class files in a deployed jar

2011-03-26T12:06:00.003+05:30

Copy the new class files to be included into a tmp folder.
Take the jar file too to this tmp folder
Extract the class files which need to be replaced, out from the jar. This should be extracted into the tmp folder with the same directory structure as it was packed initially.
Now, replace these class files extracted from the jar with the new class files(don't change the directory structure, keep the same but replace old class files with new one)
Open the jar file. Drag and drop the directory containing the class files into the jar.
Now, the jar contains the new class file. The same can be tested by sorting all the classfiles inside the jar with time stamp.

This process is useful when we have a lot of class files packed in the jar and only a very few of them need to be replaced. Building the whole jar again would take significantly more time. Instead, this work around can be used. Restarting the server should suffice to pick the new jar.

Struts

2011-03-21T17:42:00.002+05:30

Struts
· open-source framework
· web application framework
· request-based web application framework
· supports internationalization by web forms
· can include a template mechanism called "Tiles"
· uses and extends the Java Servlet API
· encourages developers to use (MVC) architecture

Traditional approach:
· client submits information to the server via a web form.
· information is given to the Servlet that processes it
· or information is given to a JSP document that combines HTML and Java code
· both interact with database wherever needed and produce HTML-formatted response

Disadvantages:
· application logic is mixed with presentation
· for large projects maintenance becomes difficult

Struts separates the following :
· application logic that interacts with a database(Model)
· HTML pages presented to the client(View)
· instance that passes information between view and model (Controller)

· controller is a servlet known as ActionServlet
· Requests from the client are sent to the controller in the form of Actions
· when the controller receives such a request it calls the corresponding Action class
· Action class interacts with the application-specific model code
· web application programmer is responsible for writing the model code
· model code returns an "ActionForward" - a string telling the controller what output page to send to the client
· A model represents an application’s data and contains the logic for accessing and manipulating that data.
· information is passed between model and view in the form of special JavaBeans
· Model components are generally standard Java classes. EJB, Java Data Objects(JDO) and JavaBeans can be use as a model. The Struts Framework has no built-in support for the Model layer and Struts frame work doesn't limit you to one particular model implementation.

struts-config.xml binds model, view and controller together.
source: http://en.wikipedia.org/wiki/Struts
http://publib.boulder.ibm.com/infocenter/rtnlhelp/v6r0m0/index.jsp?topic=%2Fcom.ibm.etools.struts.doc%2Ftopics%2Fcstrdoc001.html

PDF generation

2011-03-21T17:36:00.004+05:30

Itext is a tool that can be used for generationg pdf.
Download iText-5.0.6.jar from http://sourceforge.net/projects/itext/files/iText/iText5.0.6/iText-5.0.6.jar/download
Following is a sample code that generates PDF.

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import com.itextpdf.text.BaseColor;
import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Font;
import com.itextpdf.text.FontFactory;
import com.itextpdf.text.PageSize;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.PdfWriter;

public class PDFGenerator {
public static void main(String args[]) throws FileNotFoundException,DocumentException {
Document document = new Document(PageSize.A4, 50, 50, 50, 50);
PdfWriter.getInstance(document, new FileOutputStream("C:\\SampleTextTest.pdf"));document.open();

document.add(new Paragraph("This is a sample document"));
document.add(new Paragraph("How is the text in this color?",

FontFactory.getFont(FontFactory.TIMES_ITALIC, 14, Font.BOLD, new BaseColor(145,140, 250))));
document.close();
System.out.println("=======success=====");
}
}

Put the above code in the PDFGenerator.java file and run it after ensuring that the requiredjar file is accessible in the classpath.If the program is success, you will have a pdf file created in the path given.There are various other apis which can be used to implement our needs.Source http://www.ibm.com/developerworks/opensource/library/os-javapdf/

A Query

2011-03-14T12:48:00.001+05:30

Following is an interesting query to get the description of all the tables in a database.

SELECT T.TABLE_NAME, ROWNUM "Sr No", T.COLUMN_NAME, T.DATA_TYPE , T.DATA_LENGTH, DECODE (T.NULLABLE, 'N', 'NOT NULL', 'Y', ' ') NULLABLE, T.DATA_DEFAULT, C.COMMENTS FROM ALL_TAB_COLS T, ALL_COL_COMMENTS C WHERE T.OWNER = C.OWNER AND T.TABLE_NAME = C.TABLE_NAME AND T.COLUMN_NAME = C.COLUMN_NAME ORDER BY T.TABLE_NAME

2011-02-08T17:56:00.002+05:30

The process of building a computer program is usually managed by a build tool, a program that coordinates and controls other programs. Building a software program may comprise various modules. Each of this module will do a number of specific tasks which are logically related and clubbed together. Usually these tasks may consist of

· creating/deleting directories
· parsing some files into another type of files
· compiling source files into class files
· bundling the compiled files into archives
· moving files from one place to another
· generating some new files
· validating some files
· checking dependencies
· creating databases, tables, executing sqls

The build utility needs to compile and link the various files, in the correct order. If the source code in a particular file has not changed then it may not need to be recompiled (may not rather than need not because it may itself depend on other files that have changed), to shorten the time required to complete the build.

The overall architecture of the build process elaborates various targets executed internally. Usually, in the build scripts echo target and some key steps they execute. If the build is starting, ending or skipping something, or if there are some files missing or if there are some errors encountered, that is echoed on the command prompt. It is also a common practice to echo the timestamp along with the steps.

It is a good practice to echo the progress as elaborate as possible since that would help the user to understand the status of the build. Some other good practices include

· Don't use Hard-coded values - use relative references and be sure the files/directories are checked in your version control repository so that they are available from your local workstation.

· Don't Copy and Paste build scripts - same problems will be replicated everywhere. So, put all the common code in a single build script and use a .properties file to adapt to each environment

· Avoid Long targets - Try to break up build behavior into discrete targets.

· Clean up: If you are not removing temporary files, classes, assemblies and other files before you build, you have no way of ensuring the build was successful.

· Provide test targets: If some targets are provided to test if the configuration is proper or not, it will be helpful. This would ensure that the required configuration such as installation of required software, versions matching, setting environment variables etc are done properly before starting the execution of the actual build targets.

Build scripts are very powerful in automating various repetitive tasks and thereby reduce the work. Theoretically everything that is repetitive can be put in build scripts. In large software systems, having a stable, efficient, replicable and modularized build architecture is essential. This will ensure consistency and reduce the manual errors.

From http://blog.stelligent.com/integrate-button/2010/07/10-bad-build-practices---part-i.html and en.wikipedia.org

Java OS

2011-01-06T12:08:00.000+05:30

JavaOS is an operating system with a Java virtual machine as a fundamental component. It is developed by Sun Microsystems. Unlike Windows, Mac OS, Unix or Unix-like systems which are primarily written in the C programming language, JavaOS is primarily written in Java.

As with all operating systems, the primary role of a Javaos is to manage resources in such a way so as to allow more than one program to run concurrently.As resources we define the set of computational power, memory space and I/O bandwidth that running programs compete for.

In java OS, all device drivers are written in Java and executed by the virtual machine. A graphics and windowing system, implementing the AWT API is also written in Java.

In the case of a Javaos , the JVM is the component responsible to interact with the hardware. Since the JVM expects an operating system to do the hardware interaction in its place, a compatibility layer between the JVM and the hardware must be built. This layer must do little more than initialising the hardware, setting up a context switching environment for servicing interrupts and branching into the JVM. Device drivers would better be kept out of the compatibility layer and be directly implemented in Java, because this will make them portable and enable them to use the classpath facilities.

Two approaches to organising resources

Process based: All executed programs run on the same JVM. The virtual machine builds the notion of a process by using seperate classloaders for each loaded program. Each program is tricked to believe it is running in its own virtual machine by being with private copies of bootstrap classes and its private memory space and garbage collector. Changes in the JVM are required to support this model.

JVM based: Each executed program consists of one or more Java threads. A supervising thread is responsible for spawning new programs as needed using a well defined interface. Language-based memory protection and thread synchronisation mechanisms are used to protect shared resources. Loaded programs become part of the system’s classpath and so other programs can directly access their methods, but namespaces and method access control can be used to protect the program internals. No changes are required to the JVM.

In the case of the Javaos , the classpath has to be modified to use the OS’s subsystems instead of native calls. Finally, although the size of the classpath seems too big to be used as the basic Javaos library, the classpath is the only library most Java applications will ever need to run.

JavaOS was initially designed to run on embedded systems.

From 2006 onwards Sun considers JavaOS a legacy system and recommends migration to Java ME. This by itself however is not a full replacement, as Java ME is an API specification, which runs on top of an operating system, and is not an operating system in itself.
Sources:
ftp://ftp.cs.man.ac.uk/pub/apt/theses/GeorgiosGousios_MSc.pdf
wikipedia

PHP

2010-12-17T14:57:00.001+05:30

PHP stands for PHP: Hypertext Preprocessor. It is a server-side scripting language, like ASP.PHP scripts are executed on the server.PHP code is embedded into the HTML source document and interpreted by a web server with a PHP processor module, which generates the web page document.PHP is available as a processor for most modern web servers and as a standalone interpreter on most operating systems and computing platforms.

Originally designed to create dynamic web pages, PHP now focuses mainly on server-side scripting,[35] and it is similar to other server-side scripting languages that provide dynamic content from a web server to a client, such as Microsoft's Asp.net, Sun Microsystems' JavaServer Pages,[36] and mod_perl.

The PHP language was originally implemented using a PHP interpreter. Several compilers now exist, which decouple the PHP language from the interpreter.

It is a powerful tool for making dynamic and interactive Web pages. PHP is an open source software and is free to download and use. PHP Group provides the complete source code for users to build, customize and extend for their own use. It is the widely-used, free, and efficient alternative to competitors such as Microsoft's ASP.PHP supports many databases (MySQL, Informix, Oracle, Sybase, Solid, PostgreSQL, Generic ODBC, etc.)

PHP cannot be run on tomcat server directly. Apache foundation has apache server which is capable of compiling PHP scripts. We can run both servers in same machine at the same time.

Advantages of php:
· It is fast, stable, secure, easy to use and open source (free).
· PHP code is inserted directly into the HTML that makes up even a website.
· It runs on many different operating systems
· Since it is server side (no need to futz with client installs - only with rendering issues if you use CSS).
· The language is similar to C and Perl so that anyone with a background in either C or Perl programming will feel comfortable using and understanding PHP
· PHP is a full-fledged programming language (unlike HTML for example, which is more of a presentation means) and many complex applications can be written it it.
· There are tons of ready PHP scripts and functions, which can be customized to our liking and used in our PHP applications.
· PHP hosting is a type of a webhosting package aimed at running applications written in PHP. Since the webhosting provider can use webhosting technologies for free(PHP, Linux and MySQL) it leads to the lower cost of webhosting.

Sources
http://www.w3schools.com/php/default.asp
http://www.softminer.net/2009/05/how-to-install-or-run-php-on-tomcat-6.html
http://www.designersplayground.com/articles/118/1/The-Advantages-of-PHP/Page1.html

Scripting

2010-12-15T12:35:00.001+05:30

Scripts are often interpreted from source code or bytecode, whereas application software is typically first compiled to a native machine code or to an intermediate code.

Client scripts
-----------------
Client-side scripts are often embedded within an HTML document (hence known as an "embedded script"), but they may also be contained in a separate file, which is referenced by the document (or documents) that use it (hence known as an "external script").
By viewing the file that contains the script, users may be able to see its source code. Many web authors learn how to write client-side scripts partly by examining the source code for other authors' scripts.

Client-side scripts have greater access to the information and functions available on the user's browser, whereas server-side scripts have greater access to the information and functions available on the server.

Due to security restrictions, client-side scripts may not be allowed to access the user's computer beyond the web browser application. Techniques like ActiveX controls can be used to sidestep this restriction.

Unfortunately, even languages that are supported by a wide variety of browsers may not be implemented in precisely the same way across all browsers and operating systems. Authors are well-advised to review the behavior of their client-side scripts on a variety of platforms before they put them into use.

Some client-side scripting languages:

JavaScript (Client-side JavaScript) (*.js)
VBScript(*.vbs)

Server scripts
------------------
Server-side scripts, written in languages such as Perl, PHP, and server-side VBScript, are executed by the web server when the user requests a document. They produce output in a format understandable by web browsers (usually HTML), which is then sent to the user's computer. The user cannot see the script's source code (unless the author publishes the code separately), and may not even be aware that a script was executed. Documents produced by server-side scripts may, in turn, contain client-side script

Server-side scripts require that their language's interpreter be installed on the server, and produce the same output regardless of the client's browser, operating system, or other system details. Client-side scripts do not require additional software on the server (making them popular with authors who lack administrative access to their servers); however, they do require that the user's web browser understands the scripting language in which they are written. It is therefore impractical for an author to write scripts in a language that is not supported by popular web browsers.

In the earlier days of the web, server-side scripting was almost exclusively performed by using a combination of C programs, Perl scripts and shell scripts using the Common Gateway Interface (CGI). Those scripts were executed by the operating system, mnemonic coding and the results simply served back by the web server. Nowadays, these and other on-line scripting languages such as ASP and PHP can often be executed directly by the web server itself or by extension modules (e.g. mod_perl or mod php) to the web server.

Some server-side scripting languages:
ASP
ColdFusion Markup Language (*.cfm)
Java via JavaServer Pages (*.jsp)
JavaScript using Server-side JavaScript (*.ssjs)
PHP (*.php)
SMX (*.smx)
Lasso (*.lasso)
WebDNA (*.dna,*.tpl)

ECMAScript is the scripting language standardized by Ecma International in the ECMA-262 specification and ISO/IEC 16262. The language is widely used for client-side scripting on the web, in the form of several well-known dialects such as JavaScript, JScript, and ActionScript(ActionScript is an object-oriented language originally developed by Macromedia Inc).

source: wikipedia.org

CTI

2010-12-14T15:07:00.000+05:30

Computer telephony integration, also called or CTI, is technology that allows interactions on a telephone and a computer to be integrated or co-ordinated. As contact channels have expanded from voice to include email, web, and fax, the definition of CTI has expanded to include the integration of all customer contact channels (voice, email, web, fax, etc.) with computer systems. It mainly does the following:

· CTI enables the computer user to control their telephone system
· CTI enables the telephone system to display information via the computer

A CTI system performs various other functionalities which are listed below:

· It displays information about the call like the caller’s number, the dialed number etc
· The dialing is automatically computer managed, speedy and prognostic
· It flawlessly synchronizes the transmission of data between telephone and computer
· It is integrated with call routing, reporting utilities, desktop functions automation, multi channeling, mailing and cataloguing online requests
· It can record the calls with an inbuilt recording software for quality inspection

http://www.tech-faq.com/computer-telephony-integration-cti.html

Documentation

2010-12-09T19:21:00.003+05:30

Most of the engineers look at documentation work contemptuously. They think that it is not actually the "engineering" work but has got mostly to do with one's skills in the language. Many engineers who are excellent coders are found to be equally horrible when it comes to documenting what they have coded.

But very few intelligent folks agree that documentation can be as interesting and challenging as coding. In product companies, writing Release notes is an important task. Some companies hire technical writers who are specialized in doing this, but many would expect the developer himself/herself to perform this task. No one can deny the fact that the best documentation can be provided by the one who has coded it, provided he is skilled in that as well.

One need not be the Shakespeare to write good release notes or documentation. Nor does he need to have a great vocabulary. He just has to be clear in his thinking and develop the skill to put it with simple but appropriate words.

Here are some guidelines on that, it may seem very obvious but they are very important.

· Sentences should explain what the application/code/fix does than how it does.
· Wherever there is an external reference needed, proper link(ref numbers, urls etc) to that should be provided.
· Examples/diagrams should be used to explain relatively complex things.
· Sentences should be arranged in logical paragraphs.
· Repeated usage of verbose description and unnecessary phrases(e.g what it means is that), should be avoided.
· Lengthy sentences should be avoided as much as possible.
· Spelling and other grammar rules should be respected.

RSM

2010-12-03T15:23:00.000+05:30

It is used for visual modeling and model-driven development (MDD) with UML for creating applications and web services. It has integrations with other Rational tools, such as ClearCase configuration management and ClearQuest.

Some features:
Model files are stored as .emx/.efx files. (compare this with rose files which are stored as .cat files)These are in fact nothing but xml files.
RSM came to overcome the drawback of rational rose where it was not possible to integrate it within the IDE. But RSM can be integrated within IDE.
For the next-generation MDD products, model-driven development functions was built on top of Eclipse to form a more complete MDD tool. These came with IBM Rational XDE (extended development environment for the next generation of programming technologies) IBM Rational XDE was characterized as the next generation of IBM Rational Rose.
v7.5 was released in September 2008
source: Wikipedia

Deprecation

2010-11-23T14:52:00.000+05:30

In fact, the meaning of the word Deprecation goes as 'A prayer to avert or remove some evil or disaster', but in java as we all know it is a way to tell callers of methods/classes that 'This is not a good method/class to use, we may discontinue to have this with us eventually'. One common thing usually associated with deprecation is to point to the new method/class that should be used as a replacement.

Following things are worth considering while deprecating something:

1) Clients might be already using the artifacts which you are planning to deprecate. If you remove this, or change the signature of this, their code might break. That is exactly why we have deprecation in place. So deprecation is one of the best alternatives to remove an artifact. Any removal/addition that can impact the existing code is worth considering for deprecation.

2) When you deprecate an artifact, ideally you should deprecate all other artifacts which refer to this deprecated artifact as well, if they are in your control. Of course, you cannot control those which are calling your deprecated artifact from outside.

3) Deprecation is usually associated with a clear description of the release since when it was deprecated, why it was deprecated and what is the alternative provided.

4) If you are writing new artifacts, try to avoid the references to deprecated artifacts as much as possible.

5) Deprecated artifacts are believed be removed at some point in time in future, though I have never seen anything deprecated previously that was actually removed. The explanation to this is 'backward compatibility'.

Annotations

2010-10-07T10:57:00.001+05:30

Annotations in Java is all about adding meta-data facility to the Java Elements. Like Classes, Interfaces or Enums, Annotations define a type in Java and they can be applied to several Java Elements. Annotations are differentiated from other elements like class, interface etc., by preceding an '@' symbol before it.

Rules:
Annotation declaration should start with an 'at' sign like @, following with an interface keyword, following with the annotation name.

Method declarations should not have any parameters.
Method declarations should not have any throws clauses.

Return types of the method should be one of the following:
1)primitives
2)String
3)Class
4)enum
5)array of the above types

There are three annotation types:
Marker: Marker type annotations have no elements, except the annotation name itself.
Example

public @interface MyAnnotation {
}

Single-Element: Single-element, or single-value type, annotations provide a single piece of data only. This can be represented with a data=value pair or, simply with the value (a shortcut syntax) only, within parenthesis.

public @interface MyAnnotation
{
String doSomething();
}

Full-value or multi-value: Full-value type annotations have multiple data members. Therefore, you must use a full data=value parameter syntax for each member.

public @interface MyAnnotation {
String doSomething();
int count; String date();
}

There are only three types of simple annotations provided by JDK5
1)Override
2)Deprecated
3)SuppressWarnings

Meta-Annotations (Annotation Types)
Target Annotation - @Target(ElementType.METHOD)
Retention Annotation -@Retention(RetentionPolicy.CLASS)
Documented Annotation - @Documented
Inherited Annotation - @Inherited

From http://www.javabeat.net/articles/30-annotations-in-java-50-1.html
and http://www.developer.com/java/other/article.php/3556176/An-Introduction-to-Java-Annotations.htm

Guice

2010-10-06T12:16:00.001+05:30

Guice provides support for dependency injection using annotations to configure Java objects. Dependency injection is a design pattern with a core principal is to separate behavior from dependency resolution. In other words: a technique for decoupling highly dependent software components.

Dependency injection is a specific form of inversion of control where the concern being inverted is the process of obtaining the needed dependency.

The following is an example. A car (the consumer) depends upon an engine (the dependency) in order to move. The car's engine is made by an automaker (the dependency provider). The car does not know how to install an engine into itself, but it needs an engine in order to move. The automaker installs an engine into the car and the car utilizes the engine to move.

Guice allows implementation classes to be programmatically bound to an interface, then injected into constructors, methods or fields using an @Inject annotation. When more than one implementation of the same interface is needed, the user can create custom annotations that identify an implementation, then use that annotation when injecting it.

Following is an extract from official Google guice site(from http://code.google.com/docreader/#p=google-guice&s=google-guice&t=UsersGuide):-

The dependency injection pattern separates behaviour from dependency resolution. Rather than looking up dependencies directly or from factories, the pattern recommends that dependencies are passed in. The process of setting dependencies into an object is called injection.

Constructor Injection
Method Injection
Field Injection
Optional Injections
requestInjection
Static Injections
Automatic Injection

With dependency injection, objects accept dependencies in their constructors. To construct an object, you first build it's dependencies. But to build each dependency, you need its dependencies, and so on. So when you build an object, you really need to build an object graph.

Building object graphs by hand is labour intensive, error prone, and makes testing difficult. Instead, Guice can build the object graph for you. But first, Guice needs to be configured to build the graph exactly as you want it. Guice uses bindings to map types to their implementations. A module is a collection of bindings specified using fluent, English-like method calls:

The injector's job is to assemble graphs of objects. You request an instance of a given type, and it figures out what to build, resolves dependencies, and wires everything together. To specify how dependencies are resolved, configure your injector with bindings.

Bindings could be 'linked bindings, instance bindings, @Provides methods, provider bindings, untargetted bindings.In addition to the bindings you specify, the injector includes 'built-in bindings'. When a dependency is requested but not found it attempts to create a 'just-in-time binding'. The injector also includes bindings for the providersof its other bindings.

Linked bindings map a type to its implementation.Linked bindings can also be chained:
bind(TransactionLog.class).to(DatabaseTransactionLog.class); bind(DatabaseTransactionLog.class).to(MySqlDatabaseTransactionLog.class);

To enable multiple bindings for a same type, bindings support an optional binding annotation. The annotation and type together uniquely identify a binding. This pair is called a key.

You can bind a type to a specific instance of that type. This is usually only useful only for objects that don't have dependencies of their own, such as value objects:

When you need code to create an object, use an @Provides method. The method must be defined within a module, and it must have an @Provides annotation. The method's return type is the bound type. Whenever the injector needs an instance of that type, it will invoke the method.

You may create bindings without specifying a target. This is most useful for concrete classes and types annotated by either @ImplementedBy or @ProvidedBy. An untargetted binding informs the injector about a type, so it may prepare dependencies eagerly.

@ImplementedBy
Annotate types tell the injector what their default implementation type is. The @ImplementedBy annotation acts like a linked binding, specifying the subtype to use when building a type.

Guice uses annotations to identify scopes. Specify the scope for a type by applying the scope annotation to the implementation class. As well as being functional, this annotation also serves as documentation. For example, @Singleton indicates that the class is intended to be threadsafe.

Workflow

2010-08-20T15:41:00.001+05:30

In operating system workflow is scheduling of independent jobs on a computer. But in general it impliesa set of relationships between all the activities in a project, from start to finish. Activities are related by different types of trigger relation. Activities may be triggered by external events or by other activities. It can also mean the movement of documents around an organisation for purposes including sign-off, evaluation, performing activities in a process and co-writing.

A workflow application is a software application which automates, at least to some degree, a process or processes. The processes are usually business-related, but it may be any process that requires a series of steps that can be automated via software. Some steps of the process may require human intervention, such as an approval or the development of custom text, but functions that can be automated should be handled by the application.

Some examples:
CuteFlow is a webbased document circulation/workflow tool. Users are able to define "documents" which are send step by step to every user in a list. It's an electronical way for doing (i.e. internal) document circulations

The Java Workflow Tooling project (JWT) aims to build design time, development time and runtime workflow tools and to foster an ecosystem of interoperable Business Process Management (BPM) platforms.

YAWL is a BPM/Workflow system. Based on a concise and powerful modelling language, YAWL handles complex data, transformations, integration with organizational resources and Web Service integration. Built in Java, it uses XML Schema and XQuery natively.

The Open Business Engine is a Java workflow engine implementing Workflow Management Coalition Open Standards (WfMC: XPDL, WAPI, Auditing). Highly modular and configurable, it suits J2EE or embedded deployment. Supports integration via Web Services etc.

The 'Workflow' Perl module implements a standalone workflow system. It aims to be simple but flexible and therefore powerful. Each piece of the 'Workflow' system has a direct and easily stated job, and hopefully you will find that you can put the pieces together to create very useful systems.

Bulk transactions

2010-08-10T20:05:00.000+05:30

Sometimes, we might need to insert a huge number of records into database. Such situations can be tricky. Lets consider a scenario where you have to insert say 25000 records in 3-4 tables. There could be some data integrity constraints among these tables. The database cache may not accommodate all the data into it before a commit is executed. In such cases it might be necessary to explicitly commit the data inserted after say every 5000 records. Care should be taken to ensure data integrity between multiple tables. Also, need to think what would happen if the first 5000 inserts are successful and committed but the next 5000 failed. Should the previous 5000 inserts already committed be removed ?

Executing such transactions in one single go could be painful. Usually large amount of insertions are done using batch processes. These are nothing but some special programs set up so they can be run to completion without manual intervention, so all input data is pre-selected through scripts or command-line parameters.(This is in contrast to "online" or interactive programs which prompt the user for such input. A program takes a set of data files as input, processes the data, and produces a set of output data files. This operating environment is termed as "batch processing" because the input data are collected into batches on files and are processed in batches by the program) However, in order to track the failure it is good to maintain logs for such transactions.

SQL joins

2010-07-22T18:40:00.001+05:30

Inner join
================
This is the default join-type. It creates a new result table by combining column values of two tables (A and B) based upon the join-predicate.

The "explicit join notation" uses the JOIN keyword to specify the table to join, and the ON keyword to specify the predicates for the join.

SELECT * FROM employee INNER JOIN department ON employee.DepartmentID = department.DepartmentID

The "implicit join notation" simply lists the tables for joining (in the FROM clause of the SELECT statement), using commas to separate them. Thus, it specifies a cross-join, and the WHERE clause may apply additional filter-predicates (which function comparably to the join-predicates in the explicit notation).

SELECT * FROM employee, department WHERE employee.DepartmentID = department.DepartmentID

Programmers should take special care when joining tables on columns that can contain NULL values, since NULL will never match any other value (or even NULL itself), unless the join condition explicitly uses the IS NULL or IS NOT NULL predicates.

Equi join
===========
An equi-join, sees only equality comparisons in the join-predicate. Using other comparison operators (such as <) disqualifies a join as an equi-join. The query shown above are examples of an equi-join.

Natural Join
===============
A natural join offers a further specialization of equi-joins. The join predicate arises implicitly by comparing all columns in both tables that have the same column-name in the joined tables. The resulting joined table contains only one column for each pair of equally-named columns.

SELECT * FROM employee NATURAL JOIN department

Cross join
============
A cross join returns the cartesian product of the sets of records from the two joined tables. This is the foundation upon which all types of inner joins operate. It equates to an inner join where the join-condition always evaluates to True or where the join-condition is absent from the statement.
SELECT * FROM employee CROSS JOIN department
or
SELECT * FROM employee, department;

Self-join
==============
A self-join is joining a table to itself. For example a query to find all pairings of two employees in the same country is desired. Both employee and country information stored in the same table.

Outer joins
============
An outer join does not require each record in the two joined tables to have a matching record. The joined table retains each record even if no other matching record exists. Outer joins are further classified into left outer joins, right outer joins, and full outer joins.

Left outer join
=================
The result of a left outer join for table A and B always contains all records of the "left" table (A), even if the join-condition does not find any matching record in the "right" table (B). This means that it returns all the values from the left table, plus matched values from the right table (or NULL in case of no matching join predicate).If the left table returns one row and the right table returns more than one matching row for it, the values in the left table will be repeated for each distinct row on the right table.
SELECT * FROM employee LEFT OUTER JOIN department ON employee.DepartmentID = department.DepartmentID

Right outer joins
=====================
A right outer join closely resembles a left outer join, except with the treatment of the tables is reversed. Every row from the "right" table (B) will appear in the joined table at least once. In practice, explicit right outer joins are rarely used, since they can always be replaced with left outer joins (with the table order switched) and provide no additional functionality.

Full outer join
=================
A full outer join combines the results of both left and right outer joins. The joined table will contain all records from both tables, and fill in NULLs for missing matches on either side.

SELECT * FROM employee FULL OUTER JOIN department ON employee.DepartmentID = department.DepartmentID

DB design guidelines

2010-07-12T18:40:00.001+05:30

Following guidelines are useful in most of the database design.

Consider 2 tables A and B

If the relationship from A to B is 1 to 1(one to one)
then either pk of A can be fk in B or vice versa. Ideally, if B is dependent on A, the pk of A should be an fk in B.

If the relationship from A to B is 0:1 to 0:1(one to one, non-mandatory)
then either pk of A can be fk in B or vice versa, but with a nullable fk constraint. Ideally, if B is dependent on A, the pk of A should be an fk in B.

If the relationship from A to B is 1 to 0:N(one to many)
then pk of A is fk in B

If the relationship from A to B is 0:1 to 0:N (one to many, non-mandatory)
then pk of A is fk in B, but with a nullable fk constraint.

If the relationship from A to B is 0:N to 0:N(many to many, non-mandatory)
we need a link entity to contain pk of A and pk of B.

Multiple instances of jvm.

2010-07-09T20:04:00.001+05:30

When 2 java programs containing two main methods are running, actually there are two separate instances of jvm running. Each java.exe launches an instance of jvm. Different instances of JVM are multiple instances of java.exe running on the same machine.

That means when you open two command prompts and run two java programs - "java program1" and "java program2" - there are two instances of jvm running through two separate java.exe.

Castor

2010-07-08T14:13:00.000+05:30

Castor is a framework used for xml databinding. Data can be converted from xml to java object and from java object to xml file through marshalling and unmarshalling. A mapping xml file is used to indicate the java object type and the corresponding xml element or attribute.
Castor XML can marshal almost any "bean-like" Java Object to and from XML. In most cases the marshalling framework uses a set of ClassDescriptors and FieldDescriptors to describe how an Object should be marshalled and unmarshalled from XML.

http://www.castor.org/xml-framework.html

Connecting to db

2010-05-07T14:18:00.000+05:30

There are various applications available to connect to the database such as toad,sqldbx etc.
However, sometimes it is easy to use a plain java class to execute some queries or read some tables for test purposes.Here is a sample code snippet for the same.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class TestDatabase {
public static void main(String args[]) {
try {
Connection databaseConnection = connectToOracle();
// Connection databaseConnection = connectToDB2();
System.out.println("=============Conneted to database======"
+ databaseConnection);
PreparedStatement sqlStatement = databaseConnection
.prepareStatement("SELECT * FROM MYTABLE");
ResultSet resultSet = sqlStatement.executeQuery();
while (resultSet.next()) {
System.out.println(resultSet.getString(1));
}
} catch (Exception e) {
e.printStackTrace();
}
}
private static Connection connectToOracle() throws Exception {
// Ip address for local host. even "localhost" can also be used instead of
// this.
String serverName = "127.0.0.1";
// String serverName = "localhost";
String portNumber = "1521";
// SID is the name of the database. By default the sid is "XE".
String sid = "mydbname";
String url = "jdbc:oracle:thin:@" + serverName + ":" + portNumber + ":"
+ sid;
String username = "myusername";
String password = "mypassword";
Class.forName("oracle.jdbc.driver.OracleDriver");
Connection databaseConnection = DriverManager.getConnection(url, username,
password);
return databaseConnection;
}
private static Connection connectToDB2() throws Exception {
Class.forName("com.ibm.db2.jcc.DB2Driver");
Connection databaseConnection = DriverManager.getConnection(
"jdbc:db2:mydbname", "db2user", "db2password");
return databaseConnection;
}
}

Java mail

2010-05-06T15:14:00.001+05:30

javax.mail package has the APIs to deal with mailing in java.
Here is a very simple example to send email in java.(obtained from example in sun's documentation)

public class EmailTest{
public static void main(String args[]){
Properties props = new Properties();
props.put("mail.smtp.host", "smtp.mycompany.com");
props.put("mail.from", "myemail@mycompany.com");
Session session = Session.getInstance(props, null);

try {
MimeMessage msg = new MimeMessage(session);
msg.setFrom();
msg.setRecipients(Message.RecipientType.TO,
"youremail@yourcompany.com");
msg.setSubject("Just learning how to send email!!");
msg.setSentDate(new Date());
msg.setText("How are you Sir ?");
Transport.send(msg);
} catch (MessagingException mex) {
System.out.println("Email could not be sent: " + mex);
}
}
}

If you have provided proper smtp server name, above code works fine.

JAAS

2010-05-05T11:56:00.002+05:30

Java Authentication and Authorization Service's main goal is to separate the concerns of user authentication so that they may be managed independently.

It is a Java security framework for user-centric security to augment the Java code-based security. Since Java Runtime Environment 1.4 JAAS has been integrated with the JRE - previously JAAS was supplied as an extension library by Sun.

JAAS can be used for two purposes:
1) for authentication of users, to reliably and securely determine who is currently executing Java code, regardless of whether the code is running as an application, an applet, a bean, or a servlet; and
2) for authorization of users to ensure they have the access control rights (permissions) required to do the actions performed.

JAAS implements a Java version of the standard Pluggable Authentication Module (PAM) framework

Some important interfaces and classes include Principal,Key,PublicKey,PrivateKey, Permission, Certificate,Security,Signature,Signer,Provider etc.

http://java.sun.com/j2se/1.4.2/docs/api/java/security/package-summary.html

Reflection in java

2010-05-01T13:38:00.002+05:30

Here is a code snippet that demonstrates reflection in java.

This takes the each class file in the directory ReflectionDemo, checks if there are any public static methods that start with prefix "do" and whether such method is public static and requires no argument. The following code extracts that information and prints the same. It also invokes and executes that method.

ReflectionDemo.java
------------------------------------
import java.io.File;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class ReflectionDemo
{
public static void main(String args[])
{
File pathName = new File("C:\\Documents and Settings\\Ramprasad\\workspace\\Test\\ReflectionDemo");

File[] allFiles = null;;
if(pathName.isDirectory())
{
allFiles = pathName.listFiles();
}
try{
for(int i=0; i< allFiles.length ; i++)
{
String classFile = allFiles[i].getName();
int suffix = classFile.indexOf(".class");
if(suffix != -1 && suffix > 0)
{
String fileName = classFile.substring(0,suffix);
System.out.println("=========The file being parsed is ========"+fileName);
Class classTobeParsed = Class.forName(fileName);
parseClass(classTobeParsed);
}
}
}
catch(Exception e)
{
e.printStackTrace();
}
}

// Lets assume that the class has a method which starts with prefix "do" and such method is public static and requires no argument.

private static void parseClass(Class classTobeParsed)
{
Method[] allMethods = classTobeParsed.getMethods();
try{
for(int i=0 ;i < allMethods.length ; i++)
{
String methodName = allMethods[i].getName();
int modifiers = allMethods[i].getModifiers();
boolean isMethodWithNoArgumentAndNoReturnType = false;
boolean isStatciPublicMethod = false;
Class returnType = allMethods[i].getReturnType();
Class[] getParameterTypes = allMethods[i].getParameterTypes();
if("void".equalsIgnoreCase(returnType.getName()) && 0 == getParameterTypes.length){
isMethodWithNoArgumentAndNoReturnType = true;
}
if(Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))
{
isStatciPublicMethod = true;
}
if(methodName.indexOf("do") != -1)
{
// if the method is static and public it can be invoked. if

(isMethodWithNoArgumentAndNoReturnType && isStatciPublicMethod)
{
System.out.println("There is a public static 'do' method --" + methodName + "-- found in the file --- " + classTobeParsed.getName()+ " and I am going to execute that");

allMethods[i].invoke(null, null);
}
}

else{
// do nothing , following message can be printed if needed. But since there are lot of other methods such as wait,notify,notifyAll, equals etc obtained from Object class, the following line is commented out.
//System.out.println("Current method is ===" + methodName+" but no 'do' method was found in this class --" +classTobeParsed);
}
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
}

The following file exists in the path mentioned above.

Hello.java
----------------------------
public class Hello
{
public static void main(String args[])
{
}
public static void doTesting()
{
System.out.println("===========Finally executed this do method=====");
}
public void doSomething()
{
System.out.println("===========Doing something not static ====");
}
}

Output:
------------------

=========The file being parsed is ========Hello
There is a public static 'do' method --doTesting-- found in the file --- Hello and I am going to execute that
===========Finally executed this do method=====

Source controlling the project artifacts

2010-04-21T17:39:00.001+05:30

Usually all the java files, configuration files, web components, static files and build scripts are source controlled.
It is obvious that jar files should not be source controlled in a project unless it is related to a third party tool. If the jar file contains files related to the project, it should be built throught the build using the class files generated. The source file from which the class files and jar are generated should be source controlled. And of course, the build script too should be source controlled.
The dependency on the third party tools should be externalized. Meaning, the versions should be contained in a separate file (xml or properties or something) and also all the third party related files should be kept under a separate folder say external/lib or something. If the jars are developed internally, are are not something that need to be built each time, it can be put in a folder say internal/lib. This structure helps in reducing the confusion.

SQLite

2010-03-29T12:03:00.000+05:30

SQLite is a light weight database extremely useful for small database execution especially for testing sqlqueries before migrating them to a production database.
There is just an .exe file(for windows) and it plays the entire role. For eachnew database a new file is created and information is maintained there.
It is very easy to use and the documentation is very good.
http://www.sqlite.org/

AnthillPro

2010-03-24T18:52:00.001+05:30

AnthillPro supports automated deployment of a build to a user-configured environment (for example: DEV, QA, STAGE, PROD). Administrators can set up gates between each environment, requiring manual user intervention and providing an audit trail.
The practice of continuous integration is one where developers integrate their changes to a common code line frequently (generally at least once a day) and those integrations are rapidly verified by tests. AnthillPro supports this practice by monitoring (or listening to) the organizations various source control systems and triggering a build when it detects a developer commit. It supports distributed as well as cross-platform builds in .Net, Java, C/C++ and other languages.

It is proprietary software - www.anthillpro.com

Java as a procedural language

2010-02-26T12:31:00.001+05:30

Just like C can simulate OOPs by using the concept of 'struct', can java too have only static methods and private constructors in all classes, pass only primitives and thereby make itself essentially procedural ?

Observer pattern

2010-01-25T14:18:00.000+05:30

Here is a simple code snippet that demonstrates the Observer pattern.

file 1
================

public class ObserverPatternTest {
public static void main(String args[]){
ObserveableTest obTest = new ObserveableTest(6);
ObserverTest observerTest = new ObserverTest(obTest);
System.out.println("Before setting the value to new value");;
obTest.setTestInteger(5);
System.out.println("After setting the value to new value");;

}
}

file 2
==============
import java.util.Observable;
public class ObserveableTest extends Observable{

private int testInteger;
public ObserveableTest(int value){
this.testInteger = value;
}

public int getTestInteger() {
return testInteger;
}

public void setTestInteger(int testInteger) {
this.testInteger = testInteger;
setChanged();
notifyObservers();
}
}

file 3
================
import java.util.Observable;
import java.util.Observer;

public class ObserverTest implements Observer{
Observable observableTester;
public ObserverTest(Observable o){
this.observableTester = o;
o.addObserver(this);
}

public void update(Observable o, Object arg) {
System.out.println("The update method called");

}

}
output after running file 1
============================
Before setting the value to new value
The update method called
After setting the value to new value

RMI

2010-01-25T14:15:00.001+05:30

One classic example for RMI is a project in software services industry.
The analogy can be drawn as follows:
Customer - Client
Onsite Project Manager - Client Helper (stub)
Offshore Project manager - Service Helper (Skeleton)
Offshore Developer - Service

Anyway here are steps to learn RMI
1) Write your remote interface
2) Write your remote implementation (service)
3) Generate stub and skeleton

To generate stub and skeleton invoke the rmic.exe file that comes with jdk
and exists in the bin folder.
You can invoke this exe just by typing its path and supplying the name of
the class for which stub and skeleton are to be created

e.g if MyRemoteImpl exists in the C:\Documents and
Settings\workspace\Test folder and jdk is in the D: drive then,

C:\Documents and Settings\workspace\Test>D:\j2sdk1.4.1_06\bin\rmic
MyRemoteImpl
4) Run the rmiregistry

Rmi registry exists again as an exe
Invoke this exe from the path where your class exists, otherwise it will
throw ClassNotFound exception for the Stub and Skeleton when you try to
run the implementation class

e.g In the above case, it should be
C:\Documents and
Settings\workspace\Test>D:\j2sdk1.4.1_06\bin\rmiregistry.exe
5)Now run the implementation class i.e the service
6) Write a client code and run the same : it can access the service and
display the contents present there.

Below code snipped gives the example

Remote interface
================

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface MyRemote extends Remote {
public String sayHello() throws RemoteException;
}

Remote implementation
=====================

import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class MyRemoteImpl extends UnicastRemoteObject implements MyRemote{

protected MyRemoteImpl() throws RemoteException {
}

public static void main(String[] args){
try{
MyRemote service = new MyRemoteImpl();
Naming.rebind("RemoteHello",service);
}catch (Exception e) {
e.printStackTrace();
}
}

public String sayHello() throws RemoteException {
return "Server says, I am fine";
}

}

Remote client
===================
import java.rmi.Naming;
public class MyRemoteClient {

public static void main(String[] args){
new MyRemoteClient().doIt();
}

public void doIt(){
try{
MyRemote service =
(MyRemote)Naming.lookup("rmi://localhost/RemoteHello");
String s = service.sayHello();
System.out.println(s);

}catch (Exception e) {
e.printStackTrace();
}
}
}
1)From the path where the class file exists run the command "rmic
MyRemoteImpl"
2)From the path where the class file exists run the command "rmirgistry"
3)From the path where the class file exists run the command "java
MyRemoteImpl"
4)From the path where the class file exists run the command "java
MyRemoteClient"

output
==========
Server says, I am fine

*localhost in the above case can be replaced by the ip address of the
machine when running on multiple machines
* If there is a change done in the service, all the steps 1 to 4 should be
executed again to get it reflected
*The stub class must exist on the client side and client invokes the
method on the stub as if it is a real service

Singleton

2009-12-28T20:33:00.001+05:30

Only one instance of that class can exist.

Apporach 1 :
Declare the class as final and have only static methods in that.E.g Math in java library.

Approach2:
Private constructor and a static method and a static flag. Check the flag each time and if not set call the private constructor.

Approach 3:
Have a static flag and check this each time in the constructor and if it is set (this will be set when the object is created for the first time), throw an exception in the constructor.

Approach 4:
Have a private static instance inside the object itself. Have a static method that checks if this instance variable is pointing to null and if yes call the private constructor.
(Normally the static methods that instantiate the singleton object are marked synchronized - yes, static methods can be synchronized)

But there is a clone method unwantedly inherited from the java.lang.Object class which can be used to clone even a singleton object !!!!

By default, the clone() method is marked as protected, but if your SingletonObject extends another class that does support cloning, it is possible to violate the design principles of the singleton. So, to be absolutely positively 100% certain that a singleton really is a singleton, we must add a clone() method of our own, and throw a CloneNotSupportedException

It can be difficult to subclass a Singleton, since this can only work if the
base Singleton class has not yet been instantiated(yes you can call a non static constructor - as if there can be static constructors !! - from a static method).

You can easily change a Singleton to allow a small number of instances where this is allowable and meaningful.

Essentially, there are 3 steps to be followed
1)Block access to all constructors
2)Provide a static method to get an instance
3)Prevent cloning

Manifest.mf file

2009-12-16T15:06:00.002+05:30

· It is a special file that can contain information about the files packaged in a JAR file
· When you create a JAR file, it automatically receives a default manifest file.
· There can be only one manifest file in an archive, and it always has the pathname META-INF/MANIFEST.MF.
· The "meta" information that the manifest can be changed so that JAR file can be used for a variety of purposes.
· Not all files in the JAR file need to be listed in the manifest as entries, but all files which are to be signed must be listed.
· The manifest file itself must not be listed.
· If a JAR file is intended to be used as an executable file, the manifest file specifies the main class of the application.
· The manifest can also contain information about the other files that are packaged in the archive.
· Uses standard syntax for unicode characters.
· Uses standard line length: 72 characters Uses standard encoding: UTF-8
· Uses standard rules for wrapping long lines.
· If the UTF-8 encoded line would exceed 72 characters, the line must be broken at the 72 character mark.
· The remainder of the value should continue on the following line, with a preceding space to indicate that this is a continuation.
· Entries may not be duplicated, except for Class-Path: entries.
· Very lightweight to parse: no need for an XML parser or similar.
· This makes it easier to embed Java into very small devices.
· But there is no utility API to read and write the manifest in the standard Java API, other than the Java Package class

There can be 2 types of attributes

1) Main Attributes
Main attributes are the attributes that are present in the main section of the manifest.E.g Manifest-Version,Created-By,Main-Class etc

2) Per-Entry Attributes
Per-entry attributes apply only to the individual JAR file entry to which the manifest entry is associated with. If the same attribute also appeared in the main section, then the value of the per-entry attribute overwrites the main attribute's value

http://java.sun.com/j2se/1.3/docs/guide/jar/jar.html

Fujaba

2009-12-15T12:09:00.000+05:30

This is a very nice tool for reverse engineering. We might come up with situations where we need to get the modeldiagrams from the available java files. This is a tool meant for that. Easy to use and quite useful to an extent. Download the jar and install using jar command.
http://www.fujaba.de/

Clearcase

2009-12-07T19:34:00.000+05:30

Rational Clearcase is an SCM tool used revision control which supports 2 kinds of models
UCM(out of the box - OOTB) and Base clear case (Customizeable)
UCM is built on top of base clear case.
Can run on a variety of platforms - UNIX,Solaris,z/OS, HP-UX, Windows etc.
Objects under version control in ClearCase are stored in repositories called VOBs (Versioned Object Base).
There are 2 directories used by Clear case
1.CC-project(or something similar) - doesn't need to be shared. This contains the project specific VOB,view.dat file and .updt files
2.views - this directory is shared out and full access granted to everyone including you. Here .vws folders reside.

View is a work area for one (or more) users.Stream determines which versions of elements appear in any view configured
by that stream.Development stream is a working area to make changes in isolation from other development streams and Integration area is to combine changes from different development streams.An element is a file or directory under version control. It will have a tree of versions.If changes are done and discarded a .keep file will be generated for each such file.The act of updating one branch with the changes made in another branch is called merging. If the merging required between the branches is large, then it will ask for manual decision asking which version to select.
Otherwise, most of the times, merging will be done automatically when there are trivial differences.Once a stable configuration is built on the repository a baseline is created. Baseline could be just a baseline or could be a recommended one.If we want to make changes to a file without checking out the file, we can "hijack" the file and work on that.We can "join a project" on clear case and then each time a new baseline is created, we can rebase to get the latest code. Each submission of files(modifying an existing file by checking out and then checking in or adding a new file to the source control) requires an associated "activity" on clear quest. Even for a rebase operation an activity will be created.At any point in time, we can go an check the version history of an element on clear case which appears in the form of a tree.

https://publib.boulder.ibm.com/infocenter/cchelp/v7r1m0/index.jsp?topic=/com.ibm.rational.clearcase.help.ic.doc/helpindex_clearcase.htm

http://www.highley-recommended.com/sw_process/faq.html

Web browser architecture

2009-10-30T15:39:00.004+05:30

(click on the image to enlarge)

(From book 'Building Java Enterprise systems using J2EE' by SAMS - techMedia By Venkata S.R and Paul J Perrone)

Javascript debugger

2009-10-26T15:25:00.000+05:30

Venkman is a good debugger that can be used with firefox.
Very useful in debugging javascript.
https://addons.mozilla.org/en-US/firefox/addon/216

Code policing.

2009-09-24T11:52:00.000+05:30

Code Policing is the task of checking if all the software artifacts adhere to the standards followed in the project/organization. It includes adhering to the best practices, following the coding standards and refraining from the bad coding and logic.
The result of Policing is usually some kind of report (word doc, html etc)which shows warnings as well as errors.(which one should be an error and which one should be a warningis configurable ideally)

Some of the most common things done by code policing tools include :
1)Checking if strings are hard coded in the code.

2)Checking if if-else and for loops are nested too much.

3)Checking if classes/methods are too long (depends on the standards)

4)Checking if variables/methods/classes/files are named according to the standards.

5)Spell checks for comments and code documentations.

Normally, policing tools come with some configuration where it is possible to exclude a list of files that should be excluded. This helps in allowing some exceptions as well.

DOM

2009-08-11T11:14:00.001+05:30

DOM stands for Document Object Model.

It exposes the xml document as a tree structure composed of nodes.
DOM programming interface standards are defined by W3C

This is an interface used to
1. Create a new XML document
2.Read(Parse) an existing XML document
3. Update an XML document

Following are the key objects to remember.

Builder
Document
Element (root or child)
Attribute
Comment
Outputter

JDOM is a java based API for DOM which comes as a part of JDK.
It supports both DOM and SAX parsing.

http://www.jdom.org/

http://www.jdom.org/docs/apidocs/index.html

BMC

2009-08-10T11:26:00.001+05:30

Application Monitoring is an important aspect in software development. BMC is a IT infrastructure management tool that helps in doing so.

For example it can be used to monitor huge web applications with clustered servers in a distributed environment such as

1. Memory utilization - in terms of memory pages of each machine involved in the environment

2.CPU utilization - percentage utilization of cpu associated to each managed server/ admin server

3.Peak CPU utilization and the time when it occurred.

The information can be configured to display in a variety of graphs. This would help in understanding and analysing the production runtime behaviour of the web application and can be further used for load balancing etc. Also, such information helps in understanding the peak utilization of the website (say for a website the maximum utilization is on wednesday and thursday). If one of the managed servers comes to standstill due to peak utilization of CPU, it can be predicted as a cause for the slow response of the website.

WATIJ

2009-08-07T16:38:00.000+05:30

Web Application Testing In Java(WATIJ) is a java API that helps in automating the testing of a web application.Automation is actually an application development whos purpose is to test everything that another application does.

WATIJ features:

It does everything that a web browser can do and verifys the results.
It is free and open source.
Contolling a Container(browser) and a Document(things loaded) is possible.
Only windows and IE are supported currently.

Clover

2009-08-06T17:58:00.000+05:30

Writing proper unit test cases to test all the possible scenarios in a code base is an important aspect to be considered. Normally, in java applications, junits are used for unit testing. However, sometimes it may so happen each line of the code may not be tested if junits are not robust enough. For example, in case of complex if else nesting, only some if-else conditions may be covered by junits but not all possible cases.

One way to make sure, that each line of code to be tested is covered through junits, is to put in debug mode and make sure that debugger passes through each line. However, it may not be practical in case of large code base.

Clover is one such tool that helps in measuring the code coverage.

http://confluence.atlassian.com/display/CLOVER/Tutorial+-+Using+Clover+with+Ant+and+JUnit

It can be configured to generate reports to indicate the code covered by testcases.

Java

2009-07-02T18:14:00.001+05:30

Some info useful for understanding basic java.

Interface:
===================
Every field declared in an interface is public static and final by default always, whether all of these modifiers are mentioned or not.
Each of such field must be initialized. Final, static and public can be put in any order before the data type of the field. There can be any amount of space in between these modifiers. Interface field members can't be protected, private, transient, and volatile.

All the field members in an interface are always constants.

Every method in an interface is public whether mentioned or not. Only other modifier applicable is abstract(though redundant). Interface methods can't be static, final, private, protected, synchronized, native, strictfp.

Interfaces don't have constructors.

Interface method can throw both checked and/or unchecked(though practically doesn't make sense) exceptions. But the implementation methods should bother only about the checked exceptions.

Classes implementing the interface, can overload the methods in the interface. But can't have some static methods with signature same as that of the methods in the interface.

Abstract classes:
==================
Any class can be declared abstract regardless of whether its super class is abstract or not.
A class can't be both abstract and final.
Abstract classes have constructors.
Though they can never be called from outside, the constructors in an abstract class can be overloaded.

An abstract class can have
all or some static members,
all or some private members,
no abstract methods at all,
and all or some final members.

Fields declared in abstract classes need not be necessarily initialized unlike that for interfaces. Such fields take the default values.

If there are abstract methods in an abstract class they can't be private, final, static, strictfp, synchronized or native. But abstract methods can be public or protected.

It is legal to have a subclass as abstract while super class is a concrete class.

Entity relationship cont...

2009-06-05T17:00:00.001+05:30

Here is an example where a same table is linked to 3 tables.
It may appear as though, for every entry in the table A, there should be corresponding entries in the all the 3 tables B,C and D.
But actually, it means that A cannot exist indepedently. For every entry in the table A, thereshould exist an entry atleast in any one of B,C or D.(it could be just one or two or all three of B,C and D)
Such relationships are normally used with tables used to link different tables (called link tables).
Had there been a bubble, before B,C and D, it would mean that an entry in A can exist independently.

Data model cardinalities - very useful in designing db tables

2009-05-28T15:57:00.011+05:30

1.Link This is a 0:0 optional relationship basically stating that a person can occupy one parking space, that I don't need a person to have a space and I don't need a space to have a person. Although the concept is fairly simple, a database can't express it directly. You would need to nominate one entity to become the dominant table and use triggers or programs to limit the number of related records in the other table.

2.SubType This is a 1:0 relationship; optional only on one side. This would indicate that a person might be a programmer, but a programmer must be a person. It is assumed that the mandatory side of the relationship is the dominant. Again, triggers or programs must be used to control the database.

3.Physical Segment This is a 1:1 mandatory relationship and demonstrates a segmentation denormalization. A person must have one and only one DNA pattern and that pattern must apply to one and only one person. This is difficult to implement in a database, since declarative referential integrity will get caught in a "Chicken and the Egg" situation. Basically, this is a single entity.

4.Possession This is a 0:M (zero to many) optional relationship indicating that a person might have no phone, one phone or lots of phones, and that a phone might be un-owned, but can only be owned by a maximum of one person. This is implemented in a database as a nullable foreign key column in the phone table that references the person table.

5.Child This is a 1:M mandatory relationship, the most common one seen in databases. A person might be a member or might not, but could be found multiple times (if the member entity represents membership in multiple clubs, for instance). A member must be a person, no questions asked. The foreign key in the member table would be mandatory, or not-null.

6.Characteristic This is a 0:M relationship that is mandatory on the many side. It indicates that a person must have at least one name, but possibly many names, and that a name might be assigned to a person (might not) but at most to one person. In a database you would have the the name table with a nullable foreign key to the person table and triggers or programs to force a person to have at least one name.

7.Paradox This is a 1:M relationship mandatory on both sides. As with the physical segment situation, the "Chicken and the Egg" is involved since you have to have a person to have citizenship, but citizenship to have a person.

8.Association This is a M:M (many to many) optional relationship. Conceptually, it means that a person might or might not work for an employer, but could certainly moonlight for multiple companies. An employer might have no employees, but could have any number of them. Again, not hard to visualize, but hard to implement. Most solutions of this situation involve creating a third "Associative Entity" to resolve the M:M into two 0:M relationships. This might be an entity called employee because it does link the person to the employer the person works for.

Copied from
http://www.datamodel.org/DataModelCardinality.html

Jadclipse

2009-04-02T11:11:00.001+05:30

Very useful decompiler tool that comes as an eclipse plugin.

http://jadclipse.sourceforge.net/

This is nothing but jad which runs behind eclipse and helps in opening class files in eclipse.

To use this.

1.Copy the in the jadclipse_versionNo.jar file in eclipse\plugins directory.
2.Restart eclipse
3.Go to windows -- > Preferences --> Java -- > Jadclipse(this should be present now after copying the plugin)
4.Give the "Path to decompiler" as the directory where jad.exe exists.
5.Give a directory for temporary files.

Just try to open any class file in eclipse using Ctrl+Shift+T and the decompiled file will open up.

Junit 4

2009-01-29T14:23:00.001+05:30

Junit 4 absolutely depends on Java 5 features.
Will not compile or run with 1.4 or earlier version.

@Test
Mark your test cases with @Test annotations. You don’t need to prefix your
test cases with “test”. In addition, your class does not need to extend
from “TestCase” class.

@Before and @After
Use @Before and @After annotations for “setup” and “tearDown” methods
respectively. They run before and after every test case.

@BeforeClass and @AfterClass
Use @BeforeClass and @AfterClass annotations for class wide “setup” and
“tearDown” respectively. Think them as one time setup and tearDown. They
run for one time before and after all test cases.

Exception Handling
Use “expected” paramater with @Test annotation for test cases that expect
exception. Write the class name of the exception that will be thrown.

@Ignore
Put @Ignore annotation for test cases you want to ignore. You can add a
string parameter that defines the reason of ignorance if you want.

Timeout
Define a timeout period in miliseconds with “timeout” parameter. The test
fails when the timeout period exceeds.

New Assertions
Compare arrays with new assertion methods. Two arrays are equal if they
have the same length and each element is equal to the corresponding
element in the other array; otherwise, they’re not.
public static void assertEquals(Object[] expected, Object[] actual);public static void assertEquals(String message, Object[] expected,
Object[] actual);

JUnit4Adapter
Run your Junit 4 tests in Junit 3 test runners with Junit4Adapter.

2008-10-06T10:50:00.001+05:30

Found this good. I don't remember where I got this image from. Full view can be obtained by clicking on the image.

Internationalization

2008-10-01T12:42:00.000+05:30

When any software application is targeted for clients across the globe, it should always support multiple languages. This feature is called internationalization(i18n), localization or externalization. The application should be designed keeping this in mind in the beginning itself. Except the back-end code which is not shown to the user, everything that is displayed to the user should be internationalized.
Following are the things to be considered.

1. Labels for different fields on the screen

2. Headers,titles,display messages on the screen.

3. Error messages.

4. Validation messages.

5. Drop down values

6. Widget elements
There are even chances that words in same language might have different spellings in different locales. This is also taken care in i18n.

Internationalization is mainly accomplished by externalizing all the files that are shown to the user. This enables the back end code to change independently without bothering about the effect on the displayed texts. Such texts can be put in following types of files.

1. Properties file - a separate properties file with _en,_pt etc is created for each locale and depending on the locale set.

2. XML fil - an xml file will have locale as an element and the messages can be put for the corresponding locale.

3.Java files - this is no very much encouraged approach, however separate java files containing the message strings for different locales can be used, but it would require re-compilation and deployment of class files in the environment whenever there is a change in messages.

4.Using database - database tables can be designed for different locales and messages can be fetched from appropriate tables.

Handling code dependency

2008-09-24T10:32:00.000+05:30

While developing a project, dependency is inevitable. We always have to rely on code being written by others. If a person is in charge of say Contorl part of a project with MVC architecture, he needs Model and view to ensure that his code is working fine.

In such cases,if dependency is not addressed properly, it results in poor integration, poor testing and hence bad quality of deliverables. Developers tend to blame others if their code is not working saying that they never got enough time to test their functionality as the other part
was not available on time.

To avoid such confusions and pressure at the nth moment, one should try to stick to the initial design as much as possible. However, change is unavoidable and even is very good projects the adherence to initial design would not be more than 75%.

One of the ways is to hardcode input values and print the output values for each flow. This can help overcome the dependency on service layer and data access layer and the facade/controller can be tested.

UI part can be tested just by directly hardcoding the values in the screen pages.

If data cannot be inserted through the application, it can be manually inserted in database and the functionality such as deleting/reading/updating can be tested without bothering about the
functionality of creating/inserting data in the database.

Writing unit test cases such as junits is a good way to test the service/data access layer. One need not wait till the UI/facade/controller is ready. This also can be used to test validations.

Validations

2008-09-15T12:09:00.000+05:30

In any application, there will be need for validating the user-entered data. Following are the most common validations.
1. Mandatory validations - A field cannot be left blank. If the field is made mandatory some value must be entered for that field.

2. Date validations - The date and time should be valid. In some cases It cannot be in the past or in the future.

3. Numeric validations - This includes something like value should not be negative,zero or should not be greater than some value, less than something etc.

4. String validations - This includes the maximum/minimum number of characters in the string, whether special characters/space are allowed or not,if alphanumeric characters are allowed or not etc.

5.Cross field validations - This is to validate if some field is entered, some other field should not be left blank.

6.Pattern matching validations - This includes some pattern matching such as the pincode, phone number, some kind of coupon numbers etc where we would validate if the first few characters are letters, next few are numbers and so on.

7. Validating with the database - In some cases, we need to check if the value entered is present in a database record or not. If it is already present sometimes we say it is a duplicate. There can also be scenarios where we would say if the data is not present in the database, we cannot continue.

Database Operations

2008-09-02T18:14:00.003+05:30

The criteria for operation are
1.Is it a single row operation or multiple row operation ? If it is a single row, normally the primary key of the table should be provided. If it is a multiple row operation, some other column value can be provided.(because if the primary key value is provided, it should be provided for all the rows. If any other column value is provided, it is possible that multiple entries(rows) exist for the same column value)

2.Is it a single column operation or multiple column operation ?

3. Is it a single table operation or does it involve multiple tables ?(Involving multiple tables might mean that the tables other than the primary one may be just used for reading values from them, or they also might get modified in the operation)

4.Is there a condition in the operation or if it is a generic operation on the entire table(s) ?

There are following basic database operations.
1.Read

2.Insert

3.Update

4.Delete

======Read======
Reading a single unique entry from a table

You need to provide the primary key value for the table. There always exists only a single result for the given value. A select query with a where clause for primary key column should be used.

Reading single or multiple entries from a table - single value passed

You need to provide the value corresponding to a column in the table. All the entries whose values are equal to the one provided will be fetched. A select query with a where clause for corresponding column should be used.Note that if the column is primary key column then it is same as the previous one.

Reading single or multiple entries from a table - multiple values passed.

You need to provide values corresponding to multiple columns in the table. A select query with multiple where clauses for corresponding columns should be used.

Reading single or multiple entries from a table - no value passed

Here we don't have to pass any value matching any column. The entries in the table will be filtered on some criterion that is not dependent on any input. E.g select all values where a particular column is not null.

Reading all values from a table - no value passed

Here you need not provide anything other than the table name. All values in the table would be fetched. A select query with a * will be used.

Reading single or multiple entries from more than one table - single or multiple values passed

Here we need to provide the values corresponding to the column names of each of the tables involved. These tables must be linked through some common columns or through some common tables. A Select query with single or multiple where clauses and a join for linking the tables through common columns should be used.

P.S: The order of columns is determined while creating the table.E.g columns x, column y are specified while creating a table, column x would appear first and column y would appear next.

==========Insert==========

For insert there is only following options

Inserting a single entry(row) into a table --- values for one or more or
all columns

You need to provide the column name and the corresponding values to be inserted.A simple insert query with column name and values will be used.Inserting multiple entries(rows) into a table --- values for one or more or all columns

Row value constructors are used to insert values into the table. An insert query with values in bracket separated by comma are used. E.g INSERT INTO phone_book VALUES ('John Doe', '555-1212'), ('Peter Doe', '555-2323');

Inserting multiple entries(rows) into a table selecting it from another or same table --- values for one or more or all columns

Here you need to provide the table from where the values are to be selected, the criterion for selection(where clause, or to be more generic, any read operation) and the table and the name of the columns of this table into which values are to be inserted.

Inserting single or multiple entries into multiple tables

Not sure, if this can be done in a single query.

==========Update==========
Updating a single entry(row) into a table --- values for one or more or all columns

You need to provide the primary key value, the column name and the corresponding values to be updated.A simple update query with column name and values will be used.

Updating multiple entries(rows) into a table --- values for one or more or all columns

You need to provide the value corresponding to a column in the table and this would be taken as a criterion to filter the rows to be updated.You also need to provide the new values of the columns which need to be entered in place of old values.All the entries whose values are equal to
the conditional value provided will be updated.An update query with a where clause should be used.

Updating multiple entries(rows) into a table selecting it from another or same table --- values for one or more or all columns

Updating single or multiple entries into multiple tables

Not sure, if this can be done in a single query.

=========Delete==========
Normally delete operations are only for rows and not for columns. If columns are to be deleted, then update should be used.Delete operations are almost always followed by a where clause, otherwise it would delete all the rows.

Deleting a single entry(row) from a table

You need to provide the primary key value.A simple delete query with a where clause matching the primary key would be used.

Deleting a multiple entries(rows) from a table

You need to provide the value of a column.A simple delete query with a where clause matching the column value would be used.

Deleting single or multiple entries from multiple tables

Not sure, if this can be done in a single query. Looks like it can't be except in cases where the tables are related to each other as parent and child.

Junit

2008-08-11T17:13:00.001+05:30

It is a unit testing frame work which is a member of family called xUnit.Created by Kent Beck and Erich Gamma.

At the heart of JUnit is the TestRunner, which comes in multiple forms. They all do pretty much the same thing, however: they take a Test (or collection of Tests), and invoke a method called run(junit.framework.TestResult).

Test is an interface. There are two basic implementations of Test that we need to concern ourselves with: TestSuite and TestCase.

A TestSuite, essentially, is a collection of TestCases.The TestCase is where the action all happens! The run() method takes a parameter, called the TestResult. The TestCase
method deals with the run method, inside a method called runBare(). A test will fail if an exception propogates outwards. Exceptions of a particular type (the AssertionFailedError) are recognised as test failures; other types of exceptions will get marked as errors.We can define our own runTest() method if we like.

While writing test cases we generally extend the class TestCase. Normally, for this an abstract class would be provided for a project. All the Junits in the project would be categorised based on module and each one would extend this abstract class to test the behavior. This abstract class would do common things like - initialise the database, set the locales, load the necessary properties, increase the cache size and other similar configuration related things)

All previous versions of JUnit use naming conventions and reflection to locate tests.By contrast, in JUnit 4, tests are identified by an @Test annotation. The advantage is that method names need not start with the word "test" and the class need not extend TestCase. The annotation @Test would suffice. @Before, @After are other annotations introduced in Junit4.

Networking basics - a brush up 2

2008-06-10T12:12:00.003+05:30

DHCP - This is a protocol used by the client network devices to obtain various parameters necessary to operate in the IP network.By using this protocol, system administration workload greatly decreases, and devices can be added to the network with minimal or no manual configurations.The Dynamic Host Configuration Protocol (DHCP) automates the assignment of IP addresses, subnet masks, default gateway, and other IP parameters.When a DHCP-configured client (be it a computer or any other network-aware device) connects to a network, the DHCP client sends a broadcast query requesting necessary information from a DHCP server. The DHCP server manages a pool of IP addresses and information about client configuration parameters such as the default gateway, the domain name, the DNS servers, other servers such as time servers, and so forth. Upon receipt of a valid request the server will assign the computer an IP address, a lease (the length of time for which the allocation is valid), and other IP configuration parameters, such as the subnet mask and the default gateway. The query is typically initiated immediately after booting and must be completed before the client can initiate IP-based communication with other hosts.

DNS - Domain Name System is like a phone book which maps the complex, difficult to remember IP addresses into easily rememberable domain names. E.g 208.77.188.166 can be translated in to http://www.dnsexample.com/. It also stores other information such as the list of mail servers that accept email for a given domain.

MAC - Media Access Control address is a number that serves as an identifier for a particular network adapter. Thus network cards (or built-in network adapters) in two different computers will have different MAC addresses,However, it is possible to change the MAC address on most of today's hardware, often referred to as MAC spoofing.It is also called Ethernet Hardware Address (EHA) or hardware address or adapter address.

ISP - An Internet service provider (ISP, also called Internet access provider or IAP) is a company or business that provides access to the Internet and related services.ISPs employ a range of technologies to enable consumers to connect to their network.For home users and small businesses, the most popular options include dial-up, DSL (typically Asymmetric Digital Subscriber Line, ADSL), broadband wireless, cable modem, fiber to the premises (FTTH), and Integrated Services Digital Network (ISDN) (typically basic rate interface (BRI).For customers who have more demanding requirements, such as medium-to-large businesses, or other ISPs, DSL (often SHDSL or ADSL), Ethernet, Metro Ethernet, Gigabit Ethernet, Frame Relay, ISDN (BRI or PRI), ATM, satellite Internet access and synchronous optical networking (SONET) are more likely. With the increasing popularity of downloading music and online video and the general demand for faster page loads, higher bandwidth connections are becoming more popular.

VPN - A virtual private network (VPN) is a computer network in which some of the links between nodes are carried by open connections or virtual circuits in some larger network (e.g., the Internet) instead of by physical wires.It is used for secure connections in the public internet but a VPN need not have explicit security features, such as authentication or content encryption.The distinguishing characteristics of VPNs are not security or performance, but that they overlay other network(s) to provide a certain functionality that is meaningful to a user community.

Wi-fi - Wireless Fidelity is a wireless technology standard that is supported by most of the mobiles,operating systems,networks and games.Power consumption is fairly high compared to some other low-bandwidth standards. A typical Wi-Fi home router using 802.11b or 802.11g with a stock antenna might have a range of 32 m (120 ft) indoors and 95 m (300 ft) outdoors. Range also varies with frequency band.

Bluetooth - This is a wireless protocol that utilise short range communications technology. Both voice and data can be transmitted over short distances to create PANs(Personal Area Networks). It is intended to connect multiple devices such as mobiles, computers/laptops, printers, digital cameras etc.It consumes comparitively less power and transmission range is also short(1m - 10m). It uses 2.4 GHz short-range radio frequency bandwidth.

Spread spectrum - This is a technology in which energy generated in a particular bandwidth is deliberately spread in the frequency domain, resulting in a signal with a wider bandwidth. These techniques are used for a variety of reasons, including the establishment of secure communications, increasing resistance to natural interference and jamming, and to prevent detection

Frequency Hopping - This is a method of transmitting radio signals by rapidly switching a carrier among many frequency channels, using a pseudorandom sequence known to both transmitter and receiver.These are resistant to narrowband interference and are difficult to intercept,

PSK,BPSK,QPSK - PSK is a digital modulation scheme that conveys data by changing, or modulating, the phase of a reference signal BPSK uses two phases which are separated by 180° and so can also be termed 2-PSK.This modulation is the most robust of all the PSKs. It is, however, only able to modulate at 1 bit/symboland so is unsuitable for high data-rate applications when bandwidth is limited. If there are four phases, it is called QPSK which can encode two bits per symbol. Other PSK techniques include OQPSK,DPSK,FQPSK and pI/4 QPSK.

Networking basics - a brush up 1

2008-05-28T11:44:00.003+05:30

Routers -- it is a combination of hardware and software which is used forforwarding the information. They contain the specialised operating system,processor memory etc inside that. They are used for providing connectivity within enterprises or between and enterprise and internet.There are different types of routers used for a variety of purposes.

Network switches - are devices that are used for connecting networksegments.They can operate on multiple OSI layers such as physical,datalink,network and transport layers. So the word switch is a generic marketing term. For example router is a swith at layer 3 and hub is a switch at layer 1.

Network Hub -- also called concentrators connect multiple network segements at physical layer.It is becoming obsolete nowadays and switches are used instead.

Ethernet - A type of network technology for local area networks where coaxial cable carries radio frequency signals between computers.It defines a number of wiring and signaling standards for the physical layer.The coaxial cable is now replaced with point-to-point links connected by Ethernet hubs and/or switches to reduce installation costs, increase reliability, and enable point-to-point management and troubleshooting.

Modem --- stands for modulator/demodulator. It is a device used for modulating some information on a carrier signal and demodulating the same to get the original information back.They are normally classified based on the amount of data they can transmit or in terms of baud rate.(baud is not modems speed)The most familiar example is a voiceband modem that turns the digital 1s and 0s of a personal computer into sounds that can be transmitted over the telephone lines of Plain Old Telephone Systems (POTS), and once received on the other side, converts those 1s and 0s back into a form used by a USB, Serial, or Network connection.

IP address -- it is a unique id associated with every computer in the network.Any participating network device—including routers, switches, computers, infrastructure servers (e.g., NTP, DNS, DHCP, SNMP, etc.), printers, Internet fax machines, and some telephones—can have its own address that is unique within the scope of the specific network. Some IP addresses are intended to be unique within the scope of the global Internet, while others need to be unique only within the scope of an enterprise. In the current standards, IP address need not be a unique identifier always because of the technologies such as dynamic assignment and NAT.On the public Internet (as opposed to private internets or intranets), IP addresses are managed and created by the Internet AssignedNumbers Authority (IANA). The IANA generally allocates super-blocks to Regional Internet Registries, who in turn allocate smaller blocks to Internet service providers and enterprises.IPV4 is the latest version of standards which uses 32 bits(4 bytes).This limits the number of addresses to 2 to the power of 32. However some of these reserved for special purposes.

NAT -- Network Address Translation first became popular as a way to deal with the IPv4 address shortage. This technique involves taking the networktraffic through a single IP address through a router and re-writing the source and destination IPs mostly in a private network.

Gateways - are also called protocol converters. They can operate at any layer of the OSI model.Typically, a gateway must convert one protocol stack into another.A gateway may contain devices such as protocol translators, impedance matching devices, rate converters, fault isolatorsor signal translators as necessary to provide system interoperability.Routers exemplify special cases of gateways.

Firewall - is a device for controlling the network traffic. It can permit, deny, encrypt, or proxy the traffice based on a configured set of rules. More or less like a traffic police controlling the traffic on road.

Factory Patterns

2008-04-28T11:57:00.001+05:30

There are mainly 3 types of factory patterns which are kind of similar and hence sometimes lead to confusion.

Simple Factory

Here you just decouple the creation of object. The class whose object needs to be created using simple factory will not have a public constructor. Instead it provides a static method with name like "newInstance" or "createInstance" or something similar. This method would create an object and return it. While returning a generic type of the object (an interface or abstract class) is used as a return type. Depending on the input parameters, the static method can return different
types of objects which extend of implement the generic type. This decouples the direct usage of new operator which needs to be changed for different implementations.

There is one other interesting technique in simple factory. We declare the class as abstract though it doesn't have any abstract methods inside it. This is because when it is abstract you cannot instantiate it directly. We extend this abstract class and provide an implementation which just has a static method and instantiates the object. This enforces the client to use the factory for instantiation rather than the new operator.

Small Note : The disadvantage with static method is that it cannot be overridden further by extending it.Static methods are implicitly final, because overriding is done based on the type of the object, and static methods are attached to a class, not an object. A static method in a
superclass can be shadowed by another static method in a subclass, as long as the original method was not declared final. However, you can't override a static method with a nonstatic method. In other words, you can't change a static method into an instance method in a subclass.

Factory Method Pattern

Consider,
1. An interface X.
2. Concrete classes X1 and X2 which implement the interface X.
3. An abstract class A with two methods m1 and m2. Method m1 has
implementation and m2 is an abstract method which should be implemented by
the extending classes. Method m1 is exposed to the client. Method m1 calls
method m2. Method m2 has a return type X.
4. A1 and A2 are concrete classes which extend the abstract class A. So they have to provide implementation for the abstract method m2. Method m2 in A1 would return X1. Method m2 in A2 would return X2.

The above one is a simple scenario and it can be extended for multiple implmentations of the interface X and multiple extensions of the abstract class A.

Abstract Factory pattern
Consider,
1. Two interfaces - interface X and interface Y
2. Concrete classes X1 and X2 which implement the interface X and concrete classes Y1 and Y2 which implement Y
3. An interface A which would have two methods viz: createX which has a return type X and createY which has a return type Y.
4. Two concrete classes A1 and A2 which implement the interface A. When the two methods createX, createY are to be implemented, A1 would have return type X1 and Y1 for the two methods respectively.A2 would have return type X2 and Y2 for the two methods respectively.

The above one is a simple scenario and it can be extended further with multiple implementations for the interfaces A,X and Y.

Obfuscators

2008-04-23T12:28:00.000+05:30

There is always an element of fear for developers that their code might be reverse engineered. In java there are lot of decompilers available to get a fairly sensible and understandable source code from the class files. Though very few techies have this kind of patience to reverse engineer the class files to get the source back, the possibility cannot be denied.
Here comes the help from obfuscators. They operate on the source code and change the compiled code to confusing class files and thereby make it almost impossible to reverse engineer the classes even for the most intelligent decompilers.

http://en.wikipedia.org/wiki/Obfuscated_code
http://java-source.net/open-source/obfuscators

Classdocs

2008-04-21T19:00:00.003+05:30

Java doc is very useful in understanding the overall architecture and even the details of the framework/application. But generally we generate java docs only for the sources. Suppose we have a jar file provided by someother party and we don't have the java doc for that. How do we understand what is there inside the jar ? (Ideally, we don't need to know it if java doc is not provided. But still for curiousity we may want to know how it is written.)

One way is to extract all the class files in that jar and use a decompiler to get the source back.But this is bit tedious and also we might not want to know all the details inside the class file but only the overall structure and relation between different parts.In this case a javadoc for the jar would have helped a much.

A tool called classdoc helps here. It is just another jar file. All we need to do is run java command providing this jar file for -cp, and the path of the jar file for which we want a java doc. Of course there are a few of other parameters such as target for generated java docs, the title for the java docs etc. This provides a crude javadoc for the classes in the jar file.

Here is how to run it.Download it from the link http://classdoc.sourceforge.net/
Extract it to a convenient place.Note the path of the jar files for which you want the java doc. Also note the target where you want to put these generated java doc.
Give the command which looks something like the following,

java -cp %JAVA%\lib\tools.jar;F:\mine\classdoc\classdoc.jar;F:\mine\classdoc\jmxtools.jar classdoc -docpath F:\mine\classdoc\jmxtools.jar -private -d F:\mine\classdoc\target -windowtitle "simple test" -header "header" -verbose

classdoc.jar is required for generating the java doc and jmxtools.jar is the jar file on which the experiment is executed. Target is the folder where the java docs will be generated. The parameter "private" indicates that java doc should be generated for private members.

It is not foolproof and doesn't have any warranty also, but it is conceptually a great software.

Screen Recorder

2008-04-18T18:57:00.001+05:30

Found this very useful, to describe what has happened in the system.It is Just like we use the printscreen, we have the animation here.

http://www.sameshow.com/democreator/article/demo-creator-article-2.html (trial version)

Install the application (it is really simple)

Have the application which you want to run open.Click on democreator icon created on your desktop.

Select "By capturing screenshots" option.Do whatever you want on your application which you had opened before launching demo creator.

When you want to stop press F10.

You have the demo ready now. Publish it and it will be saved on your computor. You can view this as an html with shockwave flash object.

There are many other powerful features available with Demo creator.

We can custom the size of the window.Then the animation will appear in the size we wished with a progressbar (just like we use windows media player minimized).

Or we can even use the full screen option as well. In this case the it will appear just like the first option - i.e running the application. But demo creator will be running silently and we can do whatever we wish on the computer and everything gets recorded.

JMS

2008-04-08T11:43:00.003+05:30

Messaging means exchanging information. When different software components live in different environments, they need to communicate with each other. It could be a tightly coupled communication or a loosely coupled communication.

In the first one, the components know each other, i.e who is the sender and who is the receiver.So they communicate direclty. Examples for this kind of communication are CORBA,RMI, TCP n/w sockets.

In the second type of communication,i.e the lightly coupled communication, there is an intermediate component coming in between the communicating entities. So the sender and receiver do not communicate directly, instead they use another entity in between.

JMS falls in the second category. It is java's standard for Message Oreinted Middleware (MOM) service which is essential in enterprise applicaton.

It should be notee that, just like any other j2ee specification, JMS is onlya standard for messaging. The vendors would provide this service. But the components which intend to usethis service can call the standard interfaces to get their work done, without least bothering about how the implementation is done.

All Java EE application servers from version 1.4 and later are required to contain a JMS provider.

Following entities are conceptualized.
JMS provider --- this is the one which provides messaging service
JMS clients ---- these are entities which produce and consume messages
Messages ---- information is sent and received as messages

Messaging can be done in 2 ways.
1.Point to point (PTP)
2.Publish and subsribe(Pub/Sub)
Here comes the interesting part.
In PTP, there is a client which wants to send a message to another client. It would put it in an entity called "queue" meant for the intended client. The client might be off when the message was put in its queue. But when client wakes up and checks its queue, it would get its message and send an acknowledgement back.Here every message is sent to the queue of the intended client separately. Or only one client is supposed to receive the message sent. It can be imagined as a postman putting the letter in the post box attached to the door of the clien't house. PTP messaging is used when every message sent must be processed by one consumer.

In the Pub/Sub model, there is a particular topic on which interested clients can publish messages or subscribe for messages. Here normally neither publishers nor the subscribers know each other.The message provider would take care of sending the messages belonging to a particular topic coming from multiple publishers to multiple subscribers. Once the messages are sent to all the concerned subscribers, the particular message in the topic is not retained.
Pub/sub messaging is used when each message can be processed by zero,or many consumers.
Each JMS provider would have a JNDI name. Any java class can connect to any JMS provider using the JNDI info for that. It would further use the ConnectionFactory to get the connection to a particular Topic or Queue.

Following are the important concepts (interfaces)
1.ConnectionFactory - You ask for a connection by specifying its JNDI name and this will give you. The connection could be to a topic or queue. The corresponding connection factory can be used.
2.Connection --If you have the Connection means you have established a communication with the JMS message provider product and you can start doing what all you want - it could be creating session, sending a message or receiving a message to and from a queue or topic. Again we have corresponding connection objects for queue and topic
3.Destination - This represents an entity where the messages are supposed to reach. It could be a queue or a topic accordingly.
4.Message Consumer -- This entity eats up the message sent to it. In case of Queue it is QueueReceiver and in case of Topic it is TopicSubsciber(Note that this is different from Destination in the sense, destination represents where a message should reach and stay, the consumer is the one who grabs the message sitting there in the destination)
5.MessageProducer -- This is the one that generates the message and sends it to the destination (Queue or Topic). We have accordingly QueueSender and TopicPublisher.
6.Message - this is the entity which actually moves here and there.It could be textmessage,bytemessage,stream message etc.
7.Session -- Represents context for sending and receiving the messages.
Represents a single-threaded context for sending and receiving messages. A session is single-threaded so that messages are serialized, meaning that messages are received one-by-one in the order sent. The benefit of a session is that it supports transactions. If the user selects transaction support, the session context holds a group of messages until the transaction is committed, then delivers the messages. Before committing the transaction, the user can cancel the messages using a rollback operation. A session allows users to create message producers to send messages, and message consumers to receive messages.

http://java.sun.com/products/jms/tutorial/1_3_1-fcs/doc/basics.html http://en.wikipedia.org/wiki/Java_Message_Service

Servlets

2008-03-31T10:21:00.004+05:30

We can imagine servlets as entities which can live in their own world called servlet containers. Their job is to serve those who come to them asking for some kind of service. The service is normally providing the information seekers ask.

We can create some of our own servlets who can live in their world of servlet container. There are vendors who can provide a ready-made servlet containers just like we get an aquarium for fishes.

The technology has concepts(interfaces) as follows:

Servlet These are the basic entities for whom servlet container is created. Servlets experience following things in their life. They are born (init method), they have to serve their clients (service method), and one day they will die (destroy method).Moreover each servlet would have its own info - by whom,when why etc it was created. This can be obtained by getServletInfo() method.This is just an information.It would also have its intial configurations such as how it was created, what all went in while giving birth to it etc. This can be obtained by getServletConfig() method.

Servlet Config. This has all the details, that went in to give birth to a servlet.What was the name of the servlet ?(getInitParameterNames)What all things were used to create the servlet ? (getInitparameters)What was the environment(servlet container) where it was born ?
(getServletContext method)

ServletContext This tells each servlet, what is happening in the servlet container where it is living.

ServletContextAttributeListener He is a guy, who keeps listening to check if anything is added or removed in the servlets' world. If you request this guy, he will keep you updated as and when he finds something interesting.

ServletContextListener He is a guy, who keeps listening to few changes happening in the servlets' world. He can tell you if the servlets' world is ready with servlets to do the job or it is destroyed.If you catch hold of this guy and ask him to update you, he will promptly inform you when anything happens there. You need not check yourself periodically to see what is happening because, this guy's job is to keep listening constantly and inform others.

ServletRequest This represnts the things as a whole that seekers are asking a servlet to provide. The request might contain lot of information. The access to all such infomation can be obtained if you get hold of this servletrequest.

ServletResponse This is a pack that contains things returned by servlet to its service seeker. What all did the servlet return to its client , get hold of this servletresponse.

SingleThreadModel This is a special category of servlets, which you can create. Normally, a servlet is designed to handle things asked by many of its clients, simultaneously. But sometimes, it gets confused, if too many clients are asking it to do too many things simultaneously. In such cases it will mess up the things. So, to avoid this you can create special servlets which handle only one thing at a time.If one more client asks to do one more thing meanwhile, it would first complete what it is currently doing and then come to this new request. No doubt, this might make the clients angry due to the delay caused, but some servlet containers expect this, and hence makes sure that a lot of identical servlets are available in the pool. Though each can do only one thing at a time, there will be others to handle multiple requests and that would solve the hectic workload.

Filter This is a kind of gate keeper, who keeps observing what is coming in and what is going out from the servlets' world.This is brought into existence by the servlets world with appropriate initialization parameter provided by FilterConfig. When this is not required, the container would destroy the same.While filtering, the filter would need to know what is the request, what is the response(in the sense for which request and response comibination the filtering needs to be applied) and what are the filters in the filter chain for the same request and response. (A chain of filters can be applied for a given request response pair and each filter in the chain needs to know the name of the chain of which it is a part)

FilterChain This is available in the servlets's world if you want to know all the filters in the chain of filters. The ordering of filters is controlled by the descriptor files.

FilterConfig When a filter is to be created in the servlets world,the container needs this to know some information about the filter. using this, you can get to know the information such as servletcontext, filtername, initialization parameters etc.

RequestDispatcher This is a broker kind of guy, whose job is to get the request from the client and pass it to the appropriate entity. In most of the cases it is servlet, but it can be passed to other entities such as jsp etc which live in the same world where servlets live.

http://www.onjava.com/pub/a/onjava/2001/05/10/servlet_filters.html

ServletException If there is any problem with a servlet, it will complain by shouting this
kind of exception.

UnavailableException If a servlet is not willing to serve, or not ready or not finding something or anything like that which results in its unavailability of its service, this exception is thrown.

Following are little bit more concrete concepts(abstract classes) which have a vague body

GenericServlet(abstract) This is a vague servlet which doesn't know what kind of protocols it can handle, but has got a skeleton to know what is the purpose of its existence and what all it is supposed to do. It doesn't know how to do it.

ServletContextAttributeEvent This guys job is to shout if there are any changes happened to the members of servlet context. There is a listener(ServletContextAttributeListener)
to listen when he shouts.

ServletContextEvent This guy also shouts if there are any changes that took place in the
servlets world. He has got a guy(ServletContextListener) to listen to him as well.

ServletInputStream(abstract) This is a stream which gets the data coming from the client. If you want to read the actual bits of data coming from client, this stream has that in it.

ServletOutputStream(abstract) Same as input stream but only change is that it is associated with output data.

ServletRequestWrapper A prototype that wraps a servlet request object.The concrete servlet request implementation too is packed inside this wrapper object.

ServletResponseWrapper Same as above,except that it wraps the response. This guy also shouts if there are any changes that took place in the servlets world. He has got a guy(ServletContextListener) to listen to him as well.

ServletInputStream(abstract) This is a stream which gets the data coming from the client. If you want to read the actual bits of data coming from client, this stream has that
in it.

ServletOutputStream(abstract) Same as input stream but only change is that it is associated with output data.

ServletRequestWrapper A prototype that wraps a servlet request object.The concrete servlet request implementation too is packed inside this wrapper object.

ServletResponseWrapper Same as above,except that it wraps the response.

Abstraction and Encapsulation

2008-03-27T18:22:00.003+05:30

When I say “chair”, as a common man, you imagine a chair which can offer itself for you to sit.
Or do you imagine the wooden or iron molecules/atoms/protons/electrons/mesons and neutrons constituting the chair ? No right ?
This is what exactly abstraction is. The idea is derived from an ancient concept by Plato who had a platonic idea.i.e the concept of a chair is a separate entity from any particular chair.
In other words, we can conceive of a chair in the abstract without thinking of any particular chair.
Abstraction -- A concept or idea not associated with any specific
instance.(definition from wiki)

That is how we design an abstract class or abstract method. Abstract means we have a vague idea, what it does, but you don't have a clear picture how exactly it should be done. So normally when a system or framework is designed, it starts with interfaces and abstract classes.

Another useful example to illustrate abstraction is the naming ofconstants. Suppose we want to use the number 7 to indicate the no of days in a week. We abstract the value 7 by giving the constant name as noOfDaysInWeek. Because, if you just use 7 directly, the person reading
the code might not be able to understand why 7 is used there. Here abstraction makes a better understanding of what is happening.Encapsulation is the term as an implementor one should be aware of. How much details should be made visible and accessible to the person going to use that artifact. This helps in replacing the whole object instead of worrying about what all are there inside and leaving that to experts in that.Example, when a TV is to be repaired, the whole TV can be replaced
for the end user, without bothering him about the devices encapsulated in that. The experts will further dig in to find out, which component encapsulated in the TV is not working. Definitely there would have been a havoc if the TV was uncovered, leaving all its spare parts accessible to
everyone.
Headfirst java book calls any class that has its attributes public as a naked class and tells that it is dangerous to expose all the attributes to the external world. Hence encapsulation is a must.
Encpsulation is all about how much should be made visible and accessible to the external world. This concept helps very much in oops.
So abstraction is related to the design or imagining a system of objects but encpsulation is about implementation of a particular object.Abstraction is a design concept while encapsulation is an implementation technique.
http://en.wikipedia.org/wiki/Abstraction_(computer_science)

J2EE

2008-03-25T10:18:00.000+05:30

Any software comprises of 2 things.
1.A runtime where a software can exist,run and live(Also called Host).
2.Different components that together make an integrated bundle of software components which is set to exist and funtion on its target runtime.

The real world analogy could be something like this. There is sound and its existence makes sense to us only if there are ears. Smell exists only because there is nose. For every entity there is a corresponding entity which can sense its presence and make its existence worthwhile. The same logic is applicable in the software world. Every software exists because, there is another software/hardware to host it or detect it. Or rather, it was created targetting to live on something existing. That gets into a kind of philosophy, if we think deeper anyway !!

Interestingly, as you move up building softwares on top of another existing software/hardware, eventually there is a possibility of creating a host as well as the component from the same material.

J2EE is also conceived on the same logic. Here the components as well as the container are made of JAVA.

J2EE is a standard, that tells what kind of components can exist in what kind of containers and what all they can do. Of course this is standardization is reached based on the common requirements for building enterprise applications. This standardization is very important because, when a programmer develops some j2ee component for some purpose, he can deploy it on any of the concerned container that complies to j2ee standard.

J2ee specifications just mention what all standard services the container should provide for what kind of components. How it should be done is left to the container. This gives the flexibility and tremendous scope for imagination for vendors. This also means a great opportunity to build a product.

J2EE has the following things to understand
1.Container --- web container, EJB container
2.Component technologies --- servlets,Jsps,EJBs
3.Service technologies ---- JMS,JDBC,JTA

Batch Files

2008-03-20T15:35:00.000+05:30

It is a file containing a series of commands to be executed by command interpreters of MS-DOS and Windows. These files normally end with the extension such as .bat .cmd .btm.
Batch files are useful for running a sequence of executables automatically and are often used by system administrators to automate tedious processes.

There is no difference between the .BAT and .CMD extensions when the file is directly executed. However, when a shortcut is used to launch them, .BAT files run commands using the 16-bit COMMAND.COM command processor whereas if the extension is .CMD, the batch commands are run using the 32-bit Windows NT cmd.exe with all command extensions enabled. Also, the
Windows 9x family only recognizes .BAT extension.
(Source: http://en.wikipedia.org/wiki/Batch_file)

I guess following commands should be sufficient to write most of the batch files.

@echo off

rem

if not

if exist
set

call setlocal

endlocal

echo

exit

cd
goto :label

:label
http://www.ss64.com/nt/

FindBugs

2008-03-19T14:18:00.000+05:30

FindBugs is an interesting open source program which looks for bugs in Java code. It uses static analysis to identify hundreds of different potential types of error in Java programs. FindBugs operates on Java bytecode, rather than source code. It includes both a stand alone GUI and
an Eclipse plug-in.
http://findbugs.sourceforge.net/bugDescriptions.html

Installing findbugs plugin with eclipse.

Download, the plugin from sourceforge.net and copy the folder in the eclipse plugins folder.(Make sure that the plugin is meant for the eclipse version you have.Otherwise it will not work)
Go to window -> preferences --> general --> perspectiveYou can see findbugs icon there. That means it is installed.Now when you go to any package or java class in your project explorer and
right click, you can see the option called Find Bugs.

Some examples of potential bugs identified by findbugs.

1.Invoking System.exit shuts down the entire Java virtual machine. This
should only been done when it is appropriate. Such calls make it hard or
impossible for your code to be invoked by other code. Consider throwing a
RuntimeException instead.

2.Never call System.runFinalizersOnExit or Runtime.runFinalizersOnExit for
any reason: they are among the most dangerous methods in the Java
libraries.

Environment Variables

2008-03-18T11:10:00.000+05:30

Environment variables can be thought of as certain pointers on the surroundings where the softwares run.It normally tells what exists where. For successful compilation and running, normally softwares should take help from some other tools and softwares already existing in the system. The environment variables provide this information.
In certain operating systems like Unix, each process can have its own set of private environment variables. All the child processes would have access to this.
In Unix, the environment variables are normally initialized during system startup by the system init scripts, and hence inherited by all other processes in the system. Users can, and often do, augment them in the profile script for the shell they are using. In Microsoft Windows,
environment variables defaults are stored in the windows registry or set in autoexec.bat.(Ref:http://en.wikipedia.org/wiki/Environment_variables)
http://support.microsoft.com/default.aspx?scid=kb;en-us;310519

Widgets

2008-03-17T14:07:00.000+05:30

Widget (or control) is an interface element that a computer user interacts with, such as a window or a text box.

Widget is a virtual object just like any visible physical object in the real world.So theoritically we can have as many widgets as there are seeable perceivable objects around us.It is again upto our imagination - how anew widget can be created and made available in the graphical world.

List of common most commonly used widgets.
Selection and display of collections
1.Button (Toggle,Check box,Radio button )

2.Slider

3.List box

4.Spinner

5.Drop-down list

6.Menu (Context menu ,Pie menu )

7.Menu bar

8.Toolbar

9.Ribbon

10.Combo box (text box with attached menu or List box)

11.Icon

12.Tree view

13.Grid view

Navigation
1.Tab

2.Scrollbar

Text input

1.Text box (edit field)

2.Combo box (text box with attached menu)

Output
1.Label

2.Tooltip

3.Balloon help

4.Status bar

5.Progress bar

6.Infobar

Containers

1.Window

2.Modal window

3.Dialog box

4.Palette window, (or"Utility window" )(Inspector window,Drawer Heads-up display, similar to HUD (computer gaming)

Antipattern

2008-03-14T16:07:00.000+05:30

We invent something, get excited and find it very useful. So we standardize it.We start using it everywhere. But slowly we realise that the disadvantages by using this practice is outweighing the disadvantage of not using it. So better not to use it.
This is called antipattern.
Anti-patterns are specific repeated practices that appear initially to be beneficial, but ultimately result in bad consequences that outweigh the hoped-for advantages.

Scripting and Programming Languages

2008-03-13T12:40:00.001+05:30

This is an arguable topic.
A scripting language operates on an existing application. But programming language is used to write an independent application.Some people argue that programs that can create binary executables and consume memory are fit to be called a programming language. But scripts are never converted to anything and each time they are read and interpreted.
ActionScript,javascript are scripting languages.C,Java are programming languages.
http://www.killersites.com/blog/2005/scripting-vs-programming-is-there-a-difference/

JAR-WAR-EAR

2008-03-12T10:42:00.000+05:30

Ear stands for Enterprise Archive

It is a packed form of J2EE application with various modulesIt can be deployed on an J2EE application server and all the modules will be deployed simultaneously.Deployment descriptors in the EAR file would tell the appserver how to deploy various modules.
In fact ear file is actually a jar file only with a different extension.Typically an Ear would contain following1. A .war file - a web module2.jar files containing java classes3.A .rar file - Resource Adapter or java connectors.4.Deployment descriptor xml files5.Vendor specific files

WAR stands for Web archive.

This is a package of web components that can be deployed on a web container.Typically it contains1.JSPs2.Servlets3.Java classes4.XML5.Tag libraries6.Static web pages (HTML)

Jar file stands for Java Archive
It is a file that bundles many java classes and associated meta data into one. This makes it easy for distribution.
JAR files can be created and extracted using the "jar" command that comes with the JDK.
A JAR file has an optional manifest file located in the path META-INF/MANIFEST.MF
The entries in the manifest file determine how the JAR file will be used. JAR files which are intended to be executed as standalone programs will have one of their classes specified as the "main" class in the manifest file.
http://www.cezwright.com/tools/java/jar_war_ear.htm

Kernel and Shell

2008-03-11T10:43:00.000+05:30

The terms shell and kernel are used in operating system.The name is probably derived in comparison with a fruit which has inner kernel as the edible core part and outer shell as a cover.

A shell is a piece of software that provides an interface for users. Typically, the term refers to an operating system shell which provides access to the services of a kernel. However, the term is also applied very loosely to applications and may include any software that is "built around" a particular component, such as web browsers and email clients that are "shells" for HTML rendering engines. The name 'shell' originates from shells being an outer layer of interface between the user and the innards of the operating system (the kernel). Operating system shells generally fall into one of two categories: command line and graphical. Command line shells provide a command line interface (CLI) to the operating system, while graphical shells provide a graphical user interface (GUI).

The kernel is the central component of most computer operating systems (OS). Its responsibilities include managing the system's resources (the communication between hardware and software components).As a basic component of an operating system, a kernel provides the lowest-level abstraction layer for the resources (especially memory, processors and I/O devices) that application software must control to perform its function. It typically makes these facilities available to application processes through inter-process communication mechanisms and system calls.

ANT

2008-03-10T10:37:00.000+05:30

A.N.T. – Another Neat Tool

It is a software tool for automating software build processes.Building a software means, you have the source code and you would compile and convert it and deploy it in a way so that the software is all set to work. Ant is used for doing all this automatically instead of you doing it.

Another tool used for building C/C++ code is "make".Ant uses XML to describe the build process and its dependencies, whereas make has its Makefile format. By default the XML file used by ant is named build.xml.

Ant is operating system and language neutral.

There are 3 terms to know in ant

1.Project

2.Target

3.Task
The first or root element of any buildfile is always the tag. No buildfile can be without one nor can it have more than one.

Each 'Project' has a Build File, Default build file name is 'build.xml'However,any name with '-buildfile' command line option can be specified.

Each buildfile contains one project and at least one (default) target.

The "A" target lists the "B" target as a dependency means telling Ant that before it can start the "A" target it must first complete the "B" target.

Targets depend only on other targets and reference them by their target name. Targets NEVER depend on projects or tasks. Target depends are optional.

Optionally you can pass ant the name of the target to run as a command line argument.

Within each target are the actions that Ant must take to build that target; these are performed using built-in tasks.

Tasks could be something like creating a new directory,compiling java
files, creating a jar file etc.

http://ant.apache.org/

http://www.allapplabs.com/ant/ant_basics.htm

Http way...

2008-03-07T12:34:00.000+05:30

Http is a stateless protocol of application layer. That means, the way you interact in HTTp is that, suppose client tells something to you in http way, after sometime client tells something to you again, but neither client nor you remember that they had talked sometime before on something. So http way of communicating means, people who are communicating can perceive only the present and there is no link to associate with the past.

So, that makes it difficult, right ? In web applications client and server talk in http way. You have got some entites like servlets who are there to serve what the client asks. These servlets would have very much appreciated had there been a way, to remember a little bit of past - at least that if they can know that, it was the same client who had come a couple of minutes before asking for a cold coffee and now the same person is asking for hot coffee.

There are some solutions.
Solution 1 - When the client comes first time, you(imagine you are a servlet) assign a unique id for him. So each time now onwards when this client comes, he has to quote his id. Wait, the client too forgets his id the moment the conversation stops !!. So each sentence you talk to the client, you end your sentence reminding him his id. And each time the client talks to you, he will end his sentence saying his id. So both of you never forget, what was going on before.(This technique is called URL rewriting)
Solution2 - Attach something to client that contains all the info required to track and each time you need to keep updating it. This entity attached to the client is called cookies. Cookies contain the necessary information required to track the conversation and it is absolutely your resposnsibilty to manage it. Client never bothers to check the way cookies are handled. Each time the client comes to you asking something, he will just carry his cookies with him always and you should read it to know the what all has happened so far. Client should not have any objection to store cookies in his side. Some clients may not like to get these cookies attached to them.
Solution3 - Don't put any burden on client.So what can be done is, use sessions instead. As soon as a client comes to you you create an entity called session for him on your side and keep it with you updating it with all the relevant information. When he chooses to quit and stops asking anything from you(i.e browser is closed) you can destroy this entity called session.

Turn .jar into .exe

2008-03-06T10:57:00.000+05:30

Executor turns your jar file into a Windows executable. When we write a java application, it is quite irritating sometimes to write a batch file and ant script to run it. We do feel, it would have been nice, if it were converted our application to an exe that can run on windows platform so that just a click from your mouse on a cute icon would run the application.
Read:
http://mpowers.net/executor/

(some excerpts)
Package your Java application as a jar, and Executor will turn the jar into a Windows exe file, indistinguishable from a native application. Simply double-clicking the exe file will invoke the Java Runtime Environment and launch your application.

This allows you to distribute your Java application as a genuine Win32 binary executable. Your users will never need to run an ugly batch file to run your application. You will not have to distribute any temp or config files along with your executable. You will never need to learn JNI and have a C compiler to make a launcher for your application. You will save the hours of effort needed for writing a native launcher with this one tool.

XML

2008-03-05T13:48:00.000+05:30

There are four central problems in data management:
1. Capture
2. Storage,
3. Retrieval
4. Exchange.
XML is a technology mainly for managing data exchange.

It is a subset of SGML(Standard Generalised Markup Language).Extensible Markup Language. It is called "extensible" because user can define his own elements.

xml has following elements:--
1. XML document: An XML file containing XML code.
2. XML schema: An XML file that describes the structure of a document and its tags.
3. XML stylesheet: An XML file containing formatting instructions for an XML file.

xml can be Well-formed or Valid(conforms to a DTD or XML schema)

DTD is oldest. It has inclusion in the XML 1.0 standard. It has no support for new features such as namespaces. Represented by .dtd files.

XML schema language is defined by W3C.
More powerful than DTD. Represented by .xsd files.

Database content can be converted into XML and afterwards into HTML by using an XSLT stylesheet. Making use of this technique, complex websites as well as print media like PDF files can be generated. Information no longer has to be stored in different formats (i.e. RTF, DOC, PDF, HTML). Content can be stored in the neutral XML format and then, using appropriate layout style sheets and transformations, brochures, websites, or datalists can be generated