Java Hobby

Dove project - new release

2010-06-23T23:03:00.000-07:00

Yesterday I released a new version of Dove which is a java based Document Distribution System.

Following are the new features since the previous release:

Added support for following new protocols

FTPs

SFTP

TFTP

Windows Share and UNIX Samba - CIFS

WebDAV

2. Email Templates and Variables support
3. User Guide Document
4. Sample job files provided for all the. The files can be found under the samples folder.
5. UNIX/Linux shell scripts.

Please feel free to download and use Dove.

See you next time!

Dove - Document Distribution Server

2010-06-07T05:50:00.000-07:00

Today I released a new version of Dove - Document Distribution Server

Dove is an application which distributes your documents to a variety of destinations. It allows you to send a document to email or to a WebDAV server with equal ease, no matter which programming language you are using to do it.

Dove can currently distribute documents to email and FTP. It can be used from Java, C/C++, COBOL, .Net, Visual Basic, Delphi, PHP, or any other language you might think of.

http://doveman.sourceforge.net/

JavaBeans mess

2010-06-07T01:31:00.000-07:00

It is a known fact that JavaBeans - 'Generate Getters and Setters' was not the most brilliant idea in java.

One more instance of the problem. I have two libraries which I am using EmpireDB and Java Architecture for XML Binding (JAXB). I have a datatype which I need to use in both - JobInfo let's say. EmpireDB requires JobInfo bean in the classic bean format private field + getter + setter in order to work properly.JAXB requires the JobInfo bean to have public fields and no getters and setters. So I cannot use the same datatype in both places.

Because of the previous I came with the dirty work around of making two different types one JobInfo for EmpireDB and another XMLJobInfo for JAXB while for copying the field values of XMLJobInfo to JobInfo I tried to use BeanUtils.copyProperties(job, xmlJob)

Unfortunately BeanUtils.copyProperties is not handling the situation with two different beans - one with public properties and one with getters and setters. Now the only solution which is left for me is to write the boiler plate code of copying by hand each field's value.

Not good at all.

Sun JDK on Ubuntu 10.04 LTS

2010-06-06T03:21:00.000-07:00

Yesterday I tried for some time to get Eclipse3.5.2 working with Sun JDK6 on Ubuntu 10.04 LTS

This version of Ubuntu is coming by default with OpenJDK JRE installed. It seems that Sun's official Java is not being shipped because of licensing issues.I don't know if this is the only reason, however it is obvious that guys from Ubuntu tried to make the switch to Sun's Java a task which is taking more than 5 minutes.

First of all Sun's JDK is not available to be installed through the official Ubuntu Software Center. I also tried various installing commands which I found on various forums - but none was successful for various reasons. When un-installing OpenJDK the GNU Java was being installed semi-automatically to replace it.

Finally I gave up and I came back to OpenJDK and Eclipse combination. Now I am not able to get Maven2 m2 eclipse plug-in properly working on this combination. I hope is not because of OpenJDK.

TDD Part 4 . Practical Java mocking tutorial using jMock

2008-06-26T11:16:00.000-07:00

Hello everybody. If you came to read this ‘TDD tutorial series’ it means that the benefits of Automated Unit testing are obvious to you. If you are still not convinced you can read “The benefits of automated unit testing”.

Just after starting to write your first real life Junit test cases you realize that you need something more: mocking or stubbing. When you are doing unit testing you are focusing on an element/class at a time, like the name also suggest. But most of the classes are not straightforward and use some other collaborator classes in order to achieve their goals. Here is where the mocking techniques comes into picture and help you to “fake” the collaborator classes in order to be able to perform tests only on the class that you are focused. The term “Mock Objects” has become a popular one to describe special case objects that mimic real objects for testing purposes. By taking one by one each class of your system and writing junits (with the help of mock objects) you will finish with your system fully tested.

The scope of this tutorial is to be a “hands on” jMock presentation but before going into real source code I want to enumerate some techniques to use in order to improve testability in regard with mocking:

a) Code to interfaces rather than classes.
b) Minimize the dependence on environment-specific APIs (EJB, Servlet etc)
c) Give each object a manageable and consistent set of responsibilities
d) Hide implementation details.
e) Refactor into methods to allow overriding at test time.
f) Use a technique similar with Dependency Injection in order to “inject” dependencies rather than directly create them. This will help at test time when mocks/stubs will be injected instead of real classes.

In jMock and in other mocking frameworks you define expectations over the collaborator classes. These expectations "describe" the comportment that is expected from "the mocks" while executing the main code that is under test.

Assuming we want to test the following method. Please take a closer look to the bold code which represents the collaborator classes that I will mock.


protected void endDocument(PDDocument pdf) throws IOException {

  Enumeration keys = burstDocuments.keys();

  while (keys.hasMoreElements()) {

    String burstToken = (String) keys.nextElement();
    Vector pages =(Vector)burstDocuments.get(burstToken).getSecond();

    IPageExtractor pageExtractor = getPageExtractor(pdf,extractedFilePath);

    try {

      pageExtractor.doExtract(pages);
      extractedDocuments.add(extractedFilePath);

      if (sendDocuments) {

        ISender sender = getSender(burstToken);
        sender.attachFile(extractedFilePath);
        sender.doSend();

      } else {
        log.warn("Document: '" + extractedFilePath +
          "' was not sent to any recipient because (sendDocuments) is false");
      }
    } catch (COSVisitorException e) {
        log.fatal("Document: '" + extractedFilePath + "'", e);
    }
  }
}

Don't bother if you don't understand each line of code. Look only to the bold code where the collaborator classes appear. These classes are the candidates for mocking using jMock in order to "describe" the expectations. In short this code extracts from a big document pages corresponding to specific address destinations and sends the "bursted documents" to email, ftp etc.

In order to replace the collaborators with mocks at test time I use the following technique:


//protected method that will be overriden at test time to return "a mock" of PageExtractor
protected PageExtractor getPageExtractor(PDDocument pdf,String outputFileName) {
   return new PageExtractor(pdf, outputFileName);
}

This method will be overridden to return a mock while writing the testing code. This is one of the techniques to "inject" mocks. ISender class is using a similar way. Depending on the burstToken it returns an EmailSender or FTPSender classses that I will mock at test time.

Let's now go to the testing code to see how to use jMock.

1.First thing you need when using this library is a context. I want to use jUnit4 and I want to mock classes not only interfaces.


private Mockery context = new JUnit4Mockery() {
{
   setImposteriser(ClassImposteriser.INSTANCE);
}
};

2.After I have the context I can use it in order to set up my mocks.


//setup - data
  private final EmailSender mockEmailSender = (EmailSender) context.mock(EmailSender.class);
  private final FtpSender mockFtpSender = (FtpSender) context.mock(FtpSender.class);
  private final ExternalToolSender mockExternalToolSender = (ExternalToolSender)  context.mock(ExternalToolSender.class);
  private final PageExtractor mockPageExtractor = (PageExtractor)  context.mock(PageExtractor.class);

3.Next step is to "inject the mocks" into the class that is under test in order to use them instead of real collaborator classes. I do this by "inner overriding" the protected methods that were creating the collaborator classes.


  SimpleBurster burster = new SimpleBurster(true, "") {

    protected PageExtractor getPageExtractor(final PDDocument pdf,final String  outputFileName)
    {
        return mockPageExtractor;
    }

    protected ISender getSender(final String burstToken) {
       if (EmailValidator.getInstance().isValid(burstToken)) {
          return mockEmailSender;
       } else if (GeneralUtilities.isValidFTPAddress(burstToken)) {
          return mockFtpSender;
       } else if (GeneralUtilities.isValidFileAddress(burstToken)) {
          return mockExternalToolSender;
    }
    return null;
  }
};

4.Expectations are coming now. These are the "heart" of the mocking. Here I describe the behavior of the mocks while running the test. If expectations are not met than the test is failing.


// expectations
  context.checking(new Expectations() {
  {
    try {
       exactly(2).of(mockPageExtractor).doExtract(with(any(Vector.class)));
    }
    catch (COSVisitorException e) {
    }

    one(mockEmailSender).attachFile(with(aNonNull(String.class)));
    one(mockEmailSender).doSend();
    never(mockFtpSender).doSend();
    one(mockExternalToolSender).attachFile(with(aNonNull(String.class)));
    one(mockExternalToolSender).doSend();
  }
  });

What behavior I described here? I expect that the method
doExtract(Vector) will be called exactly 2 times on the PageExtractor. I am not
interested exactly in with what parameters will be called. I expect that the method
attachFile(String) will be once called for EmailSender with a non null String
parameter. I expect that the extracted file is send once with doSend() using the
EmailSender.I expect that this file will not be sent with FTP(never(mockFtpSender)).

5. Next step is to call the method under test. The jMock framework will take care
to throw an exception is an expected result is not met.


//execute the code. jMock will check the expectations setted up previously.
  burster.doBurst(Utilities.inputDocumentPath);

6.Last step is to check with jUnit that the returned results are the correct ones. As this is out of the scope for jMock I will not present the code here.

In your day to day work the "jMock 2 Cheat Sheet" is everything you need in order to be productive.

Finally we came to the end. My intention was to be clear and straightforward but I could not resist myself to put some theoretical sentences at the beginning of the post. I hope you got something from reading and there were not just useless words and paper wasted :-).

Enjoy.

Further resources:
1. Test Driven Development: By Example

Best Programming Language?

2008-06-14T11:13:00.000-07:00

Does this question seem familiar to you? You remember some fights with your friends on this topic? I remember for sure... But now after I wrote commercial code in some areas like Delphi, VB6, .Net, C++ and for the past 3 years in Java/J2EE I can say that this question is not a valid one. Maybe a question like "which is the best language for writing 3D shooter games/database driven applications/simple web application/complex enterprise solution" will be more accurate. Now after I have some working experience I will say something like "tell me what kind of application you need
and from the list of languages I know I will choose the most appropriate one". Probably for most of the applications the chosen language will be Java and for the rest C/C++. My reason is very simple and straightforward and not an academically speech about how efficiently memory allocation is handled in each language. When I used to work in Delphi/VB/.Net and I was googling for libraries to get my job done simpler and faster, I was wasting days to find few options with prices like 450/900/1800USD. In 3 years of Java I don't remember one case in which I had less than 5 open source free great options of libraries to choose from. In fact in Java this was my biggest problem. Choosing the best free option... I was overwhelmed with so many good options for any library that I needed at any time. In C/C++ the situation is also good regarding this aspect but in Delphi/.Net/Visual Basic everything is with money (or at least 3 years ago when I switched to Java it was like this). Because of that I will bet my money on Java for many years that will come. What do you think? Do you agree with the Best Programming Language that is suggested here?

DocumentBurster - Java report bursting solution

2008-06-06T13:07:00.000-07:00

Question - What is DocumentBurster?

Answer - DocumentBurster is a one-click batch PDF report bursting solution. The bursted documents can be delivered on a variety of destinations like email, ftp, fax, archive and many more.

A new version DocumentBurster0.0.7 was just released. Please feel free to download it.

DocumentBurster is released under an open source license and you can read more about it here...

Enjoy :-)

Is automated dependency management some kind of "fata morgana"?

2008-06-04T05:29:00.000-07:00

From the Maven site - "Dependency management is one of the features of Maven that is best known to users and is one of the areas where Maven excels".

I see some issues with this approach. For example licensing issues ... Maven2 will start to happily download for us transitive dependencies...and after one year we will find that we are dependent on some "viral" OSS software. It will be too late...

Another issue is with "dependency hell". Even for seasoned developers which are double checking everything exceptions like ClassNotFoundException and NoClassDefFoundException can become a nightmare in production environments. In java world where there are so many libraries which are interdependent, many of them have common dependencies but with different versions of the libraries...the dependency network can become big, difficult to maintain and over complex. For a simple program it is possible to have "automated dependency management" but for a complex one I have some doubts.

And the last one is that people should know what they are including in their programs, dependencies should not be a "black box" for them just because an automated system resolved everything. Sooner or later a ClassNotFoundException will come and they will have to fix it.

What do you think? Will this "dependency hell" problem ever be solved?

This one is interesting to read ... Building a Better Maven with Ant

TDD Part 3 . JUnit tutorial

2008-06-02T04:24:00.000-07:00

JUnit is a unit testing framework for the Java programming language. It helps developers to easily write code that is supposed to test their own code. JUnit (and other xUnit testing frameworks) gain more popularity with the raise of Test Driven Development. The scope of this post is not to speak "theoretically" about the advantages of writing junits (which are many) but to show "hands on" kind of stuff. So let's begin...

What means a "testing framework"? There are couple of things which are making the junit framework but the core of it is the Assert class with all the assert* kind of methods.
A usual assert method is something like


assertEquals(double expected,double actual,double delta)

What is this method doing? It is obvious: it checks/asserts that two doubles are equal to within a positive delta. Most of the Assert class methods are in the same idea. Some other useful assert methods are assertFalse/True, assertNull/NotNull and assertSame/NotSame. Let's write our first JUnit test case. I took this example from this good JUnit entry tutorial.


public class Math {
    static public int add(int a, int b) {
    return a + b;
  }
}

And the code that is testing our Math class is ... of course a JUnit test case.


import junit.framework.*;

public class TestMath extends TestCase {

public void testAdd() {
    int num1 = 3;
    int num2 = 2;
    int total = 5;
    int sum = 0;
    sum = Math.add(num1, num2);
    assertEquals(sum, total);
  }
}

The code is so simple and self explanatory that trying to explain it I will just waste your time... :-)

Let's try some other example. Let's assume we have a java function


public static Vector parse(String text,
        String openDelimiter, String closeDelimiter)

this function takes as input a text string and returns a vector with all the strings between openDelimiter and closeDelimiter that were found in the initial text. Our scope is to test that this function is working properly. What we will do? Of course we will write some JUnits test cases that will give different inputs and will assert that the results are the expected ones. Here is the code:


import junit.framework.TestCase;
import java.util.Vector;

public class TestUtilities extends TestCase {

  public void testParse() {
  
    Vector parsed=Utils.parse("aaa{micky.mouse@yahoo.com}wewe","{", "}");
    assertEquals(parsed.size(), 1);
    assertEquals(parsed.get(0), "micky.mouse@yahoo.com");
        
    parsed=Utils.parse("aaa!micky.mouse@yahoo.com}wewewe","{", "}");
    assertEquals(parsed.size(), 0);
         
    parsed=Utils.parse("aaa<testtag>micky.mouse@yahoo.com</testtag>wewe",
    "<testtag>", "</testtag>");
    assertEquals(parsed.size(), 1);
    assertEquals(parsed.get(0), "micky.mouse@yahoo.com");
        
    parsed=Utils.parse("aaa{micky.mouse@yahoo.com}we{micky.mouse@yahoo.com}rw",
    "{", "}");
    assertEquals(parsed.size(), 2);
    assertEquals(parsed.get(0), "micky.mouse@yahoo.com");
    assertEquals(parsed.get(1), "micky.mouse@yahoo.com");

    parsed=Utils.parse("aa{micky.mouse@yahoo.com}wew{duffy.duck@yahoo.com}rwwe",
    "{", "}");
    assertEquals(parsed.size(), 2);
    assertEquals(parsed.get(0), "micky.mouse@yahoo.com");
    assertEquals(parsed.get(1), "duffy.duck@yahoo.com");

    parsed=Utils.parse("aaaa{micky.mouse@yahoo.comwewew{duffy.duck@yahoo.com}rwrwe",
    "{", "}");
    assertEquals(parsed.size(), 1);
    assertEquals(parsed.get(0),"micky.mouse@yahoo.comwewew{duffy.duck@yahoo.com");
    
  }
}

There is no rocked science here. It is a simple function that is testing another function. What is to notice here is that sometimes the code to test can become bigger than the actual tested code.

In the next part I will present jMock. jUnit without some kind of mocking library is not going to help too much in real life. We will see in the next part why.

Enjoy.

Further resources:
1. JUnit Recipes: Practical Methods for Programmer Testing

New version of DocumentBurster was released

2008-06-02T03:58:00.000-07:00

A new version (0.0.6) of DocumentBurster was just released. The main addition with this release is better logging support by using the Apache Commons Logging library.

DocumentBurster takes as input PDF reports and bursts them based on meta-data. Generated documents can be delivered on a variety of destinations like email, ftp, fax, archive and many more.

You can download the latest version from
DocumentBurster Download Page

TDD Part 2 . Apache ANT tutorial

2008-05-26T10:42:00.000-07:00

Apache ANT describe itself as "a Java-based build tool. In theory, it is kind of like Make, but without Make's wrinkles." Ant is widely used for building Java projects but I feel it is much more than that. For example it can be used for constructing a portable build system for a C/C++ project. (as make replacement). Simply said Ant is a scripting and automation tool based on XML.

I understand TDD as a way of developing software in which Automation plays a very important role. Automation can be a suite of JUnits which will run with every build to verify that nothing is broken, or importing a big database dump for preparing a performance testing scenario, or automatically playing some GUI recorded scripts to make some functional testing or whatever. In all these scenarios ANT can help a lot.

Enough with theory...let's get our hands dirty with some real stuff now.

Starting with a good build system plays a very important role in every successful TDD project. Following is a picture presenting a classic ANT view of a build script in Eclipse IDE

Each node represents an ANT target. This is a clear "unit of work" with a specific scope in the final build process. A target can depend on some other targets so it is very easy to define a complex order of execution of ant targets that will fit best each need. Ant scripts are written in xml files. By default the name of the xml file is build.xml. So let's take one by one each target and describe in detail.

1.clean:


<target name="clean" description="Remove all generated files">
  <delete dir="${dest.dir}"/>
  <delete defaultexcludes="false">
    <fileset dir="${src.test.dir}/resources/pdfTestFiles/outputBurstedFiles"/>
  </delete>
  <delete defaultexcludes="false">
    <fileset dir="${src.test.dir}/resources/pdfTestFiles/outputSendedFiles"/>
  </delete>
</target>

I think the code is self explanatory. It deletes the output already compiled classes
and it also deletes some output folders which are populated while playing the automated test suite.

2.compile [default]

This is the target which compiles the java source code. It is the default target from the build file which means that it is executed by default when no other target is specified. Here is the code:


<target name="compile" depends="init" description="Compile Java source files">
  <javac srcdir="${src.dir}" destdir="${dest.dir}/classes" debug="on"   classpathref="buildtime.classpath" deprecation="on" encoding="ISO-8859-1" />
</target>

As you see this target depends on the target "init". This means that "init" will be first executed when the "compile" target is called. So let's see the "init" target.

3.init:


<target name="init">
  <mkdir dir="${dest.dir}/classes"/>
  <mkdir dir="${dest.dir}/test-classes"/>
  <mkdir dir="${dest.dir}/jar"/>
  <mkdir dir="${dest.dir}/zip"/>
  <mkdir dir="${dest.dir}/junit-report"/>
</target>

The code is very simple and straightforward. It just creates the output folders that are needed by the compile target.

4.compile.tests:

This is the code which compiles the JUnit test cases. It is just a call to the java compiler with the Ant task and it depends on the simple "compile" to be called before. The junit test cases have as a dependency the main program classes therefore these should be compiled before.


<target name="compile.tests" depends="compile">
  <javac classpathref="testtime.classpath" destdir="${dest.dir}/test-classes"   srcdir="${src.test.dir}" debug="on" deprecation="on" encoding="ISO-8859-1"/>
</target>

5.run.tests:

This is the target which actually runs the JUnit tests. Of course it depends on compiling the tests so it has depends="compile.tests". Here is the code:


<target name="run.tests" depends="compile.tests">
 <junit printsummary="yes" haltonfailure="yes">
  <classpath>
   <path refid="testtime.classpath"/>
   <pathelement path="${dest.dir}/test-classes"/>
  </classpath>
  <batchtest haltonfailure="no" todir="${dest.dir}/junit-report">
   <formatter type="xml"/>
   <fileset dir="${dest.dir}/test-classes">
     <exclude name="**/TestUtilities.class"/>
     <exclude name="**/*$*.class"/>
   </fileset>
  </batchtest>
 </junit>
</target>

So how this target is working? It is calling the junit task for running the tests, it is setting the classpath to the testtime.classpath and it is giving as input "a batch" of already compiled tests which are in the "${dest.dir}/test-classes".

6-7.make.jar and make.zip:

These two targets are much related with packaging and distribution. make.jar as the name suggest is packaging the compiled classes as a single jar file. This target depends on the target "run.tests" which means that the jar is created only if all the JUnit test cases are passing successfully. Here is the code for "make.jar":


<target name="make.jar" depends="run.tests">
 <jar destfile="${jar.file}">
   <fileset dir="${dest.dir}/classes"/>
   <manifest>
     <attribute name="Main-Class" value="burster.MainBurster"/>
     <attribute name="Class-Path" value="lib/PDFBox-0.7.3.jar lib/oro-2.0.8.jar
     lib/mail-1.4.1.jar lib/fontbox-0.1.0.jar lib/commons-validator-1.3.1.jar
     lib/commons-net-1.4.1.jar lib/commons-email-1.1.jar lib/jta.jar
     lib/commons-digester-1.7.jar
     lib/commons-beanutils.jar lib/commons-logging.jar lib/commons-logging-api.jar
     lib/commons-collections-3.1.jar lib/quartz-1.6.0.jar"/>
   </manifest>
 </jar>
</target>

Jar task is used for creating the output file. "Main-Class" and "Class-Path" are the "attributes" which are putted in the manifest file when defining the jar.

make.zip - This is the target which takes the output DocumentBurster.jar, it copies also the lib files which are needed, the src files,some txt files like LICENSE.txt, README.txt, Prerequisites.txt and some other and is building the final zip files which will be downloaded by people. Here is the code:


<target name="make.zip" depends="make.jar">
  <delete includeemptydirs="true">
    <fileset dir="${dest.dir}/zip" includes="**/*"/>
  </delete>
  <mkdir dir="./tmp"/>
  <copy todir="./tmp/bin/lib">
    <fileset dir="${runtime.lib.dir}">
    </fileset>
  </copy>
  <copy todir="./tmp/src">
    <fileset dir="../DocumentBurster_client/src">
    </fileset>
  </copy>
  <copy file="${resources.dir}/config/settings.xml"  tofile="./tmp/bin/config/settings.xml"/>
  <copy file="${resources.dir}/config/quartz-jobs.xml"  tofile="./tmp/bin/config/quartz-jobs.xml"/>
  <copy file="${jar.file}" tofile="./tmp/bin/${project.name}.jar"/>
  <copy file="${bat.file}" tofile="./tmp/bin/${project.name}.bat"/>
  <copy file="${resources.dir}/txt_files/LICENSE.txt"  tofile="./tmp/LICENSE.txt"/>
  <copy file="${resources.dir}/txt_files/README.txt"  tofile="./tmp/README.txt"/>
  <copy file="${resources.dir}/txt_files/Prerequisites.txt" tofile="./tmp/Prerequisites.txt"/>
  <copy file="../DocumentBurster_client/IDEs_proj_files/VS2005/DocumentBurster/DocumentBurster/Release/DocumentBurster.exe" tofile="./tmp/bin/DocumentBurster.exe"/>
  <copy file="../DocumentBurster_client/src/resources/mondrian.ico"  tofile="./tmp/bin/images/mondrian.ico"/>
  <copy file="../DocumentBurster_client/src/resources/DocumentBurster.exe.Manifest" tofile="./tmp/bin/DocumentBurster.exe.Manifest"/>
  <zip destfile="${zip.file}" basedir="./tmp"/>
  <delete dir="./tmp"/>
</target>

8.test.gui.with.autoit. This is another target related with automated testing. "run.tests" were running only the JUnit test cases which were testing each java class in isolation. This is taking the redistributable zip file and runs and AutoIt GUI recorded script. This is more like a functional testing comparing with "run.tests" which was about unit testing. Here is the code:


<target name="test.gui.with.autoit" depends="make.zip">
 <unzip src="${zip.file}" dest="./tmp"/>
 <copy file="../DocumentBurster_client/IDEs_proj_files/AutoIt3/documentburster.au3" tofile="./tmp/bin/documentburster.au3"/>
 <copy file="${src.test.dir}/resources/pdfTestFiles/inputFiles/SimpleBurster.pdf" tofile="./tmp/SimpleBurster.pdf"/>
 <exec executable="C:\Program Files\AutoIt3\AutoIt3.exe">
  <arg value="./tmp/bin/documentburster.au3"/>
 </exec>
 <delete dir="./tmp"/>
</target>

Most important thing to notice here is the use of the Exec Ant Task which is used to call an external program from ANT.

Here I finished my "hands on" tutorial with ANT. I hope it was a useful piece of information that you will be using with success it in your own projects.

Further resources:
1. Ant in Action

"Hands on" Test Driven Development tutorial. Part 1-Overview

2008-05-25T03:49:00.000-07:00

Hi everybody. I intend to start a tutorial series about test driven development and extreme programming. I will concentrate on the tools that we need in order to achieve the best results. Everything will be based on real pieces of code which are used in an open source project. The project is small enough in order to be easy to understand but it is not trivial so it does not have the "hello world" syndrome (you read it, you understand it, but you learn nothing from it).

So here are the main topics that I will try to follow:

1) Automate the build process. I will make a short Apache ANT Overview and a real "how to" ANT tutorial.
2) Automate unit testing by writing JUnit Test Cases. I will show real world JUnit examples.
3) Just after starting to write JUnit test cases you realize that you need also something else. This is mocking which helps in testing each class in isolation by using some kind of mocks/stubs for the collaborative classes. I will make a short overview and “hands on” tutorial about jMock.
4) I will discuss a little bit about re-factoring and the place it has in the full test driven development picture.
5) Automate integration/functional testing using a “GUI scripting/recording” kind of tool. For web applications the options are Selenium, Canoo Web Tests. My application has a desktop like GUI so I will present a tutorial about AutoIt which is a very good GUI scripting tool for desktop applications.
6) I will give some guidelines of how to automate as much as possible from performance testing or non function tests (NFT).
7) I will show some application profiling tricks. I will show how to start quick using jProfiler and how to automate the starting of your profiled application from an ANT build script. Maybe I will show also some Eclipse plug-in for profiling.
8) How to correctly audit the quality of your project and source code/JUnit test cases by using a “software project management and comprehension tool” like Maven2. Maven2 can be used also like a replacement for build and deployment of applications instead for ANT but I prefer to use it more for its reporting capabilities and integration with code auditing tools. So in short I will present a real “hands on” Maven2 tutorial which will include FindBugs, Cobertura(code coverage tool), Jalopy(code beautifier tool), CheckStyle, PMD(similar with FindBugs) and other stuff.

Do you think there is some other important topic that should be covered in a Test Driven Development tutorial? I would like to hear from you  :-).

Further resources:
1. Java Extreme Programming Cookbook
2. Extreme Programming Explained

Is Java really portable? Is J2EE really portable?

2008-05-15T13:10:00.000-07:00

Java was all the time marketed with “write once, run everywhere”. The same is true with J2EE. Hundreds of standard specifications are published all the time in order to achieve the all around standardization and portability (JSRs). All the big names in the Java world like Sun, IBM, Oracle and BEA are aggressively claiming that they implement all the JSRs so the only logical result is that portability is a piece of cake in Java. But is this true? If somebody is writing a game with Java will this game run “just like that” on all the mobile platforms that have Java support? If one is writing a complex J2EE application, will this application run easily on all the major application servers? Currently I work with a medium-size EJB J2EE application which was initially deployed with Weblogic. Big money and time efforts were invested to deploy the same application on Websphere. Even bigger efforts are wasted currently to maintain and test the same application on the two platforms in parallel. Is this happening because the developers are bad and they don’t know how to write good J2EE applications? Or it is because Java and J2EE are not exactly what the big names are claiming it is? I want to know your opinion about this. Do you work with a big J2EE application which is easily deployed (without huge money wasted) on all the big application servers Weblogic, Websphere, JBoss, Oracle etc?

Java Architecture for XML Binding - JAXB2 kick-off tutorial

2008-05-04T04:26:00.000-07:00

Java Architecture for XML Binding (JAXB) allows Java developers to map Java classes to XML representations. JAXB provides two main features: the ability to marshal Java objects into XML and the inverse, i.e. to unmarshal XML back into Java objects. JAXB2 is a very good reference implementation of the specification.

There are 2 main approaches to work with XML binding:

a)start with a XSD schema definition as input and generate a collection of Java classes from the given XML schema through the schema compiler.
b)start with writing the Java model classes, mark the classes with specific JAXB 2.0 annotations and compile the model classes using JAXB2 in the classpath.

Here I will demonstrate the last approach as I find much easy for myself to think in "java classes" than to write a XSD schema definition file. The scope is to write the XML binding code for the following document:


<?xml version="1.0" encoding="utf-8"?>
<documentburster>
<settings>
<defaultfilename>defaultBurst</defaultfilename>
<emailserver>
<host>your_email_server</host>
<port>your_email_port</port>
<userid>your_email_user_id</userid>
<userpassword>your_email_password</userpassword>
<usessl>false</usessl>
<usetls>false</usetls>
<debug>false</debug>
<keyfile/>
<rootcertfile/>
<servercertfile/>
<emailaddressfrom>your_email_address</emailaddressfrom>
<emailaddressfromlabel>your_name</emailaddressfromlabel>
</emailserver>
<defaultemailmessage>
<emailmessage>Default Message</emailmessage>
<emailsubject>Default Subject</emailsubject>
</defaultemailmessage>
</settings>
</documentburster>

All the Java mapping classes are in package burster.settings.model;
First step is to write the "documentburster" root class. Here is the code:


package burster.settings.model;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name="documentburster")
public class DocumentBursterSettings {

 @XmlElement(name = "settings")
 public BursterSettings settings;

}

I think the code is self explanatory with @XmlRootElement(name="documentburster") the most important thing to notice. <settings> is a child for the root so the @XmlElement(name = "settings") annotation is used. The code for the class BursterSettings is:


package burster.settings.model;

import javax.xml.bind.annotation.XmlElement;

public class BursterSettings {
 
 @XmlElement(name = "defaultfilename")
 public String defaultFileName;

 @XmlElement(name = "emailserver")
 public EmailServer emailServer;

 @XmlElement(name = "defaultemailmessage")
 public DefaultEmailMessage defaultEmailMessage;

}

EmailServer and DefaultEmailMessage are classic plain java bean classes with getters and setters and without any annotation inside. Because of space issues I will show only the code for DefaultEmailMessage.java


package burster.settings.model;

public class DefaultEmailMessage {

 private String emailsubject;
 private String emailmessage;
 
 public String getEmailmessage() {
  return emailmessage;
 }

 public void setEmailmessage(String emailmessage) {
  this.emailmessage = emailmessage;
 }

 public String getEmailsubject() {
  return emailsubject;
 }

 public void setEmailsubject(String emailsubject) {
  this.emailsubject = emailsubject;
 }
}

The code for EmailServer class is very simple as it is a plain java bean class with getters and setters.

But where is the Unmarshaller code? Where is the code that actually reads/write into the XML file? The final piece of the code is the class Settings which is a "facade" for all my model XML binding classes. From my application I access all the XML binding through the Settings class and not through each model class individually. Here is the code for Settings.java:


import java.io.File;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Unmarshaller;

import burster.settings.model.BursterSettings;
import burster.settings.model.DefaultEmailMessage;
import burster.settings.model.DocumentBursterSettings;
import burster.settings.model.EmailServer;

public class Settings {
 private static Settings instance = new Settings();

 private DocumentBursterSettings docSettings;
 
 private Settings(String xmlSettingsFile) {
loadSettings(xmlSettingsFile);
 }

 public static Settings getInstance() {
  return instance;
 }

 public void loadSettings(String xmlSettingsFile)
 {
  try {
     JAXBContext jc = JAXBContext.newInstance(DocumentBursterSettings.class);
        Unmarshaller u = jc.createUnmarshaller();
    
     docSettings = (DocumentBursterSettings)u.unmarshal(new File(xmlSettingsFile));
     } catch(Exception e){
        System.out.println("Settings.loadSettings: " + e);
    }
 }
 
 private BursterSettings getSettings() {
  return docSettings.settings;
 }

 public EmailServer getEmailServer() {
  return getSettings().emailServer;
 }

 public DefaultEmailMessage getDefaultEmailMessage() {
  return getSettings().defaultEmailMessage;
 }

 public String getDefaultFileName() {
  return getSettings().defaultFileName;
 }

}

In this post I experimented only with a small part of what JAXB2 is capable. By the way JAXB2 is included with Java SE6 but you can use it in earlier versions of Java if you download it from here.

I would appreciate a comment if you feel you have your own noteworthy xml binding tips.

Further resources:
1)DocumentBurster project
2)Another Good JAXB2 tutorial
3)XML Data Binding Resources

Make Web and EJB development simple

2008-04-19T03:18:00.000-07:00

During the years EJB got criticism with the main idea that it mostly introduces a lot of complexity without delivering many benefits. I remember 3 years ago when I first came in touch with Java and J2EE. I was coming with Desktop & .Net kind of programming experience where everything was simple and straightforward. My first J2EE task was to create the simplest screen in the world with two textboxes and one lookup control. I started to dig into the existing application and to develop by finding similar stuff. Blindly I found myself adding stupid code that was not doing anything (home interface-this is what I was thinking at that time) many xml files that looked almost identical but with small differences one from each other (deployment descriptors), xsl files,jsp/javascript files etc and in the final I got around 20 source files for such
a simple task. I was totally confused and I didn’t know what to believe. I was afraid to say that this is totally wrong as I was new and I was thinking that I don’t understand.

After three years of working with J2EE/EJB2 I got some “best practices” experience that I want to share with you. I will not enumerate here all the “known EJB” limitations just for the sake of writing. I will speak only about the things I encountered in my experience and for which I invested some time of thinking for better alternatives. I will not say “don’t use EJB” - use lighter frameworks. I assume that you already considered very seriously the alternatives and you have strong reasons for using EJBs (either technical or political or marketing reasons).

So my points will be:

1)Keep it as simple as possible. Question for anything…why it has to be so complicated?

2)Make a clear logic separation between the business code (APIs) and presentation code (WEB part – mostly JSPs/HTML/JS files). In practice it is a good to have also physical separation with two different building blocks one for business APIs and one for the WEB presentation part.

3)On the APIs side write only business code. Don’t write by yourself any deployment descriptor; don’t write any home interface or any boiler plate code. If you do so you will finish with 1000 “hand written” deployment descriptors files, 500 for Weblogic/500 for Websphere and with thousands or boiler plate source files on your source repository. Each upgrade of Weblogic or Websphere will be a nightmare. Use tools like XDoclet in order to generate all this boiler plate code on build time.

4)Write your all business code with POJOs, not directly in EJBs. Make EJB a “small detail” of your application and not a “deep inside” aspect. Make your business logic only “deployed” with EJB and not “written” with EJB. In order to achieve this one option can be to “decorate/facade” your POJOs with EJB capabilities at build time by generating some proxies that will be the real EJBs. If you will follow this rule you will be able to write JUnits for your business code much easily without needing an EJB container for running the tests. Another advantage is that you will be able to “easily deploy” the business with a lighter framework like Spring or EJB3 at a later point in time if you will decide to move on with newer technologies.

5)This one is a continuation of the previous idea. Don’t use inside your business POJO’s imports like import javax.ejb.something. POJO means plain java and not J2EE. Try to keep aspects like transaction management and security outside your business code (maybe use declarative transaction management and security in deployment descriptors is an option for doing this?). Business POJOs should contain only your business code and nothing like framework/platform invasive stuff.

6)Write JUnits test cases during the development. Use a technique like Dependeny injection in order to make your POJO business components clearly separated. This way you will be able to write tests easier by using mocking. If you respected rules 4 and 5 you will be able to run the automated JUnit test cases fast (at build time) without the need to start any application server.

7)Refactor your code all the time. JUnits test cases will help you in this direction by testing that existing functionality in not broken during the refactoring process.

8)Don’t try to write you own infrastructure code (“home made” frameworks) for anything that is not related with your business. You will just loose time and energy that is better to be invested in business code. For example don’t write your own “in house” ORM framework. Better to invest your energy just in finding the solution that suits your needs from the well established open source market: Hibernate, Apache iBatis, Apache Cayenne etc.

9)Deploy as EJB only components with obvious business meaning. Don’t deploy as EJB stuff that should be helpers for example. In my current application during the time a mixture between business components and helper classes were both deployed as EJBs. This means more deployment descriptors, JNDI lookups for helper classes and so on.

10)Don’t write EJB JNDI lookup calls inside your POJO APIs. If one business component needs services from another one than use POJO only calling conventions (normal java class that is using another simple java class). JNDI lookups should be only from Web part (the client) to the API business layer (the business server).

11)Keep your Web presentation part as simple as possible. Don’t write any business logic inside JavaScript for example. Ideally your JSPs should do nothing more than drawing GUI stuff. I suggest using a framework like Struts2 for the Web presentation part. Write as little as possible logic inside the Web part. Ideally the Struts2 action classes should contain nothing more than redirecting to a business API for making the business processing and retrieving information. Again … don’t write any kind of logic inside the presentation JSPs or in JavaScript. It is very good if you can fully eliminate Javascript “hand written” code from your application.

12)If you need Ajax support then don’t try to make your own homegrown Ajax framework. Look for a well established option like Dojo, Prototype, and GWT etc.

13)This one is obvious….stay away from any vendor specific feature. Things like
import weblogic.bla.bla… should not appear in any part of your code. BEA and IBM are very friendly in helping us to import their classes but this will only make our application blocked with a particular vendor.

14)Make your build and deployment scripts as simple/straightforward, small and generic as possible. Try to avoid as much as possible conditions like “if weblogic/websphere” in your build or deploy scripts.

15)Configure correctly “hot deployment” for your application server. This will speed up the development and the debugging of your application.

16)Use tools like Continuum, Ant, Findbugs, PMD, Maven2, Cobertura, Checkstyle and Jalopy extensively in your build process. All these tools should be part of build scripts and should not be optional if you expect quality code.

So do you have some other “tricks” that can make the web and enterprise development simple and straightforward? I will be glad to hear from you what you think.

Further Readings:
- Head First EJB
- Expert One-on-One J2EE Development without EJB

Enjoy :-)

Give your DocumentBurster feedback

2008-04-06T04:47:00.000-07:00

Hello. Here is the place where you can give your feedback about DocumentBurster project. Feedback can be about suggesting a new feature for the program or describing a problem that you might have. I will be here to assist so please feel free to tell me what you think.

Getting started with wxWidgets - Part5 - Hands on showcase with DocumentBurster

2008-04-06T00:42:00.000-07:00

Finally we are here. In this post I will show a “start to end” example of how to build a non trivial application using wxWidgets. This application will contain most of the elements which are enumerated in “Writing a wxWidgets application: a rough guide”. DocumentBurster is the application that we will look inside in this real example. Please feel free to download the source code in order to study and understand better the concepts explained here.

Some other things that I will show today are:

- How to use Visual Leak Detector in order to catch the memory leaks in the program.
- How to use “Property Tree” library in order to easily read/write program settings in an xml file. Basically this is a very simple and convenient way to achieve XML binding in C++ programs. Property Tree is part of the Boost C++ libraries.
- How to asynchronously call an external program/process from wxWidgets and redirect the output of it to a console window.

Here are few pictures of how the final program will look.

So let's get in.

Download and install Visual Leak Detector. Assuming you are using Visual Studio as your IDE (I explained in a previous post how to set up VS IDE with wxWidgets) you need to go to Tools-Options-Project And Solutions - VC++ Directories and add the Include Files + Library Files for your Visual Leak Detector installation. #include <vld.h> is what you need to do in your .h files when you want to trace memory leaks.

Next step is to download Boost C++ libraries. Here we will use only a very small part of Boost (Property Tree) but you should take a look to this great set of C++ libraries.

DocumentBurster is following the structure of a usual wxWidgets application described in
“Writing a wxWidgets application: a rough guide”.

So the most important classes that you should trace into the source code are:

1)DocumentBursterApp. It is the point of entry into the program( it is like the main() function into a c/java program) and is extending as you might guess : wxApp
virtual bool OnInit() is a function which needs to be implemented so the code is:


bool DocumentBursterApp::OnInit()
{
 if (IsAnotherInstanceRunning()) return false;
 ShowMainWindow();
 return true;
}

I think the code is self explanatory.

2)MainFrm. This is the main window (subclass of wxFrame) of the application and is created inside the DocumentBursterApp::ShowMainWindow.


void DocumentBursterApp::ShowMainWindow()
{
 MainFrm *mainFrame = new MainFrm(NULL);
 mainFrame->Show(true);
 SetTopWindow(mainFrame);
}

3)OptionsDlg. This is the next important class of the program. It extends wxDialog. This class keeps inside the code for the options screen that is a GUI front-end for entering the different settings of the program. This class is created inside the function

void MainFrm::OnOptions(wxCommandEvent& event). What is important to point here is about the event handling mechanism in wxWidgets. Simply saying event handling is about responding to different actions that are happening into your program like user selecting a menu, clicking a button, showing a window, hiding a window and many other types of events.
For example OnOptions() function is called whenever the user is clicking the "Program Options" menu item from DocumentBursters main window. In this function the Options screen is created with the following code.


void MainFrm::OnOptions(wxCommandEvent& WXUNUSED(event))
{
 if ( !mpOptionsDlg )
 {
   mpOptionsDlg = new OptionsDlg(this);
 }
 mpOptionsDlg->Show(true);
}

But how can we make the wxWidgets framework to call our functions when a specific event is happening in the system? In order for a window class to respond to events it needs to make a call to DECLARE_EVENT_TABLE() in the .h class declaration.


class MainFrm : public wxFrame
{
 private:
  DECLARE_EVENT_TABLE();
  void OnExit(wxCommandEvent& event);
  void OnAbout(wxCommandEvent& event);
  void OnOptions(wxCommandEvent& event);
  ....
}

Inside the .cpp class implementation following code is "linking" between events and functions that are called when events are happening.


 BEGIN_EVENT_TABLE(MainFrm,wxFrame)
 EVT_MENU(ID_MNU_EXIT, MainFrm::OnExit)
 EVT_MENU(ID_MNU_ABOUT_DOCUMENTBURSTER, MainFrm::OnAbout)
 EVT_MENU(ID_MNU_DOCUMENTBURSTER_OPTIONS, MainFrm::OnOptions)
 EVT_CLOSE(MainFrm::OnClose)
 END_EVENT_TABLE()

As you see each event has associated a constant which is declared in the .h file.

4)Settings is the next class that we will look. Here is the place where the XML binding is implemented. “Property Tree” library is used for reading and writing of program configurations into the config xml file. This library is part of Boost C++ libraries which I advise you to take a look. Some methods of the class are:

 
 wxString GetProperty(wxString path);
 void SetProperty(wxString path,wxString value);

 void Load();
 void ResetAllChanges();
 void Save();

Implementations of these functions are trivial and you can download the source code for detailed informations.

5)How to asynchronously call an external program/process from wxWidgets and redirect the output of it to a console window. PipedProcess and ConsoleFrm are the classes involved here. ConsoleFrm is extending wxFrame and is the window that is showing the output from the executed process. PipedProcess is extending wxProcess. The code to execute the process is something like:


void OptionsDlg::OnExecWithRedirect(wxCommandEvent& event)
{
  ...
  ConsoleFrm* console = new ConsoleFrm(this);
  console->Show(true);

  PipedProcess *process = new PipedProcess(console, cmd);
  if ( !wxExecute(cmd, wxEXEC_ASYNC, process) )
  {
    wxLogError(_T("Execution of '%s' failed."), cmd.c_str());
    delete process;
  }
  else
  {
    console->AddAsyncProcess(process);
    ...
  }
}

With this post we finished the full wxWidgets tutorial. It was a five parts tutorial in which I tried to show the most important information that people will need to "get started" while keeping it simple enough to be digested in short time by beginners. I will be happy if you will tell me what I did well and what I can improve in order to make this tutorial better.

Further Readings:
- Officiall wxWidgets site
- Cross-Platform GUI Programming with wxWidgets
- wxPython in Action

Enjoy :-)

Getting started with wxWidgets - Part4 - Set up the environment

2008-04-01T10:14:00.000-07:00

In the previous posts I told you about wxWidgets only theoretical. Now time has come for some “hands on” stuff. For writing a wxWidgets application you need to write the business code in C++ but also to draw the GUI interface.

In the current post I will show:

1)How to make Microsoft Visual Studio “wxWidgets ready” so you can write&build your wxWidgets code.

The easy way is to download&install wxPack. Follow the wxPack setup and “magically” your Microsoft Visual Studio environment is configured for the latest version of wxWidgets. Behind the scene wxPack copied wxWidgets libraries in binary forms and configured for us all the complicated settings in the VS IDE.

If you are beginner I advise to choose the easy way. The alternative to this is to download & build “by hand” wxWidgets and to set up everything in Visual Studio. Here is a guide to how to do this.

2)Choose a tool that will allow you to easily draw the screens by placing GUI controls in a drag and drop style (similar with Delphi RAD). Once you have your screens you can generate the GUI related C++ code(that you will copy&paste in Visual Studio) or export your GUI definitions as XRC files (Basically these are XML files that keep all the definitions of your GUI externally from the business code and which you can modify at run-time without re-building the application).

In my day to day work I use Anthemion DialogBlocks. I tried also wxFormBuilder and wxGlade (which are free) but I was not able to use those productively because of some randomly problems that were appearing. With DialogBlocks I was able to do my work without a big learning curve. Maybe it is only a matter of getting used to a tool by I like DialogBlocks.

Starting with next session I will show how to build a wxWidgets application from start to the end.

Further Resources:
- Officiall wxWidgets site
- CodeBlock-Alternative to VS IDE for developing wxWidgets applications
- How to configure CodeBlocks for wxWidgets development
- DevC++ -Alternative to VS IDE for developing wxWidgets applications
- How to configure DevC++ for wxWidgets development
- wxDev-C++ is an extension of Dev-C++ by Colin Laplace et. al.
- Cross-Platform GUI Programming with wxWidgets
- wxPython in Action

So Enjoy :-)

Getting started with wxWidgets - Part3 - Steps to write a simple application

2008-03-30T13:05:00.000-07:00

Here is a cookbook of how to write a simple application in wxWidgets. I will try to split this process in couple of simple to follow steps.

1)First step is to derive a wxApp class and override wxApp::OnInit.


#include "wx/app.h"

class DocumentBursterApp : public wxApp
{
 public:
  virtual bool OnInit();
  ...
};

2)An application must have a top-level wxFrame or wxDialog window. Each frame may contain one or more instances of classes such as wxPanel, wxSplitterWindow or other windows and controls.


class MainFrm : public wxFrame
{
  ...
}

bool DocumentBursterApp::OnInit()
{
 
 MainFrm *mainFrame = new MainFrm(NULL);
 mainFrame->Show(true);
 SetTopWindow(mainFrame);
 
 return true;
}

3)A frame can have a wxMenuBar, a wxToolBar, a status line, and a wxIcon for when the frame is iconized.


void MainFrm::CreateGUIControls(void)
{
   wxIcon ic_exe;
   ic_exe.LoadFile(wxT("images/mondrian.ico"),wxBITMAP_TYPE_ICO);

   SetIcon(ic_exe);
   mpMenuMain =  new wxMenuBar();
   ...

   this->SetMenuBar(mpMenuMain);
   ...
   mpStatusMain = new wxStatusBar(this, ID_MPSTATUSMAIN);
   ...
   this->SetStatusBar(mpStatusMain);

}

4)A wxPanel is used to place controls (classes derived from wxControl) which are used for user interaction. Examples of controls are wxButton, wxCheckBox, wxChoice, wxListBox, wxRadioBox, wxSlider.

5)Instead of creating a dialog box and populating it with items, it is possible to choose one of the convenient common dialog classes, such as wxMessageDialog and wxFileDialog.

6)You never draw directly onto a window - you use a device context (DC). wxDC is the base for wxClientDC, wxPaintDC, wxMemoryDC, wxPostScriptDC, wxMemoryDC, wxMetafileDC and wxPrinterDC. If your drawing functions have wxDC as a parameter, you can pass any of these DCs to the function, and thus use the same code to draw to several different devices. You can draw using the member functions of wxDC, such as wxDC::DrawLine and wxDC::DrawText. Control colour on a window (wxColour) with brushes (wxBrush) and pens (wxPen).

7)To intercept events, you add a DECLARE_EVENT_TABLE macro to the window class declaration, and put a BEGIN_EVENT_TABLE ... END_EVENT_TABLE block in the implementation file. Between these macros, you add event macros which map the event (such as a mouse click) to a member function. These might override predefined event handlers such as for wxKeyEvent and wxMouseEvent.

in OptionsDlg.h file...


class OptionsDlg: public wxDialog
{   
   DECLARE_EVENT_TABLE();
   ...
}

and in the OptionsDlg.cpp file...


 BEGIN_EVENT_TABLE( OptionsDlg, wxDialog )
 EVT_BUTTON(ID_BTNCANCEL,  OptionsDlg::OnCancel)
 EVT_BUTTON  (ID_BTNSAVE,  OptionsDlg::OnSave)
 EVT_BUTTON  (ID_BTNPATH,  OptionsDlg::OnPdfPath)
 EVT_BUTTON  (ID_BTNRESET,  OptionsDlg::OnResetAll)
 EVT_BUTTON  (ID_BTNSCHEDULE,  OptionsDlg::OnExecWithRedirect)
 EVT_INIT_DIALOG(OptionsDlg::OnInitDialog)
 EVT_TREE_SEL_CHANGED(ID_TREEOPTIONS,OptionsDlg::OnOptionsTreeItemChanged)
 END_EVENT_TABLE()

8)Most modern applications will have an on-line, hypertext help system; for this, you need wxHelp and the wxHelpController class to control wxHelp.

9)GUI applications aren't all graphical wizardry. List and hash table needs are catered for by wxList and wxHashMap. You will undoubtedly need some platform-independent file functions, and you may find it handy to maintain and search a list of paths using wxPathList. There's a miscellany of operating system and other functions.

You see. It is like a MFC guide :-).

This was my simple introduction to wxWidgets. In the following sections I will show you in greater details how to write a wxWidgets application from start to end.

Further Readings:
- Officiall wxWidgets site
- Cross-Platform GUI Programming with wxWidgets
- wxPython in Action

Enjoy :-)

Getting started with wxWidgets - Part2 - Classes at a glance

2008-03-30T00:26:00.000-07:00

wxWidgets is a very extensive GUI application framework with many years of proved "production deployments". It has almost 4 mil downloads on sourceforge.net being one of the most active open source projects on this site.

With wxWidgets you get a very big number of components/classes which are coming in the official package and which should be enough for most of the normal programming tasks. If you need more than there are also 3-rd party controls which are of course free. One of the most active wxWidgets component repositories (beside the standard one) is wxCode.

In this section I want to make a short overview of the most important classes in the package. So classes by category:

1)Managed windows

wxTopLevelWindow,wxDialog,wxFrame,wxPropertySheetDialog,
wxSplashScreen,wxTipWindow,wxWizard

2)Miscellaneous windows

wxPanel,wxScrolledWindow,wxGrid,wxSplitterWindow,
wxStatusBar,wxToolBar,wxNotebook,wxListbook,
wxChoicebook,wxTreebook,wxWizardPage,wxWizardPageSimple

3)Common dialogs

wxDialog,wxColourDialog,wxDirDialog,wxFileDialog,
wxFindReplaceDialog,wxMultiChoiceDialog,wxSingleChoiceDialog,
wxTextEntryDialog,wxPasswordEntryDialog,wxFontDialog,
wxPageSetupDialog,wxPrintDialog,wxProgressDialog,
wxMessageDialog,wxSymbolPickerDialog,
wxRichTextFormattingDialog,wxWizard

4)Controls

wxAnimationCtrl,wxControl,wxButton,wxBitmapButton,
wxBitmapComboBox,wxToggleButton,wxCalendarCtrl,wxCheckBox,
wxCheckListBox,wxChoice,wxComboBox,wxComboCtrl,wxDataViewCtrl,
wxGauge,wxGenericDirCtrl,wxHtmlListBox,wxSimpleHtmlListBox,
wxStaticBox,wxListBox,wxListCtrl,wxListView,
wxOwnerDrawnComboBox,wxRichTextCtrl,wxTextCtrl,wxTreeCtrl,
wxScrollBar,wxSpinButton,wxSpinCtrl,wxStaticText,wxHyperlinkCtrl,
wxStaticBitmap,wxRadioBox,wxRadioButton,wxSlider,wxVListBox

5)Miscellaneous pickers

wxColourPickerCtrl,wxDirPickerCtrl,wxFilePickerCtrl,
wxFontPickerCtrl,wxDatePickerCtrl

6)Menus

wxMenu,wxMenuBar,wxMenuItem

7)wxAUI - advanced user interface

This is a new set of classes for writing a customizable application interface with built-in docking, floatable panes and a flexible MDI-like interface. Further classes for custom notebooks with draggable tabs etc. are in progress. See also wxAUI overview.

wxAuiManager,wxAuiNotebook,wxAuiPaneInfo,wxAuiDockArt,wxAuiTabArt

8)Window layout

wxSizer,wxGridSizer,wxFlexGridSizer,wxGridBagSizer,
wxBoxSizer,wxStaticBoxSizer

9)Events

wxActivateEvent,wxCalendarEvent,wxCalculateLayoutEvent,
wxChildFocusEvent,wxClipboardTextEvent,wxCloseEvent,
wxCommandEvent,wxContextMenuEvent,wxDateEvent,wxDialUpEvent,
wxDropFilesEvent,wxEraseEvent,wxEvent,wxFindDialogEvent,
wxFocusEvent,wxKeyEvent,wxIconizeEvent,wxIdleEvent,
wxInitDialogEvent,wxJoystickEvent,wxListEvent,wxMaximizeEvent,
wxMenuEvent,wxMouseCaptureChangedEvent,wxMouseCaptureLostEvent,
wxMouseEvent,wxMoveEvent,wxNotebookEvent,wxNotifyEvent,wxPaintEvent ,wxProcessEvent,wxQueryLayoutInfoEvent,wxRichTextEvent,
wxScrollEvent,wxScrollWinEvent,wxSizeEvent,wxSocketEvent,
wxSpinEvent,wxSplitterEvent,wxSysColourChangedEvent,
wxTimerEvent,wxTreebookEvent,wxTreeEvent,wxUpdateUIEvent,
wxWindowCreateEvent,wxWindowDestroyEvent,wxWizardEvent

10)Validators

wxValidator,wxTextValidator,wxGenericValidator

11)Data structures

wxCmdLineParser,wxDateSpan,wxDateTime,wxArray,wxArrayString,
wxHashMap,wxHashSet,wxHashTable,wxList,wxLongLong,wxNode,wxObject,
wxPathList,wxPoint,wxRect,wxRegEx,wxRegion,wxString,
wxStringTokenizer,wxRealPoint,wxSize,wxTimeSpan,wxURI,wxVariant

12)Additional to these there are also classes for

Device contexts
Graphics device interface
Run-time class information system
Logging features
Debugging features
Networking classes
Interprocess communication
Document/view framework
Printing framework
Drag and drop and clipboard classes
File related classes
Stream classes
Threading classes
HTML classes
Rich text classes
Virtual file system classes
XML classes
XML-based resource system classes
Online help
Database classes
Miscellaneous

For a more comprehensive list of classes in wxWidgets you can check official documentation

Further Readings:
- Officiall wxWidgets site
- Cross-Platform GUI Programming with wxWidgets
- wxPython in Action

Enjoy :-)

Getting started with wxWidgets - Part 1 - Overview

2008-03-29T11:42:00.000-07:00

Do you know C++? Do you know how to write a program using MFC windows API? If your answer is yes it means you already have the skills to write a portable C++ application. WxWidgets is a cross API framework for creating C++ GUI applications. It's also extensive, free, open-source, and mature. Write your program once and then compile/link it with the targeted OS(wxlibs for windows, Mac OS etc) libraries and "voila" you have your program developed for Win32, Mac OS X, GTK+, X11, Motif, WinCE, and more using one codebase. It is as simple at that.
Before getting in touch with wxWidgets I had some windows MFC experience. This helped me a lot in being very comfortable with this library. I never had the feeling that is something new and I need to study before becoming productive.
But why trouble yourself with a different C++ GUI API? Here are some reasons which I find valid and for which I recommend wxWidgets:
-you will get more potential clients for your application as your program will be available on multiple platforms. The additional effort involved from writing a windows application with MFC and writing an all around windows/Mac/Linux/WinCE is insignificant.
-In case you know MFC than you already have some wxWidgets knowledge.
-Works with almost all popular C++ compilers and Python.
-it has very good documentation.
-it is a very mature library as it is around since almost 15 years. It also has a very active community.
-it is completely free.
-you can use Microsoft Visual Studio as your IDE of choice but you also have a lot of very good open source free IDEs like DevC++, CodeBlocks, Eclipse or Anthemion DialogBlocks.

You are still not convinced? The wxWidgets library is implemented in C++, with bindings available for many commonly used programming languages, among them, Python (wxPython), Erlang (wxErlang), Haskell (wxHaskell), Lua (wxLua), Perl (wxPerl), Ruby (wxRuby), Smalltalk (wxSqueak), Java (wx4j) and even JavaScript (wxJavaScript)

You are still not convinced? :-) In following sections I will try to give you more good points in using this great piece of software. At the end of this tutorial I will show a complete wxWidgets sample application which will help you to put all the pieces of the puzzle together and to "kick off" your wxWidgets development.

Further Readings:
- Officiall wxWidgets site
- Cross-Platform GUI Programming with wxWidgets
- wxPython in Action

Enjoy :-)

New version of DocumentBurster is out

2008-03-02T00:20:00.000-08:00

A new version (0.0.3) of DocumentBurster was just released. The main addition with this release is a GUI interface that can be used to manipulate all the important settings of the program. The GUI can be used also to schedule the bursting jobs.

Current features of the software are:

• It is portable as it works on all versions of Windows and most of the UNIX systems.
• It works by reading meta-data which is easily included in the document to indicate the splitting and delivery methods to be used.
• It has out of the box delivery targets as email, ftp. Others like fax, archive and many more is easy to be added. Email is referring to any SMTP compatible server including gmail and yahoo.
• It is easy to define your own custom delivery targets with the help of a plug-in architecture. This will handle the delivery of reports to any target that can be imagined.
• Scheduling. It is easy to define simple or complex schedules for bursting.

Next Features list will contain:

• Make the program "network enabled". Multiple users will be able to burst reports based on specific permissions/roles that will be configurable.
• Variables. There will be 1) Pre-defined System Variables and 2) User-defined Variables. Variables are blocks of information which may change from document to document, and can be used as data to be included in the delivery of documents.

You can download and evaluate the latest version from
DocumentBurster Download Page

Automate functional GUI testing using AutoIt

2008-03-01T23:40:00.000-08:00

Automation is very important when it comes about testing. Creating or recording a bunch of automated tests that can be performed again and again gives the confidence that what was working before is still working after the code was changed. Without automation somebody should stay and test everything manually after each code change. And with the next code change all the work will be lost which is very frustrating. Doing things without automation will take a lot of effort and you will still not be sure that the program is really working.

One of the ways of doing automation is by recording GUI activities which can be played at a later point in time. For doing this I find myself very confident with AutoIt v3. From the AutoIt homepage "AutoIt v3 is a freeware BASIC-like scripting language designed for automating the Windows GUI and general scripting. It uses a combination of simulated keystrokes, mouse movement and window/control manipulation in order to automate tasks in a way not possible or reliable with other languages".

From my point of view AutoIt is a wonderful alternative to expensive commercial solutions like WinRunner.

At a later point of time I will show a small tutorial about how to write a script for testing a GUI interface.

Going Ski in Austria

2008-03-01T11:36:00.000-08:00

I just came from a vacation near Innsbruck, Austria. I enjoyed very much, it was relaxing and I also went to ski in the nearby. Schlick2000 Fulpmes is a large ski area which I find difficult for me as a beginner. On the other hand Stubaier Gletscher is a place with so many places for ski that both beginners and experienced will love. Top of Tirol (3300m) is the highest mountain around and the view is great. I enjoyed 10 wonderful days and I was lucky with sunny weather still the snow was great at the high points.

Debugging memory leaks in C++ programs

2008-02-03T03:41:00.000-08:00

I found a very simple and yet powerful tool for tracing memory leaks in C++ programs. It is free and it can be used as an alternative for costly and complicated to configure commercial memory tools. It is called Visual Leak Detector and you can download it from
VLD.

Enjoy!