FreeDownload: 07/01/2007

Selasa, 31 Juli 2007

Spcials Download

Senin, 30 Juli 2007

Extreme Messenger for AIM 1.7.5

Download miror 1
Sownload miror 2

Minggu, 29 Juli 2007

HackCatalog > Download <

HackCpath > Download <

HackHpMaker > Download <

HackMambo > Download <

energybaru > Download <

nix_intrusion > Download <

putty > Download <

warnetcleaner > Download <

YahooHacking > Download <

irc script attack > Download <

Kamis, 19 Juli 2007

ATI Radeon HD 2000 Series Launched, from $99 to $399

As expected, the ATI Radeon 2000 series have been launched, starting at less than $99 for the 2400 series, $99 to $199 for the 2600 series and $399 for the ATI Radeon 2900 XT. The new cards come with 65-nm GPU, 512-bit memory bus, second generation Unified Shader Architecture, new Unified Video Decoder for HD multimedia playback and obligatory DirectX 10 support.

Also as expected, none of the models come with the belly dancers that were at the AMD press event in Tunis. Too bad, because maybe that would have distracted us from the fact that the latest Radeon cards seem to get spanked by their NVIDIA counterparts, which apparently offer higher performance and lower consumption while compared to sample cards provided by ATI. In any case, you will find the belly dancer after the jump, along with complete official specs for the 2900 XT.

Belly dancers presenting the ATI Radeon 2000 Series in Tunis, for some reason. – Jesus Diaz

ATI Radeon HD 2900 XT

Features & Specifications

700 million transistors on 80nm HS fabrication process
512-bit 8-channel GDDR3/4 memory interface
Ring Bus Memory Controller
Fully distributed design with 1024-bit internal ring bus for memory reads and writes
Optimized for high performance HDR (High Dynamic Range) rendering at high display resolutions
Unified Superscalar Shader Architecture
320 stream processing units
Dynamic load balancing and resource allocation for vertex, geometry, and pixel shaders
Common instruction set and texture unit access supported for all types of shaders
Dedicated branch execution units and texture address processors

128-bit floating point precision for all operations
Command processor for reduced CPU overhead
Shader instruction and constant caches
Up to 80 texture fetches per clock cycle
Up to 128 textures per pixel
Fully associative multi-level texture cache design
DXTC and 3Dc+ texture compression
High resolution texture support (up to 8192 x 8192)
Fully associative texture Z/stencil cache designs
Double-sided hierarchical Z/stencil buffer
Early Z test, Re-Z, Z Range optimization, and Fast Z Clear
Lossless Z & stencil compression (up to 128:1)
Lossless color compression (up to 8:1)
8 render targets (MRTs) with anti-aliasing support
Physics processing support
Full support for Microsoft DirectX 10.0
Shader Model 4.0
Geometry Shaders
Stream Output
Integer and Bitwise Operations
Alpha to Coverage
Constant Buffers
State Objects
Texture Arrays
Dynamic Geometry Acceleration
High performance vertex cache
Programmable tessellation unit
Accelerated geometry shader path for geometry amplification
Memory read/write cache for improved stream output performance
Anti-aliasing features
Multi-sample anti-aliasing (up to 8 samples per pixel)
Up to 24x Custom Filter Anti-Aliasing (CFAA) for improved quality
Adaptive super-sampling and multi-sampling
Temporal anti-aliasing
Gamma correct
Super AA (CrossFire configurations only)
All anti-aliasing features compatible with HDR rendering
CrossFire Multi-GPU Technology
Scale up rendering performance and image quality with 2 or more GPUs
Integrated compositing engine
High performance dual channel interconnect
Texture filtering features
2x/4x/8x/16x high quality adaptive anisotropic filtering modes (up to 128 taps per pixel)
128-bit floating point HDR texture filtering
Bicubic filtering
sRGB filtering (gamma/degamma)
Percentage Closer Filtering (PCF)
Depth & stencil texture (DST) format support
Shared exponent HDR (RGBE 9:9:9:5) texture format support
ATI Avivo HD Video and Display Platform
Two independent display controllers
Drive two displays simultaneously with independent resolutions, refresh rates, color controls and video overlays for each display
Full 30-bit display processing
Programmable piecewise linear gamma correction, color correction, and color space conversion
Spatial/temporal dithering provides 30-bit color quality on 24-bit and 18-bit displays
High quality pre- and post-scaling engines, with underscan support for all display outputs
Content-adaptive de-flicker filtering for interlaced displays
Fast, glitch-free mode switching
Hardware cursor

Two integrated dual-link DVI display outputs
Each supports 18-, 24-, and 30-bit digital displays at all resolutions up to 1920x1200 (single-link DVI) or 2560x1600 (dual-link DVI)
Each includes a dual-link HDCP encoder with on-chip key storage for high resolution playback of protected content

Two integrated 400 MHz 30-bit RAMDACs
Each supports analog displays connected by VGA at all resolutions up to 2048x1536

HDMI output support
Supports all display resolutions up to 1920x1080
Integrated HD audio controller with multi-channel (5.1) AC3 support, enabling a plug-and-play cable-less audio solution

Integrated Xilleon HDTV encoder
Provides high quality analog TV output (component / S-video / composite)
Supports SDTV and HDTV resolutions
Underscan and overscan compensation

HD decode for H.264/AVC, VC-1, DivX and MPEG-2 video formats
Flawless DVD, HD DVD, and Blu-Ray playback
Motion compensation and IDCT (Inverse Discrete Cosine Transformation)

HD video processing
Advanced vector adaptive per-pixel de-interlacing
De-blocking and noise reduction filtering
Edge enhancement
Inverse telecine (2:2 and 3:2 pull-down correction)
Bad edit correction
High fidelity gamma correction, color correction, color space conversion, and scaling
MPEG-2, MPEG-4, DivX, WMV9, VC-1, and H.264/AVC encoding and transcoding
Seamless integration of pixel shaders with video in real time
VGA mode support on all display outputs
PCI Express x16 bus interface
OpenGL 2.0 support

Rabu, 18 Juli 2007

Parsing arguments for your shell script

Suppose you want to have some options on your bash shell script, some flags that you can use to alter its behavior. You could do the parsing directly, using ${#} to tell you how many arguments have been supplied, and testing ${1:0:1} to test the first character of the first argument to see if it is a minus sign. You would need some if/then or case logic to identify which option it is and whether it takes an argument. What if the user doesn't supply a required argument? What if the user calls your script with two options combined (e.g., -ab)? Will you also parse for that? The need to parse options for a shell script is a common situation. Lots of scripts have options. Isn't there a more standard way to do this? This article is excerpted from the newly published book bash Cookbook. The solution -- use bash's built-in getopts command to help parse options. Here is an example, based largely on the example in the manpage for getopts #!/usr/bin/env bash
# cookbook filename: getopts_example
#
# using getopts
#
aflag=
bflag=
while getopts 'ab:' OPTION
do
case $OPTION in
a) aflag=1
;;
b) bflag=1
bval="$OPTARG"
;;
?) printf "Usage: %s: [-a] [-b value] args\n" $(basename $0) >&2
exit 2
;;
esac
done
shift $(($OPTIND - 1))

if [ "$aflag" ]
then
printf "Option -a specified\n"
fi
if [ "$bflag" ]
then
printf 'Option -b "%s" specified\n' "$bval"
fi
printf "Remaining arguments are: %s\n" "$*"
There are two kinds of options supported here. The first and simpler kind is an option that stands alone. It typically represents a flag to modify a command's behavior. An example of this sort of option is the -l option on the ls command. The second kind of option requires an argument. An example of this is the mysql command's -u option, which requires that a username be supplied, as in mysql -u sysadmin. Let's look at how getopts supports the parsing of both kinds. The use of getopts has two arguments. getopts 'ab:' OPTION
The first is a list of option letters. The second is the name of a shell variable. In our example, we are defining -a and -b as the only two valid options, so the first argument in getopts has just those two letters -- and a colon. What does the colon signify? It indicates that -b needs an argument, just like -u username or -f filename might be used. The colon needs to be adjacent to any option letter taking an argument. For example, if only -a took an argument we would need to write 'a:b' instead. The getopts built-in will set the variable named in the second argument to the value that it finds when it parses the shell script's argument list ($1, $2, etc.). If it finds an argument with a leading minus sign, it will treat that as an option argument and put the letter into the given variable ($OPTION in our example). Then it returns true (i.e., 0) so that the while loop will process the option then continue to parse options by repeated calls to getopts until it runs out of arguments (or encounters a double minus -- to allow users to put an explicit end to the options). Then getopts returns false (i.e., non-zero) and the while loop ends. Inside the loop, when the parsing has found an option letter for processing, we use a case statement on the variable $OPTION to set flags or otherwise take action when the option is encountered. For options that take arguments, that argument is placed in the shell variable $OPTARG (a fixed name not related to our use of $OPTION as our variable). We need to save that value by assigning it to another variable because as the parsing continues to loop, the variable $OPTARG will be reset on each call to getopts. The third case of our case statement is a question mark, a shell pattern that matches any single character. When getopts finds an option that is not in the set of expected options ('ab:' in our example) then it will return a literal question mark in the variable ($OPTION in our example). So we could have made our case statement read \?) or '?') for an exact match, but the ? as a pattern match of any single character provides a convenient default for our case statement. It will match a literal question mark as well as matching any other single character. In the usage message that we print, we have made two changes from the example script in the manpage. First, we use $(basename $0) to give the name of the script without all the extra pathnames that may have been part of how it was invoked. Secondly, we redirect this message to standard error (>&2) because that is really where such messages belong. All of the error messages from getopts that occur when an unknown option or missing argument is encountered are always written to standard error. We add our usage message to that chorus. When the while loop terminates, we see the next line to be executed is: shift $(($OPTIND - 1))
which is a shift statement used to move the positional parameters of the shell script from $1, $2, etc. down a given number of positions (tossing the lower ones). The variable $OPTIND is an index into the arguments that getopts uses to keep track of where it is when it parses. Once we are done parsing, we can toss all the options that we've processed by doing this shift statement. For example, if we had this command line: myscript -a -b alt plow harvest reap
then after parsing for options, $OPTIND would be set to 4. By doing a shift of three ($OPTIND-1) we would get rid of the options and then a quick echo$* would give this: plow harvest reap
So, the remaining (non-option) arguments are ready for use in your script (in a for loop perhaps). In our example script, the last line is a printf showing all the remaining arguments

Senin, 16 Juli 2007

Linux (OS / Platform)

Linux is growing to be the platform of choice for the future, although there are a number of very powerful tools for developing apps for Linux. It has always been daunting for Windows GUI developers to develop Linux Apps. For example a Windows VB ( Visual Basic ) programmer will have a very tough time developing apps for Linux.

GoDB Changes all that. Now developers can develop Linux apps in familiar Windows . That's right!!! they can use the GoDB IDE in Windows develop the applications debug, simulate and test them in windows and finally deploy them into a Linux machine and the app will run with out any modifications or recompiling. This is made possible by using a GoDB Virtual Machine. When you develop an app using GoDB, your apps will run on all platforms that have the GoDB VM.

Linux developers can also utilize the GoDB Linux IDE for Linux desktops, which can be downloaded freely.

Linux progammers can install the GoDB IDE in their Linux machines, develop and deploy Linux desktop application. The IDE and Linux VM’s are available free for all development and deployment done on Desktop Linux.

Windows developers who are looking to develop Desktop Linux application in their familiar Windows environment can use GoDB Entreprise version in Windows PC to develop and deploy the applications on both the Windows/Linux Desktop.

There are two versions of GoDB for Linux, the X11 version to run GUI apps in XWindows (XFree86) and a version that directly runs on the framebuffer(GUI apps run from the Linux text console).

Here are some screen shots of GoDB Development.

App development using IDE in Windows OR your favourite Linux distro (Using WINE - for more information read "SETUP.TXT")

Simulator to test and debug the app developed in windows.

App copied to linux and running under X11

App copied to linux and running consolse using framebuffer.

GoDB For Linux VM Architecture.

Senin, 09 Juli 2007

Linux Mint 2.1 “Bea”

Linux Mint 2.1 codename “Bea” is out and available for download :)

Many thanks to all the people who contributed to the project and to the users who posted their feedback and suggestions on the forums. Bea is a huge step forward and comes with a lot of changes compared to the last release.

New Software

Two new applications made their way into Linux Mint:

* OpenOffice 2.1-Impress (Calc and Writer also got upgraded to version 2.1)
* Xchat-gnome

Better desktop

This is probably the biggest improvement in Bea: A brand new desktop. Linux Mint 2.1 comes with mintDesktop, which adds a lot of desktop improvements:

* Quick access to the computer and home places
* Quick access to the terminal from the context menu
* Ability to delete files directly without sending them to the Trash
* mintDesktop home folders
* Beagle search
* Tomboy notes
* Network manager

Better Wifi support

Bea comes with mintWifi, which purpose is to allow you to configure your wireless card without an Internet connection. mintWifi comes with the following:

* Ndiswrapper and Ndisgtk
* Cabextractor and unshield
* Tutorials to install and configure your Wifi card
* A collection of Wifi drivers to support about 40 different wireless card models

Better branding

* Bea comes with new artwork: new LiveCD splash, new usplash and GDM screens.
* Help is now “one click away”. As our community is growing it seemed important that users could find help and support in the easiest possible way. To achieve this Xchat-Gnome was modified to automatically connect to the Linux Mint IRC channel, and Firefox now features Linux Mint bookmarks pointing at the website and forums.

Better Web browsing

Web browsing was good in Barbara, but as some of you pointed out, it wasn’t good enough:

* Realplayer 10 was replaced with the Mplayer plugins so you can now enjoy Quicktime, AVI, MPG and a lot of other web content.
* The Flash plugin was upgraded to version 9 Beta 2.
* Support for ipv6 was disabled to make your Internet connection and Web browsing faster
* Firefox 2.0 was tweaked so that it does go back to the previous page when you press the backspace key

And a few surprises…

* For those of you who have nvidia cards there’s a little surprise in Bea called envy
* For those of you who like to mount stuff, PyMou was added to the command line
* For those of you who love using Amarok we added support for MusicBrainz tagging
* For those of you who need to extract RAR archives we included unrar
* For those of you who really like Flash, we included the Flash player
* And for those of you who like playing with the terminal, we put a little surprise in there too

Accelerate Your Java Web Service Development with XFire

SOAP Web Services have been around for a number of years now. For many years, the two main Java-based SOAP frameworks were Apache Axis and Sun's JAX-WS. A new Java-based SOAP framework by Codehaus called XFire now provides an even simpler way to develop SOAP web services and clients. The first article in this series will create a simple SOAP client using XFire, demonstrating how simple it is to work with this Java SOAP framework. The second article will use XFire to create a web service implementation.

XFire: SOAP Web Services Simplified

XFire is a next-generation Java SOAP framework. It makes service-oriented development approachable through its easy-to-use API and support for standards. It is also highly performant because it is built on a low-memory, StAX-based model. XFire can be used to create SOAP web service implementations and SOAP web service clients. Some important features of XFire are:

Support for important Web Service standards—SOAP, WSDL, WS-I Basic Profile, WS-Addressing, WS-Security, and so forth.

High performance SOAP Stack

Pluggable bindings POJOs, XMLBeans, JAXB 1.1, JAXB 2.0, and Castor support

JSR 181 API to configure services via Java 5 and 1.4 (Commons attributes JSR 181 syntax)

Support for many different transports—HTTP, JMS, XMPP, In-JVM, and so on.

Embeddable and Intuitive API

Spring, Pico, Plexus, and Loom support.

JBI Support

Client and server stub generation

JAX-WS early access support

Downloading XFire

The first thing you will want to do is get the latest XFire distribution, which is XFire 1.2.6. You can download the xfire-distribution-1.2.6.zip file from the XFire Download page. Once you have downloaded it, you can unzip it to a directory of your choice. I extract it to my C: drive, creating a directory C:xfire-1.2.6.

Downloading Java

For this example, I will use Java SE 5, specifically version 1.5.0_06. You can download the latest Java SE version from the Sun Java Download page. You can follow the installation instructions and install Java SE on to your machine. You also will want to set a JAVA_HOME environment variable as well as add the JAVA_HOMEbin directory to your PATH, so you can run the 'javac' and 'java' commands.

Downloading Ant

To compile and build your Java code, you will use the Apache Ant build tool. You can download the latest version of Ant, version 1.7.0 from the Ant Download page. All that needs to be done is unzip the file to a directory. I extract it to my C: drive, creating a directory C:ant-1.7.0. You also will need to set an ANT_HOME environment variable as well as add the ANT_HOMEbin to your PATH, so you can run the 'ant' command. For this example, I will be using an older version, 1.6.5.

Downloading Eclipse

For this example, I will use the Eclipse IDE to do my development. I am currently running Eclipse version 3.2.2. You can download the latest version of Eclipse from the Eclipse Download page and follow the installation instructions and install Eclipse on to your machine.

Creating Your XFireDemo Project in Eclipse

Create an XFireDemo Java project in Eclipse. Within this project, create the 'bin', 'src', 'lib' subdirectories, as well as a 'build.xml' file. Copy the C:xfire-1.2.6xfire-all-1.2.6.jar file and C:xfire-1.2.6lib*.jar files to the XFireDemo project 'lib' directory. Once you are done, your project should look like this:

Figure 1:XFireDemo Eclipse Project

Filling in the Ant build.xml File

You are going to use Ant to build your XFire test, so you need to create your build.xml file. The build file contains three targets: one to clean the build, called 'clean'; one to generate our SOAP client Java classes from the web service WSDL definition, called 'wsgen'; and one to compile the project, called 'compile'. Here is the build.xml file with the 'clean' and 'compile' targets filled in:

You will compile your Java source files from the 'src' directory, creating Java classes in the 'bin' directory.

XMethods Stock Quote Web Service

You are going to create a SOAP client for the XMethods Stock Quote web service. This simple SOAP web service takes a String parameter representing a stock company symbol and returns the stock quote for this symbol. This web service has a WSDL located at the URL http://www.webservicex.net/stockquote.asmx. You will use XFire to generate SOAP client Java classes that you can use to access this web service.

Generating SOAP Client Java Classes from a WSDL Using XFire

XFire provides an Ant task that allows a user to generate the Java classes for the SOAP client of a web service. It does this by inspecting a WSDL definition for that web service. You are going to point XFire to the XMethods Stock Quote WSDL URL and have it generate your SOAP client Java classes for you. To do this, you need to set up your 'wsgen' Ant task in our build.xml file. Add the following to the 'build.xml' file:

You define a 'wsdlurl' property that contains your StockQuote web service WSDL URL. You also specify your Java compilation classpath by using a path variable 'compile.classpath'. You define the XFire built-in 'wsgen' Ant task definition. You then specify your 'wsgen' ant target that uses the XFire 'wsgen' taskdef, pointing to the 'wsdlurl', to generate your StockQuote web service SOAP client Java classes in the 'net.xmethods.services.stockquote' package. When you run this task, you will see the following new Java classes in your project:

Figure 2:StockQuote SOAP web service client Java classes generated by XFire

Coding the StockQuote Web Service Client

You create a Java class file called XFireClientTest in the 'src' directory. The 'src' directory should now look like this:

Figure 3:XFireClientTest Java class

Fill in the XFireClientTest.java file with the following Java code:

import net.xmethods.services.stockquote.StockQuoteClient;
import net.xmethods.services.stockquote.StockQuoteSoap;

public class XFireClientTest
{
 public static void main(String[] args) {
    StockQuoteClient client = new StockQuoteClient();
    StockQuoteSoap service = client.getStockQuoteSoap();
    String quote = service.getQuote("HOT");
    System.out.println(quote);
 }
}

Your client gets the client proxy for the StockQuote service. It then uses it to get the StockQuote service and call the 'getQuote()' service method, passing in the company symbol of 'HOT'. It then prints out the result to the console. That is all there is for you to code; XFire has generated all the other marshalling code that will convert your input parameter into a SOAP request.

Compiling the XFireDemo Project

Now that you have your Stock Quote web service client, you can go ahead and compile your project using Ant. Running 'ant build.xml' produces the following output, indicating that it compiled your source code and created your XFireClientTest and supporting class files in the 'bin' directory:

Buildfile: C:Documents and SettingsdominicworkspaceXFireDemo
            build.xml
clean:
 [delete] Deleting 8 files from C:Documents and Settingsdominic
          workspaceXFireDemobin
wsgen:
 [wsgen] Jun 30, 2007 5:02:46 PM
         org.codehaus.xfire.gen.Wsdl11Generator generate
 [wsgen] INFO: Generating code for WSDL at
         http://www.webservicex.net/stockquote.asmx?WSDL with a
         base URI of http://www.webservicex.net/stockquote.asmx?WSDL
 [wsgen] Jun 30, 2007 5:02:51 PM
         org.codehaus.XFire.gen.jsr181.AbstractServiceGenerator
         generate
 [wsgen] INFO: Creating class
         net.xmethods.services.stockquote.StockQuoteSoap
 [wsgen] Jun 30, 2007 5:02:51 PM
         org.codehaus.xfire.gen.jsr181.AbstractServiceGenerator
         generate
 [wsgen] INFO: Creating class
         net.xmethods.services.stockquote.StockQuoteImpl
 [wsgen] netwebservicexGetQuote.java
 [wsgen] netwebservicexGetQuoteResponse.java
 [wsgen] netwebservicexObjectFactory.java
 [wsgen] netwebservicexpackage-info.java
 [wsgen] netxmethodsservicesstockquoteStockQuoteClient.java
 [wsgen] netxmethodsservicesstockquoteStockQuoteImpl.java
 [wsgen] netxmethodsservicesstockquoteStockQuoteSoap.java
compile:
 [javac] Compiling 8 source files to C:Documents and Settings
         dominicworkspaceXFireDemobin
 [javac] Note: C:Documents and Settingsdominicworkspace
         XFireDemosrcnetxmethodsservicesstockquote
         StockQuoteClient.java uses unchecked or unsafe operations.
 [javac] Note: Recompile with -Xlint:unchecked for details.
BUILD SUCCESSFUL
Total time: 14 seconds

Running the StockQuote Service SOAP Client Test

You can run your client directly from Eclipse by right-clicking the XFireClientTest class and selecting 'Run As->Java Application':

Click here for a larger image.

Figure 4:Running XFireClientTest in Eclipse

When you run the SOAP client test class, XFireClientTest, using a company symbol of 'HOT' (Starwood Hotels and Resorts), you will get the following response from the Stock Quote web service, indicating a successful test:


 
    HOT
    67.07
    6/29/2007
    4:00pm
    -1.13
    68.04
    68.77
    66.035
    3752226
    14.427B
    68.20
    -1.66%
    49.68 - 74.35
    5.237
    13.02
    STARWOOD HOTELS&R

Conclusion

This article took a look at XFire, a Java SOAP framework that makes working with web services fast and simple. You created a SOAP client and saw how easy it is to use XFire. In the next article in this XFire series, you will create your own SOAP web service using XFire.

References

Codehaus XFire: http://xfire.codehaus.org/

Sun Java: http://java.sun.com/

Apache Ant: http://ant.apache.org/

Eclipse: http://www.eclipse.org/

XMethods: http://www.xmethods.net/

SilvaSoft, Inc. weblog: http://jroller.com/page/silvasoftinc

About the Author

Dominic Da Silva (http://www.dominicdasilva.com/) is the President of SilvaSoft, Inc., a software consulting company specializing in Java- and Ruby-based web and web services development. He has worked with Java since the year 2000 and is a Linux user from the 1.0 days. He is also Sun Certified for the Java 2 platform. Born on the beautiful Caribbean island of Trinidad and Tobago, he now makes his home in sunny Orlando, Florida.

Code Coverage for Free: How to Use EMMA

In this article you will learn how to configure Open Source framework EMMA to work with a web-based application.

Why Do You Need Code Coverage?

How do you know if the code you have written is being executed during regression or unit testing? One way is to use a debugger. Another way is to log every line of code. Yet another way is to compare the expected results of the test with the actual results. The latter usually suffices. All three methods are "somewhat" potent, but nonetheless, all three methods are not enough.

The first case will work in a small, non-repeatable test. The second method clutters your code and the verification process is labor intensive and ineffective. Only the third method is generally accepted by the IT and user community. The third method relies on the test author to cover ALL conditions and prepare test data in such a way that all test conditions are met. You put your trust into the test author's hands. Now, consider the following situation:

You are testing a method that accepts two parameters. It returns false if the first parameter is 1 or the second parameter is 1. Otherwise, the method returns true. The test author creates three test cases to cover three possible scenarios:

A is 1; the expected result is false.

B is 1; the expected result is false.

Both A and B are not 1; the expected result is true.

Figure 1

For the test data, the test author creates three records corresponding to each case:

A = 1, B = 0

A = 0, B = 1

A = 2, B = 2

The above test data in conjunction with three test cases covers all exit points of the returnSomething () method. Now, suppose the test author made a mistake and created the following test data:

A = 1, B = 0

A = 1, B = 1

A = 2, B = 1

What happens now? The second test case return false, which matches our expected result, but Line 4 had never been executed. This is precisely why you need a code coverage tool.

Why EMMA?

I have chosen EMMA as a code coverage tool of choice because:

It is open-source 100% Java.

It has a large market share compared with the other open source coverage tools.

Note: See other open source coverage tools here: http://java-source.net/open-source/code-coverage.

It is easy to use (once you figure out how to use it).

It has most of the features that one needs from the code coverage tool:

It has multiple report type formats.

It has class instrumentation that can be done offline and on the fly.

It can be used in an enterprise environment.

It has ANT support.

It includes the ability to drill down to class, method, and lines of code.

It is free for both open-source and commercial development.

Emma's home page is http://emma.sourceforge.net/.

How-To Overview

This overview explains how to configure EMMA for a web-based Java application. It entails:

Recompilation of Java classes using the debug="on" option.

Off-line instrumentation of application-specific Java classes by using the EMMA <instr> command.

Extracting Java coverage dump from JVM by using the ANT command.

Building code coverage report by using the EMMA <report> command.

All development for this how-to is done within the IBM Rational Software Development Platform 6.0.1 and Websphere 5.1 test environment.

Get JAR Files

Emma jar files (emma.jar and emma_ant.jar) can be downloaded here: http://sourceforge.net/project/showfiles.php?group_id=108932&package_id=117768. You want to get version 2.1.5320 just to be on board with my example.

Import Emmarun.zip into Your Workspace

You can find a link to the download of EmmaRun.zip at the end of this article. The zip file contains one servlet (EmmaTestServlet.java), deployment descriptor (web.xml), one jsp file (input.jsp), and ANT files for running EMMA tools (1_emma_compile.xml, 2_emma-instument.xml, 3_emma_copyfiles.xml, 4_emma-extract-covarage.xml, and 5_emma_report.xml).

Go to FILE → IMPORT → ZIP FILE and follow further instructions on the screen.

Figure 2

Add JAR Files to Your Application Server Classpath

Add Emma.jar and emma_ant.jar to application server classpath Locate Application Server for your web application → Select Environment Tab → under Class Path, click on "Add External Jars", and add emma.jar and emma_ant.jar.

Figure 3

Recompile Classes for Code Coverage

Locate the 1_emma-compile.xml Ant script and execute it. The output should look like this:

Figure 4

This script compiles your EmmaTestServlet.java and places the class file into a emma_classes directory under WebContent/WEB-INF/. The only thing to note in this script is that you do compile with the debug="on" option.

Instrument Classes for Code Coverage

Locate the 2_emma-instument.xml Ant script and execute it. The output should look like this:

Figure 5

This script performs the following steps:

It resets this demo project to a clean state.

It turns on EMMA instrumentation.

It runs the EMMA instrumentation by taking the class files produced by 1_emma-compile.xml ANT script and producing metadata.em instrumentation file and EMMA-instrumented class files.

Copy Classes

Locate the 3_emma-copyfiles.xml Ant script and execute it. This script copies instrumented class files from the "emma_intr_classes" directory to the "classes" directory. This is the output of the script:

Figure 6

Execute Your Example

Now that you have recompiled, instrumented, and copied class files to the classes directory, you can start executing your application. In this step, you will call your application several times. As I mentioned earlier, your test application consists of one servlet, EmmaTestServlet.java, and one jsp, input.jsp. The servlet accepts two parameters from the JSP and, based on these parameters, returns true or false. Repeat the same steps you saw at the beginning of the article:

Parameter 1 = 1, Parameter 2 = 0

Parameter 1 = 0, Parameter 2 = 1

Parameter 1 = 2, Parameter 2 = 2

Figure 7

Extract Coverage Dump

Locate the 4_emma-extract-covarage.xml ANT Script and execute it. By using the command, this script communicates with a JVM running EMMA-instrumented classes via a TCP socket. It downloads current coverage data from a JVM at a given TCP address and saves it into a local file, 'mycoverage.ec'. The output of the script should look like this:

Figure 8

Locate the 5_emma_report.xml ANT Script and execute it. This script executes a EMMA command- offline coverage report generator. It reads in a 'metadata.em' class metadata (produced by the instrumentation step) and runtime 'mycoverage.ec' coverage data (produced by extracting the coverage dump step) and generates a coverage report. The execution output should look like this:

Figure 9

View Report

You finally can open the generated index.html file in the browser to review your results. The report shows that 100% of your code has been executed.

Figure 10 (overall coverage summary)

Figure 11 (coverage summary for source file [EmmaTestServlet.java])

Conclusion

The example that is explained above reveals only a part of EMMA's full functionality, but I hope it will help you get started with this great framework. The framework provides many customization options that you can read about in the help files provided by the author of the framework.

Download

Download the source code for this article here.

References

http://emma.sourceforge.net/

http://java-source.net/open-source

About the Author

Aleksey Shevchenko has been working with object-oriented languages for over seven years. For the past four years, he has served as a technical lead and a project manager. Aleksey has been implementing Enterprise IT solutions for Wall Street and the manufacturing and publishing industries.

MySQL System Architecture

In this article, we're going to take a look at MySQL internals. It will be a fun, informative examination of how all the different pieces and parts of the MySQL server operate together. MySQL's implementation is a fascinating mix of technology that is truly a remarkable achievement—an achievement born from the sweat and inspiration of numerous developers over many years.

One of the joys of open-source technology is just that: it's open source! On a system as large as MySQL,¹ taking a look at the source code gives you a true understanding of the dilemmas faced by the developers over the course of the software evolution. In this article, we'll investigate the source code of the server itself, so put on your hard hat. We encourage you to take a look at the source code, even if you have no intention of making any changes. You will gain an appreciation of the enormity of the tasks undertaken by the development team at MySQL AB, as well as gain a much deeper understanding of how the software works, and thus how you can optimize your programs to best utilize MySQL's strengths and avoid its weaknesses.

The information presented in this article comes from an analysis of both the internal system documentation and the actual source code for the MySQL database server system. Because MySQL is an evolving code repository, since press time, some of the design features explained here have likely changed and will continue to do so over time. If you look at the source code from one version to the next, you'll notice variations in the implementations of subsystems and how they interrelate; however, much of the way in which the system generally functions has persisted over the evolution of the software.

Even if you're not a C programming guru, you should be able to follow most of what we'll cover here. The focus will be less on the code itself and more on the structure and flow of operations within the server, and how the different code libraries interact with each other. Our intention is to provide a basic road map from which you can navigate the source code and documentation yourself. However, there are a few sections of this article that require a significant knowledge of C and C++ programming, and are meant for more advanced readers. If you don't have a whole lot of experience in C programming, just do your best to follow along, and don't worry about it too much!

The MySQL Source Code and Documentation

Since we're going to be looking at the MySQL server source code, you'll want to download a copy of the latest MySQL source code so that you can follow along, as well as embark on your own code review adventures. The source code used in this article comes from a copy of the source code for version 5.0.2. To download a copy of the source code, head over to MySQL's download site (http://dev.mysql.com/downloads/mysql/5.0.html) and download the version of interest to you.

Caution: The source distribution we used for this article's analysis came from the 5.0.2-alpha source tree. Bear in mind that MySQL is an evolving piece of software, and as such, various implementation details discussed in this article may change over time. Always obtain the proper source versions of development documentation before you assume anything is the case for a particular version of MySQL.

The Source Code

The source code is organized into a shallow directory tree containing the major libraries of the MySQL server and its different extensions.

Top-Level Directories

Table 1 shows all the major top-level directories, with a brief description of the files contained in each directory and the general purpose of those files. As we progress through the article, we'll break down the information in this table into smaller groups that relate to each subsystem, but you may use this larger table as a reference.

Table 1. Top-Level Directories in the Source Tree

Directory	Contents
`/bdb`	The Berkeley DB storage engine handler implementation files
`/BUILD`	Program compilation files
`/client`	The mysql command tool (client program) implementation files
`/data`	The mysql database (system database) schema, data, and index files
`/dbug`	Debugging utility code
`/Docs`	The documentation, both internal developer documents and the MySQL online manual
`/heap`	The MEMORY storage engine handler implementation files
`/include`	Core system header files and type definitions
`/innobase`	The InnoDB storage engine handler implementation files
`/isam`	The old ISAM storage engine handler implementation files
`/libmysql`	The MySQL C client API (all C source and header files)
`/libmysqld`	The MySQL server core library (C, C++, and some header files)
`/libmysqltest`	A simple program to test MySQL
`/merge`	The old Merge storage engine handler implementation files
`/myisam`	The MyISAM storage engine handler implementation files
`/myisammrg`	The MyISAM Merge storage engine handler implementation files
`/mysys`	The core function library, with basic low-level functions
`/regex`	The regular expression function library
`/scripts`	Shell scripts for common utilities
`/share`	Internationalized error messages
`/sql`	The meat of the server's implementation, with core classes and implementations for all major server and client activity
`/sql- bench`	MySQL benchmarking shell scripts
`/strings`	Lower-level string-handling functions
`/support-files`	Preconfigured MySQL configuration files (such as my-huge. cnf)
`/tests`	Test programs and scripts
`/vio`	Network/socket utility functions, virtual I/O, SSL, and so on
`/zlib`	Compression function source files

You can take some time now to dig through the source code a bit, for fun, but you will most likely find yourself quickly lost in the maze of classes, structs, and C functions that com-pose the source distribution. The first place you will want to go is the documentation for the distribution, located in the /Docs directory. Then follow along with us as we discuss the key subsystems and where you can discover the core files that correspond to the different system functionality.

NetBeans: Introductions to the Open-Source Project, More Than an IDE

NetBeans is more than an IDE. It is also an open-source project, community, and a rich client application platform. There is certainly more to NetBeans than just a free IDE. In this new series of articles about NetBeans I hope to introduce you to not only the NetBeans IDE but also the project as a whole.

Click here for a larger image.

Figure 1: NetBeans IDE

The NetBeans Integrated Development Environment

The NetBeans IDE is an open-source IDE supporting Java Mobile, Standard, and Enterprise editions. It also supports development of NetBeans Rich Client Platform, HTML, XML, JavaScript, and other scripting languages and technologies. The IDE itself is a NetBeans RCP application.

Other standards and APIs are supported "out of the box" including but not limited to JavaBeans, Struts, Java Server Faces, JUnit, and ANT projects. Others are supported by add-on plug-ins such as Apache Maven and Maven2 and UML. UML along with some other features including Ruby applications will be available after install starting with NetBeans version 6. In my next article I hope to specifically address new features you will find in NetBeans 6.0.

The IDE also includes features that are common to Java IDEs. These features include an integrated editor with source code refactoring support, visual designers for certain technologies including Swing user interfaces, web applications and web services support, and projects which can be built from the command line without the IDE. There are too many features to address in a single article, but I will attempt to address many of them in the coming months.

Aside from Ruby and JavaScript mentioned above, there are other technologies being added to the IDE. These include PHP and operating system scripts such as Bash and Windows Batch files. The new JavaFX scripting language is also being added. This will provide many visual capabilities not previously available to Java developers such as dynamic presentation style effects Flash developers have enjoyed. Many others will come as NetBeans now has a generic language framework, known as Schliemann, for easily adding different language support to the IDE.

Plug-ins (Modules)

Using the NetBeans RCP as its base, the IDE supports plug-ins. These are first class citizens with their own project support accessible in the IDE using File|New Project and category NetBeans Plug-in Modules. This makes it easy to add support for your own custom needs to the IDE. It is also how the NetBeans developers keep adding extra functionality while keeping the existing functionality, and it provides the capabilities to upgrade individual sections or functionality of the IDE.

I currently have two modules listed on the NetBeans Plug-in Portal that do this. One helps clean up large directories, such as copies of large open-source projects, without consuming too much disk and CPU resources, and the other makes working with text embedded in Java sources and external tools, including SQL, XML, and HTML, easier. Many others have done as I, and most of the modules are free. I suggest looking over the plug-in portal as you may find something useful.

The NetBeans Rich Client Platform

The NetBeans RCP, as other RCP packages, is a framework and set of utility APIs which help developers create feature rich applications more easily. It takes care of many features that are common to desktop applications such as context menus, extensions or plug-ins that are called modules in NetBeans lingo, integrated data views, user preferences, and persistence between application sessions.

Click here for a larger image.

Figure 2: Simple NetBeans Rich Client Platform paint application

There are many utilities and packages that applications can build atop. For instance, many 3rd party applications need custom editors, so editors are not unique to IDEs, and the NetBeans RCP provides this. There is a visual library that can be used to develop a wide range of functionality including graphing and reporting and diagramming tools such as UML or Organization Chart designers. There are many others for you to examine.

The RCP also helps integrate your application into the operating system. The RCP project support in the IDE can generate application launchers for Windows, Mac OS X, and general Unix and Linux. The common components and Swing extensions also have UI delegates defined for different look and feels. Coupled with standard Swing look and feel support these are things you as the developer no longer have to worry about.

You can examine the IDE to get a feel of what is available in the Platform. You can install and test it on different operating systems. You can also view the current API documentation. Based on the NetBeans RCP, the IDE sources are a good resource for developing RCP applications. They provide many working examples.

As I mentioned in the IDE section, plug-in development is supported directly in the IDE. This extends to RCP applications. For IDE plug-ins and RCP development there are many wizards and utilities to make things easier. Not that it can't be done, but this is much easier than trying to do it all by hand in something like a text editor or some other development environment. Aside from your specific functionality and code, most things can be added to your application with a few clicks and completing a few text fields in NetBeans.

Click here for a larger image.

The introduction to the NetBeans community begins on the NetBeans home page. This is usually with a download of the IDE. From the home page you can find links to most community information. There is a lot of it and it can be a little overwhelming to new comers.

Mailing Lists

One of the first things you should do is sign-up for the mailing lists or use Nabble to use the mailing lists like a forum. Some have complained about not having a forum or a news server. With Nabble you do not need anything extra. Simply use the mailing list like a forum and search the messages and view them by thread without having to actually download all the messages. The only difference between this and a news server and client is the message headers are not downloaded to your system. Either way, the mailing lists are a good resource for getting help with the different facets of NetBeans and offer good, free support.

Each mailing list has an archive available from the mailing lists page. It is good netiquette to attempt to search the archives for previous answers before posting a new question. The point being many members are community volunteers and just as busy as everyone else, so please respect their time as much as your own. This helps everyone.

Internet Relay Chat (IRC)

Next, there is an Internet Relay Chat (IRC) channel on irc.freenode.org called #netbeans. This has been around for a while, and is now starting to get more users, so if you had previously tried to use it you might want to try again. Some of the Dream Team members try to frequent the channel and help users as they can along with other helpful community members.

Freenode has a neat tool that allows IRC users to connect from behind firewalls. You can also directly access the IRC channel or link to it from your web site. This is a Java Applet that communicates with another server over HTTP and redirects your messages and others to and from the IRC server. This will come in very handy if you cannot use IRC because your company network blocks a port.

Remember, when using IRC, others are usually working too. So, when you ask a question, it may take up to an hour before a reply is made and other times it may take only seconds. If you come in, ask a question, and leave the channel too fast, you may never see the reply, so try to have patience for your own benefit.

Code Samples

You will find the different samples included with the IDE very helpful. They directly demonstrate aspects of the technologies supported by NetBeans. Look in the IDE under File|New Project and category Samples to see what is available. Then, if you cannot find what you are looking for, visit the Sample Catalog on-line. The samples on-line are usually part of a set of plug-ins known as a pack or part of an individual module. Once you find the ones you need, you can install them into the IDE through the update center.

The samples in the IDE create projects that you can use as complete code and resource examples. The good thing about this is they are pre-built so you can dig into them; get a feel for what is capable, and how to do it while being able to run them. This, coupled with specifications, documentation, and possibly a tutorial covering the used technologies, can get you up to speed on something faster than trying to put all the pieces together yourself.

Click here for a larger image.

Figure 4: Project samples

There is also the Java Blueprints Solution Catalog accessible in the IDE through Help|Java Blueprints Solution Catalog. There are many examples of different EE technologies. Along with code samples, there are complete tutorials and documents written by experts to help get you going. This is a sub-set of what is available on the Java Blueprints Solution Catalog project web site.

Click here for a larger image.

Figure 5: Java Blueprints Solution Catalog

Documentation

Beyond the mailing lists, IRC, and samples, there is a lot of on-line documentation. I suggest first accessing Help|Help Contents and Help|Tutorials from inside the IDE. Then, if you cannot find what you need, access the different on-line resources. This may save you some time. Many features of NetBeans are documented in the IDE help including the default keyboard shortcuts through Help|Keyboard Shortcuts.

The NetBeans Docs & Support page is easily located from the NetBeans home page as a tab. There are documents available for the standards and technologies supported by the NetBeans IDE functionality. These range Mobile, Standard, and Enterprise Java as well as SOA and BPEL technologies among others. They include tutorials/learning trails, references, demos, and sample applications. Here you will also find links to different areas of the NetBeans Wiki though the links are not specifically identified as linking to the Wiki.

Click here for a larger image.

Figure 6: IDE Help

Wiki

The NetBeans Wiki contains much information. It is such a valuable resource it really deserves to have a visible link to it from the Docs & Support page. Something like "NETBEANS WIKI HERE" would work for me. Not only will you find information created by NetBeans developers, but also many community members have created documents based on their experience in areas where documentation is lacking or from a different perspective you may find more useful. You will also find information related to development of the IDE and the RCP.

Beyond Documentation and Help: Digging into NetBeans

If getting into the innards of the project is more your forte, you will find the Community page useful. From here you can access the Release Roadmap for a quick peek at what is on the horizon or the past. You will also find information on the different NetBeans teams, contributing, where to get the sources and how to build them, NetBeans development guidelines and processes, the different projects/modules home pages, and the NetBeans issue tracking system Issuezilla.

Issuezilla is a good resource even if you do not plan on working with the sources yourself. Anyone can create issues or requests. This is how the development team knows what issues you are having with the software or different areas of the project including the NetBeans web site and project infrastructure such as CVS. It is how bugs get fixed and problems are resolved; general usage issues should be resolved in the appropriate mailing lists or IRC however.

Aside from defects, you can file enhancement and feature requests in IZ. The NetBeans teams cannot guarantee that all enhancements and features will be implemented due to a lack of resources and time, but most requests are seriously examined when the developers and module owners have time to review them.

For this, you will need to create an account on NetBeans, and the IZ page has links and information with the details. Setting up an account is quick and easy, and like everything else in NetBeans, it is free.

The UI specifications page is a good place to look if you are interested in the user interface design of NetBeans. Here you will find links to different resources regarding the UI including members whom you may want to get to know at some point if contributing to the UI and improving it is something you feel you would enjoy.

Are you into quality? You can help improve the quality of the project at the QA page. There is a community acceptance program called NetCat. I participated in the NetBeans 5.0 NetCat program, and it was a good way to share and contribute with other community members on an upcoming release. I was able to get to know a few members I had not previously communicated. I even received a T-Shirt as I had submitted so many feature requests and bugs.

There are many ways to contribute. I have found it personally rewarding and have made many community friends. If you find contributing to other open-source communities fun and rewarding, I believe you'll like the NetBeans community the same.

Working With Others

You will find, as with most things, you have different experiences with different module owners and developers. People are different and working with some will certainly be easier than others. If you have problems don't simply become frustrated, throw up your hands, and walk off. Please communicate your issues with other community members and try to resolve them.

Sometimes, detailing and explaining your issue more fully helps. Other times, it helps to communicate or use someone else as a mediator. Diplomacy comes in pretty handy when getting to know different community members and working with them. This is also true for working with employees of Sun Microsystems, the company who open-sourced NetBeans and continues to be the primary sponsor of the project. It basically boils down to people are people.

I have experienced this with different open-source projects, so communication problems are nothing unique to NetBeans. There are X different people with X different personalities and experiences. Sometimes that which one perceives as hostility or harshness is perceived differently from another person and is not always the intent of the person you are communicating. Other times, shortness is just a trait of the person you may be dealing with regardless if it's a good social tool or not. In general, this is good to keep in mind when working with any open-source project, and NetBeans is not different in this aspect.

In the NetBeans Dream Team, we will at some point try to address some community issues with regard to contributors, users, and NetBeans developers and how the relationship can be more symbiotic. Currently, we do not know exactly what this will mean or entail, but we certainly want to look at it. I feel there is something lacking, but I have not myself been able to put my finger on it, and I'm not saying it is bad, but instead some things seem like they could be better.

Either way, improvements can never hurt and certainly if we can collaborate better it will benefit all involved with the project. If you have any experiences, good or bad and from a community point of view, please feel free to share them with me at my comments email address. Let me know the issues and what worked and didn't work for you.

The NetBeans Dream Team

The NetBeans Dream Team, which I am a member, is a group of NetBeans community members who have been deeply involved with the NetBeans project for a while. Members have no affiliation with Sun Microsystems, the NetBeans project owner, other than being involved and supporting the NetBeans open-source project. No Dream Team member can be a Sun employee. This is a requirement.

The Dream Team is planning different things. Some of them involve improving the NetBeans IDE or the Rich Client Platform; others involve improving the community, while others are directed towards promoting NetBeans as one of the members' favorite open-source projects. The team may also be working on documentation for different things a user may want to do inside a NetBeans project which documentation may not be available.

Members have special insider access to the project as they are long standing community members and contributors. They are recognized for this. I may be biased in this regard, but no more than a member of any other community, which they have devoted a number of years. I will not be writing to convince you one way or another about the NetBeans project other than to tell you about it. I will try to be as non-biased as possible for someone as involved and I'm sure my editor will help me address this if I get out of line.

One way the Dream Team can help the community, and be a good resource, is try to communicate concerns between the project owner and the community at large. They can talk to community members and users in detail and try to express those concerns to the NetBeans developers and insiders at Sun. This happens now as members help out on mailing lists and IRC chat and bring community members concerns to the group.

The Dream Team can also work the other way and help the developers request things from the community, which helps them, make the project better for members and users. You can think of the Dream Team as an ear or bridge for the community. Community members and users can feel welcome to share concerns and information with the Dream Team.

Conclusions

I hope I have given you enough information about the NetBeans project to get a feel about what it is and where to find out more information about it. In the coming months, I hope to explain different features and how to use them. If nothing else, I hope you find my information useful.

About the Author

Wade Chandler has been developing software for over ten years. He has worked with different languages including C, C++, Java, Perl, different Basic and Pascal flavors, Assembler, .NET languages, and scripting tools including different scripting pages as JSP, PHP, and Cold Fusion along with JavaScript, HTML, XML, and other technologies such as Flash and Director (Shockwave). He has also worked with different operating systems, server applications, networking, DBMS, and protocol and PDA development. He is currently working for Decision Dynamics, Inc. of South Carolina.

He has been a member of the NetBeans community since NetBeans was called Forte for Java and is a member of the NetBeans Dream Team. He has contributed to different open-source projects in different capacities including but not limited to Apache Tomcat, AXIS, and other Apache projects, the visual JasperReport designer iReport, and different Linux distros (currently OpenSuSE being his favorite). Wade is also a member of the SwingLabs.org community. He has been devoting most of his open-source time to NetBeans and some day wishes to again devote time to other projects.

Selasa, 31 Juli 2007

Senin, 30 Juli 2007

Minggu, 29 Juli 2007

Kamis, 19 Juli 2007

Rabu, 18 Juli 2007

Senin, 16 Juli 2007

Senin, 09 Juli 2007

XFire: SOAP Web Services Simplified

Downloading XFire

Downloading Java

Downloading Ant

Downloading Eclipse

Creating Your XFireDemo Project in Eclipse

Filling in the Ant build.xml File

XMethods Stock Quote Web Service

Generating SOAP Client Java Classes from a WSDL Using XFire

Coding the StockQuote Web Service Client

Compiling the XFireDemo Project

Running the StockQuote Service SOAP Client Test

Conclusion

References

About the Author

Why Do You Need Code Coverage?

Why EMMA?

How-To Overview

Get JAR Files

Import Emmarun.zip into Your Workspace

Add JAR Files to Your Application Server Classpath

Recompile Classes for Code Coverage

Instrument Classes for Code Coverage

Copy Classes

Execute Your Example

Extract Coverage Dump

View Report

Conclusion

Download

References

About the Author

The MySQL Source Code and Documentation

The Source Code

Top-Level Directories

The NetBeans Integrated Development Environment

Plug-ins (Modules)

The NetBeans Rich Client Platform

Mailing Lists

Internet Relay Chat (IRC)

Code Samples

Documentation

Wiki

Beyond Documentation and Help: Digging into NetBeans

Working With Others

The NetBeans Dream Team

Conclusions

About the Author

Search That was more complete

Menu