Online Résumé

• Developed a new search quality assessment API and Web application in Scala, using the following stack:

  1. Angular JS
  2. Scalatra
  3. MongoDB
• Worked on improving the search engine algorithms behind the Sensis® API. This API provided the data that drove the Yellow Pages and Whereis website/mobile apps, as well as various other Sensis products. Technologies used included:

  1. Play framework 1.x
  2. SOLR
  3. MongoDB
• Developed new functionalities for the Yellow Pages website, based on the following technology stack:

  1. Spring
  2. Hibernate
  3. Cucumber (testing)

  and integrated with the Sensis® API (JSON over HTTP).
• Led Data Verification Testing teams of two major data migration projects, to ensure the proper conversion of customer data. They involved technologies such as Oracle SQL, BASH scripting, Ruby and Groovy.
• Worked on a data-extraction program that accesses the Yellow Pages Oracle database and generates an XML file. This process is used to efficiently transfer gigabytes of data into external customers' systems. Database access is implemented using iBatis. This is being used in a project with Google to enable Google Maps access to Yellow Pages advertisements.
  Implemented an acceptance testing framework, based on JBehave, that allowed automated acceptance tests for the data-extraction program to be written in a clear and meaningful way.
• Developed Web Services, using Apache CXF, to be accessed by external customers such as NineMSN.
  Set up an architecture for monitoring and graphing of runtime statistics of Web Services using Cacti.
• Undertook an application support role to handle customer problems and resolve various production-time issues for the Yellow Pages online platform.
• Implemented various system monitoring of the Yellow Pages online platform using Nagios to preemptively identify potential problems.

• Worked on an updated Web 2.0 travel website for members to contribute travel-related information, such as reviews of tourist attractions, and interact with other travelers. The application was based on a corporate service-oriented architecture consisting of the following technologies:

  1. Struts 2
  2. jQuery
  3. Hibernate
  4. Spring

  Automated builds and tests were implemented using :

  1. Bamboo
  2. a custom Java version of Story Runner
  3. Selenium
  4. JUnit & JSUnit
• Implemented a Restful Web application, using Ruby on Rails 2, that allowed employees to apply for and manage their annual/personal leave.
• Delivered a Restful Web application that allowed prospective students to search for and enquire about PhD research projects offered by the University of Sydney. Technologies used included Ruby on Rails 2 with plugins like:

  1. Active Scaffold,
  2. Acts As State Machine
  3. TinyMCE
  4. Whitelist

  Automated builds and testing were implemented using:

  1. RSpec
  2. Selenium RSelenese
  3. Cruise Control

  Mentored client developers on Agile Methodology practices such as test-driven development (TDD) and pair-programming.
• Developed a Web application that enabled people to apply for credit cards from a bank, using Java Enterprise technologies like:

  1. Websphere Application Server
  2. SQL Server (stored procedures)
  3. Struts 2
  4. Hibernate 3
  5. Selenium
  6. EJB Timers
  7. Third party Java-based reporting framework

• Developing in-house transportation management J2EE application based on the following technologies:

  1. AJAX based Web interface using Direct Web Remoting (DWR), as well as various other web-tier technologies like JSF (MyFaces), JSTL and NetUI.
  2. Persistence tier using iBatis to invoke stored procedures and SQL statements on an Oracle database.
  3. Integration with Oracle Transportation Management (OTM) by messaging via webMethods.
  4. Integration with Atlassian JIRA issue management system via Web Services.
• Designed and implemented a database driven localization framework for the application. Localized parts of the application to Simplified Chinese.
• Designed and implemented a generic job scheduling framework using Quartz.
• Initiated and managing daily stand-up meetings to enable the development team to share knowledge and gain an overall understanding of the development effort. As a result, the team became more cohesive and focused, and more able to properly integrate the various sub-projects into a consistent whole.
• Written Ant build script to allow deployment of the application to a remote WebLogic server to facilitate automated builds.
• Set up Daisy Wiki for the team to easily document and share useful technical information such as HOWTOs, environmental configurations and design patterns. This dynamic sharing of knowledge was essential in keeping every member of the development team adequately informed of the "big picture" of the system as a whole.
• Set up the infrastructure for automated building/integration and continuous unit testing, in line with current best-practice agile-based methodologies. This infrastructure enabled end-to-end integration testing that ensured that the code quality is maintained. Components used included :

  1. Ant + JUnit
  2. Anthill (integration server)
  3. PMD CPD (detecting any code duplication)
  4. EMMA (detecting code coverage of unit tests)
  5. Findbugs (detecting common coding mistakes)
• Implemented a custom performance testing framework using JUnit to ensure that database performance remains consistent for different users. The database uses Oracle VPD to control access to data for specific users.
• Reviewed and refactored existing code based on best-practice design patterns and a test driven mindset. Consequently, the code-base became easier to test, validate against requirements, accommodate new features and maintain.
• Prototyped rich-client UI and business tier solutions using new technologies like Google Web Toolkit, Flex and EJB3. These technologies were integrated to provide functional prototype systems to assist the development team in deciding the best possible technology to adopt for future projects.

• Implemented customer change requests for an existing J2EE application based on JSP, Struts and EJB 2.x technologies, running on JBoss application server and Oracle database. Modified Struts actions and entity EJBs to cater for new work-flow/data.
• Created Javascript libraries to deliver a richer and more user-friendly user interface to complement standard browser controls. In addition, Adobe Javascript was implemented ( via iText library ) to interact with Adobe Acrobat plugin to perform scripted actions such as automatic printer selection. Care was taken to ensure that an alternative PDF download functionality was provided to browsers that lack the Adobe plugin.
• Developed a Swing applet to auto-detect printers on a client browser and communicate this information to the server.
• In addition to software development, also installed a new Mandriva Linux operating system for 4LOOP's development support server (configured RAID-1 mirrored hard-drives, CVS, Postfix, Samba, etc.) to improve security and reliability.

• Provided consultation services to support BearingPoint's developers in undertaking a large J2EE project for a major Australian corporation.
• Set up the infrastructure for automated building/integration and continuous unit testing, in line with current best-practice agile-based methodologies. This infrastructure enabled end-to-end integration testing that ensured that developers produced quality code. Components used included:

  • Ant
  • Anthill (integration server)
  • JUnit + extensions (see below), DBUnit (unit testing)
  • Checkstyle (enforcing consistent coding standards)
  • PMD CPD (detecting any code duplication)
  • EMMA (detecting code coverage of unit tests)
  • Daisy (Wiki for online collaboration)
  • CVS

  The results from JUnit, Checkstyle, CPD and EMMA were automatically emailed to developers so that problems were made visible.
• Developed a sample J2EE application to serve as a reference implementation for BearingPoint's developers. This sample application illustrated all the major components of the actual production system, consisting of:

  1. Web tier using Struts 1.2, JSTL, JSP/CSS/XHTML/Javascript and iText.
  2. Application tier using Session EJBs and Hibernate 3. XDoclet was used to tie everything together.
  3. Database tier with Oracle 9i.

  The application was deployed on WebLogic 8.1 application server.
• Automated the creation of Hibernate POJOs from database schema using Middlegen and hbm2java.
• Developed frameworks to support various types of unit tests:

  • JUnit remote test clients for testing session EJBs.
  • StrutsTestCase (mock objects approach) for testing Struts actions
  • Canoo WebTest for testing the final Web UI.
  • Web Service mock providers to test Web Service (SOAP) interfaces.
  • JMS mock consumers and producers to test messaging interfaces (over TIBCO EMS).
• Solved problems with the usage of Hibernate, such as serialization of Hibernate POJOs with lazy-loaded relationships over the remote interfaces of session EJBs.
• Developed a Swing applet that printed PDFs from file or URL using Smart JPrint. The applet provided features such as auto-printer detection and tray selection.
• Provided mentoring and code review services to other developers to ensure that various J2EE technologies and design patterns were applied properly.

• Took over the development of 4LOOP's software product for managing projects/tasks, timesheets and performing earned-value calculations.
• The product was a J2EE Web application consisting of :

  1. Web tier using Struts 1.2, JSP/CSS/Javascript, iText (PDF generator) and JFreeChart.
  2. Application tier using EJB 2.0 (with CMP) and XDoclet.
  3. Database tier using Oracle.

  It was deployed on JBoss application server application running on a Linux platform.

• Designed a flexible and extensible framework, named Molevolve, for running Genetic Algorithms for Protein Structure Prediction. It was for a new Bio-Computing course introduced at RMIT, Melbourne.
• Implemented the framework using Java 5 including usage of new features such as generics and enumerated types that were very useful for scientific applications. Also developed a Swing front-end for it.
• Prepared full documentation, using OpenOffice Writer, and packaged everything up for release as an Open Source project (GPL) in Sourceforge.net.
• Subsequently tutored the new Bio-Computing laboratory class in using Molevolve to predict structures of protein molecules from their amino acid sequences.

• Developing and maintaining CyberTester, an open-source Web-application for creating, managing and conducting online tests, exams or quizes. It runs on JBoss 4.x application server.
• Designed the architecture that consisted of :

  1. Web tier using Struts 1.2, JSTL, JSP/CSS/XHTML/Javascript and JFreeChart. Internationalized using language resource bundle.
  2. Application tier using EJB 3.
  3. Database tier with MySQL.
• Developed unit tests using JBoss Embeddable EJB3 container to ensure that session EJBs worked properly.
• Packaged up the distribution file and wrote detailed instructions to make it easy for users to download and deploy the application on Unix/Linux servers. Building and deployment was automated using Ant.
• Coordinated development with other open-source developers using facilities (forum, CVS) provided by Sourceforge.net.

• Led a team of four developers in developing a J2EE Web application that integrated with the customer's Enterprise Application Integration (EAI) layer using XML messaging over TIBCO Enterprise Message Service (EMS), and various external third-party application via Web Services (SOAP).
• Designed XML Schema Definitions (XSD) for XML messaging between the Web application and SAP, NetPOS and MQM backends over the TIBCO EMS. These XSDs were statically bound to the Java code using XmlBeans.
• Built the application using Struts 1.2, JSTL,JSP, Servlets on the Web tier. The Web tier was developed to be easily ported into JSR-168 compliant portlets using a Struts-Portlet bridge so that the application could be deployed into a portal server. The business-logic tier utilized EJB (session facade beans over entity beans with CMP/CMR), JMS (interfacing with TIBCO EMS) and LDAP (authentication) technologies. The database tier consisted of Oracle 9i. The deployment platform was BEA WebLogic 8.1 on a HP Tru64 UNIX server.
• Exposed a programmatic interface to the application as SOAP-based Web Services that were implemented by session EJBs. Generation of Web Services was automated in the build process using WebLogic's autotype and source2wsdd ANT tasks.
• Configured transport-level security for Web Services using server and client certificates to provide encryption and authentication over SSL. Client identity was embedded within the client certificate's DN attribute and WebLogic was configured to extract this identity from the certificate.
• Implemented a cluster-wide timer service using JMX MBean Timer.
• Optimized the application to be as fast and scalable as possible by adopting J2EE specific design patterns such as read-mostly entity EJBs.
• Set up development environment to support a test-driven methodology. Development environment consisted of Eclipse IDE, Ant, EJBGen, JUnit and various tools on a Mandrake Linux laptop. Unit tests were written using JUnit for all session EJBs. Web browsers such as Mozilla/Firefox (primary development browser) and Internet Explorer ensured that the client-side GUI was truly platform independent with error-free Javascript.
• Set up an integration server to ensure continuous integration using Anthill OS on a Mandrake Linux server.
• Adopted many agile development practices such as frequent iterative releases, pair-programming, and ensuring minimal overhead to development. Team decisions and architectural designs were efficiently captured using VQ Wiki.
• Configured and administered an entire development LAN running on Mandrake Linux servers that provided services such as Postfix email server, CVS repository, automated backup scripts, Apache Web hosting, Samba shared folders, etc.

• Designed and implemented a Swing-based, multi-threaded desktop application for Toyota car dealers to automatically run diagnostics on cars prior to delivery to customers or during servicing. This application used the JavaComm library to interface with a custom device onboard the vehicle via a RS-232 serial connection.
• Optimized the GUI to provide responsive, user-friendly feedback to users who may not be very computer-savvy. This involved careful manipulation of threads.
• Designed and implemented a copy-protection mechanism based on Digital Signature Algorithm (DSA) to allow Toyota to securely restrict the distribution of the application.
• Performed obfuscation on the application using ProGuard to strengthen the copy-protection mechanism and prevent reverse-engineering.
• Developed unit-tests for all major functionalities using JFCUnit (for Swing GUI) and JUnit for libraries.
• Automated the build-test-release cycle using Ant and implemented continuous integration using Anthill OS.
• Adopted pair-programming for the development of all the major functionalities.
• Prepared installation CDs and scripts for the following desktop platforms: Windows 98/2000/XP and Linux.

Also performed the following system administration tasks for 4LOOP in addition to software development.

• Installed and configured Mandrake Linux operating system to deliver printer, file, backup, Web and CVS services.
• Installed and configured Uninterruptible Power Supply (UPS) to ensure continuous operation of 4LOOP Linux servers.

• Designed and implemented a Swing-based, multi-threaded application for production-line testing in a car manufacturing factory. This application used the JavaComm library to interface with a custom device onboard the vehicle via a RS-232 serial connection.
• Developed unit-tests for all major functionalities using JFCUnit (for Swing GUI) and JUnit for libraries.
• Developed stress-tests using JFCUnit to ensure that the application met strict production-line robustness requirements (24/7 continuous uptime).
• Automated the build-test-release cycle using Ant and implemented continuous integration using Anthill OS.
• Fine-tuned the application to meet strict performance criteria demanded by continuous production-line activities.
• Customized jGossip to provide a Web-based forum to discuss and track requirement changes. This was a big improvement to the software development process over the previous practice of sending emails all over the place.
• Customized iTracker to provide a Web-based application to report, track and manage defect/bugs for both the internal development team and external customers.
• Adopted XPlanner to provide a Web-based application to keep track of project progress and prepare timesheets.

• Developed a J2EE-based Web application to handle the financing of cars for an international bank. In addition to the Web interface, this application also used many background processes for integration with third-party systems.
• Developed the interface using FTP protocol for communicating financial information with ANZ (the merchant bank).
• Utilized Tomcat 4, Struts, XDoclet, Hibernate, HttpUnit, Hypersonic database and various other open-source modules.
• Adopted all aspects of extreme programming throughout the development such as pair-programming, test-driven development, automated integration and daily releases.

• Designed (from top level categories down to coding level) and implemented a J2EE-based portal ( www.softwaremark.com.au ).
• Drove the technical development through the full Software Development Life Cycle (SDLC), from requirements gathering phase (meetings with the client) to the final deployment of the portal on production servers.
• Prepared the Requirements Trace Matrix, Use-cases, and Category diagrams as part of the development methodology as well as being deliverables to the customer. In addition, Javadocs of all source code (extensively documented) were generated as part of the deliverables.
• Evaluated various types of software licenses to select one that that best suited the customer's needs and delivered the best value. Eventually decided on delivering the portal to the customer using the GNU General Public License (GPL). This greatly reduced the project's cost as it could leverage off various existing open-source projects, while still fully satisfying the customer's requirements.
• Designed the architecture of the portal. It consisted of :

  1. Web tier using Struts 1.1,JSP/CSS/XHTML/Javascript, Tomcat 4.
  2. Application tier using EJB 2.0 (with CMP) running on JBoss 3.2.x, XDoclet and JAXB.
  3. Database tier with MySQL and JDBC.

  The architecture was based on industry standard design patterns like MVC, Session Facades, Data Transfer Objects, etc to improve clarity and performance. The portal was built up from several sub-Web applications in a modular manner using Tomcat's single sign-on facility.
• Installed FreeSSL certificate on Tomcat to enable secure transmission of sensitive data over https.
• Led a team of 2 other developers in the implementation stage, using various aspects of extreme programming, such as test-driven development and continuous integration, in order to deliver a high quality product within a tight deadline.
• Set up test framework using JUnit, JWebUnit, Ant, Anthill OS and JMeter.
• Set up Mandrake Linux 9.1 as the standard operating system for production and test servers, as well as for development laptops. Also set up various support applications like firewall, SSH, VNC, etc on these machines.
• Integrated the in-house portal code with external (open-source) applications such as OpenCMS (content management system) and Babylon (chat client/server).
• Wrote batch scripts to synchronize portal data with client's CRM system. These scripts were set up to run every night using cron.

• Designed and implemented a new version of the successful SuperWeb (refer below), a J2EE-based data analysis and visualization Web application.
• Ported STR's existing server products (C++ programs with 64-bit file access) from Solaris/AIX platforms to Linux (Mandrake 9.1, kernel 2.4.21, gcc 3.2.2).
• Critically evaluated and tested various Java charting libraries such as EspressChart, JFreeChart, NetCharts Pro and VantagePoint, for integration into SuperWeb.
• Improved on STR's internal Web-based project planning and tracking system, based on the open-source XPlanner project. This system used Tomcat 4, Struts, Tornado (Object-Relational Mapping Engine), MySQL and ran on a Red Hat Linux server.
• Created a new wizard-based Web interface for SuperWeb that conformed to the guidelines of the W3C Web Accessibility Initiative. This allowed access for people with visual or physical disabilities.

• Provided consultation and advice to a development team on the design and implementation of a Web application using Tomcat 4, Struts, Velocity, JDBC and SQL Server. This application was deployed on the iPlanet server. It serves as a complaints management system and integrates into the CRM system of a major multinational company.
• Improved the object-oriented design of the application by adopting some design patterns where appropriate. This produced code that was easier to understand and maintain.
• Set up building process using Ant and integrated it into the company's existing IDE.
• Set up an integrated framework for automated unit testing using JUnit and StrutsTestCase. This allowed the practice of test-driven development resulting in more robust and bug-free code.
• Written test cases for the various Struts actions and provided guidance to other developers on how to write their own.
• Participated in extreme programming methodologies, such as pair-programming and test-driven development.
• Set up automated build management and testing server using Anthill OS. This enabled continuous integration and unit-testing of new code to further facilitate extreme programming and produce high-quality software.
• Used the company's development environment based on IntelliJ IDEA (the IDE) and Visual Source-Safe (repository).

• Redesigned and improved STR's new multi-lingual web-based data analysis and visualization application named SuperWEB. This application has been successfully deployed on many government and commercial sites, such as www.windowonwomen.gov.au (Australia's Women Data Warehouse).
• Converted SuperWEB from its previous "Model 1" architecture to a proper MVC pattern using the Struts presentation framework. This allowed many more features to be added with ease.
• Developed new SuperWEB features on the server using J2EE technologies like JSP/servlet and Javabeans. Adopted J2EE design patterns such as Value Objects to improve efficiency and scalability.
• Used MySQL & JDBC to implement fast meta-data searching functionality.
• Implemented user-friendly Web browser client using W3C-standards compliant HTML/XHTML, CSS and Javascript. Javascript was used extensively to perform layout, rendering, validations, drag-n-drop, tree-display, menus, client-side data-caching, etc., that contributed to a highly usable and efficient GUI. All client-side code were written and tested to work across all DOM-compliant browsers such as Internet Explorer 5+, Netscape 6+ and Mozilla 1+.
• Implemented multi-lingual output and locale-dependent layout using resource bundles.
• Performed extensive optimization and refactoring of SuperWEB to meet a strict download time target of less than 1 minute on a 56Kbps modem connection.
• Performed load and stress testing using Jakarta JMeter to ensure the application is robust.
• Used Tomcat 4 as the servlet container, Ant as build automation tool, JUnit as unit testing tool and Sun JDK 1.4 as Java compiler.
• Installed, configured and maintained Mandrake Linux 9.0 and Redhat Linux 7.2 operating systems as development platforms. Tested all server-side (Java) and client-side (Javascript) programs on Linux platforms, as well as on secondary Windows 98/NT platforms. This ensured that the multi-platform requirement of this project would be met.
• Integrated SuperWEB into InfoPark's NPS Content Manager system using an XML interface. This allowed SuperWEB to seamlessly access the client's huge repository of managed resources.
• Adopted some aspects of extreme programming such as frequent release iterations to improve software quality and meet deadlines.

• Developed Java GUI applications to run on a new Hewlett-Packard Jornada X-25 handheld device. The GUI was built with light-weight components and ran on JDK 1.1.x.
• Developed Java desktop application that synchronized with the handheld device (above). The GUI was written using Swing on JDK 1.3.1. Used XML extensively to configure the software.
• Performed unit testing using JUnit. Automated building using Ant.
• Profiling and performance optimization using Sitraka JProbe Profiler.
• Designed and modelled software using UML class and sequence diagrams.
• Installed, setup and maintained a CVS repository to support distributed development over the Internet.
• Tracked and managed bugs using Bugzilla.
• Worked with clients and other contractors from 4Loop and Hewlett-Packard on a large, complex & collaborative project.

• Developed Web-based workflow application to manage the company's release procedures. This uses HTML, JavaScript, J2EE server-side programming (servlet/JSP), JDBC driver and MySQL database.
• Extended and improved existing financial simulation Java frameworks.
• Done Java client-side applet programming with AWT, including GUI design.

• Developed JDBC drivers for STR's proprietary database format, using Java, C++ and JNI. Java code developed with JDK 1.2, C++ code initially developed using Visual C++ on Windows NT, subsequently ported to Solaris and AIX platforms using GNU C++ compilers.
• Used various Java and C++ design patterns, such as adapter, visitor, proxy, etc.
• Developed GUI viewers for STR's databases using Java Swing (with JDK 1.2 & 1.3)
• Designed a version numbering system to reflect source code modifications compatible with the tagging mechanism of the CVS source code repository. Initiated the use of XHTML for Release Notes to record code changes.
• Implemented Web-based services using Servlet, JDBC, XML (DOM) and JavaMail technologies.
• Written various Java packages and C++ libraries to support STR's software development.
• Designed a copy-protection scheme for STR's software based on the DSA authentication algorithm.
• Written Makefile scripts to build Java and C++ programs consistently across Windows (using zsh) and Unix platforms.
• Debugged Java programs using JBuilder Foundation, C++ programs using Visual C++.
• Performed program profiling using JDK's profiler for Java programs, and TrueTime profiler for C++ programs.
• Optimized Java and C++ programs for maximum performance.

• Designed object-oriented programs in Swann Insurance's mainframe system using DEC C++.

• Developed document editor with GUI in Java (AWT) for deployment on Windows NT and OpenVMS platforms.

• Rewrote systems routines that were originally written in DEC BASIC and macros.

• Used the OpenVMS operating system on a DecAlpha mainframe.

• Maintained existing system that handled insurance transactions.

• Taught intermediate-level Java programming to a class of ~30 students. Topics include OO design, Applet, Swing & I/O.
• Instructed the students to use BlueJ as the development IDE.

• Lectured 2nd Year Bachelor of Technology (Computing) C programming subject.
• Taught class of 70+ students to program in C, from the basics to developing a database program.
• Organized course syllabus, lecture notes and examination questions. Conducted computer laboratory sessions.

In charge of 2nd & 3rd Year Bachelor of Engineering (Electrical) and Bachelor of Technology (Computing) tutorial and laboratory classes.

Subjects

• Operating Systems (UNIX/DOS/Windows)
• Unix shell & Tcl/Tk scripting
• Digital Design & Circuit Theory