CodeBalance

Relocation of CodeBalance

2012-01-13T04:31:00.000-08:00

CodeBalance has been suspended and renamed as CodeBuild on 12th January 2012.
You can reach our new site via codebuild.blogspot.com.
Blog postings about software development will continue on CodeBuild exactly as before.

Thanks for your concern.

Java Dynamic Web Project to Maven 3 Project - Migration Steps

2012-01-10T07:47:00.000-08:00

If you start a java project in eclipse as "maven project" at the beginning, all you need is downloading maven distribution or maven plug-in and add dependencies to the pom.xml file when required. But some issues exist while migrating from java dynamic web project to maven project. In this post, required configuration steps will be told. Maven introduction, installation, "repository" concept and maven commands are out of scope for this post.

Source codes for a maven project must be located in src/main/java folder. Also test and resources must be located in src/test/java and src/main/resources folders respectively. For this conversion, you can create required folders manually and copy old source codes in it, but more preferred and stable way is defining source paths in Project Properties --> Java Build Path section:

Source folder configuration

/WEB_INF folder is not used in maven projects. There is "webapp" folder instead. You can move WEB_INF files into webapp folder as the given structure and delete old WEB_INF folder. You don't even need lib folder because maven will create required jars:

webapp folder

target/classes folder must be the output (deploy) path instead of build/classes. Again in Project Properties --> Java Build Path section:

Output folder

org.eclipse.wst.common.component file needs some changes. Open it using ctrl+shift+R and edit deploy path and output path as below:

org.eclipse.wst.common.component file

Create pom.xml file on project root folder and configure required sections with your project details. Then add required dependencies one-by-one between tags (This will be the most time consuming issue if there are tens or hundreds of JARs). If maven global repository has required jar, it will be downloaded automatically, otherwise you must find required jar and run "mvn install" command to install that jar to maven repository:

pom.xml file

Run mvn-install or mvn-package commands for the project. Created JARS, web.xml, other resources and class files will be located under /target folder automatically. Also a WAR file for the project will be created. You can copy WAR file to server (e.g. apache tomcat) and run the application, or you can run the application using the server defined in eclipse.

target directory

Depending on the running style of mvn-install command (by plug-in, command etc.) , created JARs under the /target folder may not be copied to src/main/webapp/WEB-INF folder. If you will run the application using the server of the ide, you may be needed to copy created libs into src/main/webapp/WEB-INF/lib folder and add those libs to project using Project Properties --> Java Build Path --> Libraries --> Add JARs section for once.

Adding required jars under webapp/WEB-INF/lib

A Look Into Java Annotations & A Real World Spring Example

2011-12-29T07:26:00.000-08:00

An "annotation" is a type of programminglanguage definition and used as a “marker”. They can be thought as commentlines which programming language engine can understand. They don’t directlyaffect program execution but affect indirecly if wanted.

Definition

An annotation is defined with @interface keyword and is similar withan interface. It has attributes which are defined like interface methods.Attributes can have default values. Let’s define an annotation named “Page”,which defines UI pages of an application:

public @interface Page {

int id();

String url();

String icon()default "[none]";

String name();default "[none]";

}

Usage

Annotations are widely used to informcompiler or compile-time/runtime/deployment-time processing.

Usage ofan annotation is simpler:

@Page(id=1, url=”studentView”, icon=“icons/student.png”,name=”Students”)

public class StudentWindow extends Window { … }

Annotationscan also be defined for methods and attributes:

@AnAnnotation

public String getElementName() {…}

@AnAnnotation(type=”manager”, score=3)

public int income;

Examples

1) Reflection/code generation:

Methods havinga specific annotation can be processed at runtime:

public @interface MyAnnotation { ... }

public class TestClass {

@MyAnnotation

public static method1() { ... }

@MyAnnotation

public static method2() { ... }

@MyAnnotation

public static method3() { ... }

}

public static void main(String[] args) {

for (Method method : Class.forName("TestClass").getMethods()) {

if (method.isAnnotationPresent(MyAnnotation.class)) {

// do what you want

}

2) Spring bean configuration (this section requires Spring bean configurationknowledge):

Let’s useour “Page” annotation again:

package com.cmp.annotation;

public @interface Page {

int id();

String url();

String icon() default "[none]";

String name(); default "[none]";

}

Say thatwe have a few classes having @Page annotation in a package:

@Page(id=1, url=”studentView”, icon=“icons/student.png”, name=”Students”)

public class StudentWindow extends Window { … }

If wedefine a bean configuration as below in a Spring application-context.xml file, Springwill create class instances “which has @Page annotation” placed in “givenpackage”.

<context:component-scan base-package="com.cmp.ui" annotation-config="true">

<context:include-filter type="annotation" expression="com.cmp.annotation.Page"/>

context:component-scan>

So, we havebeen enforced Spring to instantiate only a selection of classes at runtime.

For more detailed info about annotations, please refer to:

http://docs.oracle.com/javase/1.5.0/docs/guide/language/annotations.html

http://docs.oracle.com/javase/tutorial/java/javaOO/annotations.html

A Selection of Successful Software Engineering Posts (2011)

2011-12-29T02:00:00.000-08:00

This selection contains 25 blog posts selected by CodeBalance which were placed on DZone in 2011.

Java
Producer and Consumer Pattern in Java
Quick Tip for Improving Java Apps Performance
JUnit Tutorial 2
Clientside Improvements in Java 6 & 7
Java Productivity Report 2011 (India vs Rest of the World)
Be a Better Java Programmer - A Reading List
Method Size Limits in Java
Why I Choose Java?
Best Practices List in Java
Lessons in Software Reliability
Music Components in Java Effects
WWW: World Wide Wait - A Performance Comparison

Software Engineering & Practices
The Principles of Good Programming
A Detailed Study on Understanding Code
Making Better Software - Forget New Features
Making Code Easy to Understand What Developers Want
Things to Remember When Doing Code Review
The Seven Phases of Introducing Continuous Integration

General
The Most Important Man in Tech Dies Last Week…It wasn't Steve Jobs.
The Top 10 Attributes of a Great Programmer
Build Facebook Bot in 2 Easy Hours
30 Free Programming E-Books
Signs That You're a Bad Programmer
A Complete List of All Major Algorithms (300)
10 Android Articles/Tutorials

You can also review Part 1 (2010) here:
http://codebalance.blogspot.com/2011/01/selection-of-successful-software.html

Improve Software Quality with Tools and Processes

2011-12-28T07:26:00.000-08:00

As most of the software developers know, software engineering is not just "coding". It's a complex process which requires engineering vision, analytical thinking, designing and software process management supported with tools. This article contains some important approaches, techniques and tools to improve software production quality.

Software quality depends on time and cost of course. But you can be sure that spent money and time will return as so much more. Quality standards will also be used for upcoming projects and increase company growth speed on midterm.

Choose a suitable process model and apply it correctly

As you know there are software process models like agile, scrum, iterative and incremental etc. Choose one of these according to the project type. You don't have to perform all rules strictly, you can modify most of them. The point is "using a process" here, for a systematic and ordered development.

Control the version of each required source

Using a version controlling system is a must. Even if only one developer exist, it must be used. Historical data, versioning, merging, ... is very important for increasing productivity. Otherwise developers will wait each other, can not detect performers and lines of previous changes, can not perform versioning systematically etc. SVN, CVS and TFS are used for this purpose.

Track issues with easy-to-use tools

Parallel with using a process model, issue tracking tool usage is essential. JIRA-like tools are useful and easy-to-use. By tracking issues, you can track productivity and software growth and get production reports easily. Besides, those tools can be used to monitor developer work-hour productivity.

Perform and manage documentation

Perform documentation as required (e.g. %10 of total production time). No documentation is never a good solution as much as excessive documentation. It may include code documentation, requirement specifications, design documents, test documents, user manuals etc. Those documents are needed to be managed and shared also, by using version controlling tools or web based platforms (like Confluence).

Use dependency management tools

Managing dependency libraries (library projects, jars, DLLs etc.) are a big problem especially for big projects. Configuring libraries to run the application after each release or after each project check-out is a hell. Use a dependency managing tool like Maven or at least auto build/copy script tools like Ant.

Use continuous integration

Building, deploying and versioning software is a big problem. Its time consuming and reduces productivity. Because of these, use a continuous integration tool (Hudson for example) and integrate it with dependency management or build tools (like Maven, Ant, ..). The tool may be configured to perform a build on each commit, on clicking a button manually or on predefined periodic times...

Perform testing and integration testing constantly

Testing is very important for software quality. Test documentation which may consist test scenarios, results and relations with issues is required. Also, testing (UI testing, integration testing, ...) must be performed constantly and periodically. Even if changing a single line of code may crush the whole system or crash a hidden functionality. for example, JUnit is very popular for Java applications.

Perform unit testing and automatize it

Unit testing is as important as the other testing methods. Unit tests provide pre-detection of most of the problems. By performing qualitative unit testing, time consumption for other testing methods also descreases. Automatizing these tests using continuous integration tools or at least command line tools (Hudson with Maven for example) are important to keep software consistency and reliability.

Collect metrics from production and use results

Coding metrics (e.g. line of code, abstraction ratio, cyclomatic complexity, ...) gives us some good viewpoints about software. For example, by using line of code maybe we can't (or we mustn't) determine the productivity of a developer; but we can determine the growth speed of software monthly. Complexity-like metrics tells us design errors before deployment. These metrics can be collected by tools or plug-ins (e.g. CodePro Eclipse plug-in).

Follow best practices of coding and control with tools

There is no "golden rule" suitable with all software projects, but there are best practices for project management, architecture, designing, coding, testing for most situations. Performing those rules will increase the quality. For example, you can define rules for code production (about indentation, commenting, magic numbering, paranthesis etc.) and monitor convenience automatically and periodically with external tools or plug-ins like Maven Surefire Report plug-in.

Hibernate 3 Installation & Configuration

2011-10-10T01:27:00.000-07:00

Short Description:

Hibernate is an ORM framework for Java applications, which maps application objects into relational database tables. It is important because:

Developers don't write SQL expressions into code. This saves time and increases maintainability.
It is database independent. DBMS can be changed without changing the code. Only configuration XML is modified for this.
It supports transaction methods and auto-creation of tables, constraints, relations (1-N,1-1, N-N, etc.).

Installation:

Requires two steps:

Copying required JARs into /lib directory:
Creating and configuring persistence.xml configuration file.

Required JARs are:

Hibernate installation JARs

Hibernate requires only hibernate3.jar. But hibernate-jpa jar is also used generally for additional JPA properties. A database connector jar is also reqiured for connection handling. mysql-connector jar is used here for this reason. Other jars are required because of dependencies. These jars can be found on most Java developer download site with exact version numberings.

persistence.xml file is also required to map application into database. Database configuration is done in this file. It is put into /src/main/config/META-INF folder as default. Content should be as below:

Hibernate persistence.xml configuration

persistence-unit name: Defines the configuration id. More than one persistence unit can be defined at once.

hibernate.connection.driver_class & hibernate.dialect: Defines the database type. MySQL is used in this example.

hibernate.connection.username & hibernate.connection.password: Defines database connection parameters.

hibernate.connection.url: Defines database server name, port and schema. "test" is used here for schema name.

These two steps are required and enough for starting Hibernate usage. Hibernate entity definition and API usage will be explained in upcoming posts.

A Quick Reference to the Spring 3 DI Bean Configuration

2011-10-07T03:19:00.000-07:00

Spring 3 DI (dependency injection) functionality which placed in "Spring Core" is very important for managing objects (or "beans") in enterprise applications.

Here is a quick reference for bean configuration of Spring DI:

Spring Bean Configurations

You can get a bean in application by

manual:
ApplicationContext context = new ClassPathApplicationContext(new String[] {“application-context.xml”})
ViewManager viewManager = (ViewManager)context.getBean(“viewManager”);

annotation:
@Autowired
ViewManager viewManager;

10 SCRUM Methodology Best Practices

2011-08-21T23:28:00.000-07:00

Here is a list of some best practices about scrum:

Burn down charts can be used to monitor sprint status. Graphical representations are better than tabular list views in planning.

Planning poker is a useful way to determine sprint item finish durations. And using Fibonacci numbers is a good practice for planning poker numbers.

ROI (Return on Investment) values are useful to determine item priorities in a sprint. Planning poker can be used to determine ROI values.

Using a board and simple planning/reporting tools (e.g. excel, sprintometer, projectsimple) are important and enough as process quality equipments.

Scrum methodology does not offer documenting everything, but this does not mean "no documentation". Really needed documentation can be done as required.
Daily meetings must not be longer than 15 minutes. Scrum is an agile methodology and no one needs to listen other members' problem details. These details may be discussed after daily meeting with scrum master with only required subset of team members.
Stand up meeting style is better for daily meetings, to keep meeting short. Also meeting location and time are recommended to be the same for each day.
Product backlog may contain items which will not be developed. According to ROI values, some items may not be developed and this is normal. Product backlog should contain all possible items anyway. Give backlog items ID numbers, to manage simply.
Sprint length (in weeks) changes are not recommended. But according to the sprint retrospective meeting results, sprint week lengths may be changed if there are really important reasons.
6 hours per a day is a realistic planning input. Total sprint hour capacity can be calculated as: (number of team members) * (number of sprint days) * 6 hours

For general information about SCRUM:
http://codebalance.blogspot.com/2011/08/scrum-software-development-methodology.html

Software Architecture Antipatterns : Swiss Army Knife Interface

2011-08-15T23:24:00.000-07:00

Swiss Army Knife Interface is an interface class which has excessive number of method definitions. Architect/designer may design this interface to use for every need of the software, but this is a wrong approach and an antipattern. More than one interface must be designed using some design approaches.

Of course, "excessive number of methods" is a too general statement. Although most developer think that a handful number of methods (e.g. 8-10) and some studies show that some magic numbers (7 plus/minus 2) are mostly enough, we can't say the maximum number of methods precisely.

First of all, you must think that this interface will be implemented by a class and if the number of methods is excessive, there will be plenty of empty method bodies in implementor class. But this situation still can't determine the number of interfaces and number of methods in an interface.

The answer is hidden in the OOP SOLID rules. Single Responsibility ("S") rule of SOLID says that "every object should have a single responsibility", and Interface Segregation ("I") rule of SOLID says that "different types of functionalities should be placed in different interfaces". If an interface have more than one types of functionalities or defines more than one responsibilities, implemening that interface is meaningless because implementer class will not suit SOLID rules by implementing that interface.

More than one Swiss Army Knife Interface may also exist in a software. This means more than one problem exist and must be solved.

For another viewpoint, you can take a look at our another post about interface segregation principle:

http://codebalance.blogspot.com/2010/09/oop-solid-rules-interface-segregation.html

SCRUM Software Development Methodology : Nuts & Bolts

2011-08-07T23:22:00.000-07:00

Scrum is an agile software development methodology. It is useful for relatively small (5-9 developers) development teams and limited project calendars. This post will give brief definitions and useful suggestions about this methodology.

Team Members

Product Owner: Behaves as real customer and criticizes product. Attends meetings and can determine work priorities. Adds items to product backlog (will be told later). Only one person can be product owner in a scrum team.
Scrum Master: Enforcer of the rules. Generally most experienced team member. Works like team leader. Solves the problems of the team, if team/team member couldn't. Only one person can be scrum master in a scrum team.
Team: A scrum team member is responsible of analysing, design, development, test and the other required processes. So, specialization is rare. Self-organization is a plus. There is no hierarchy in members. Scrum master is also a team member.

Document Types:

Product Backlog: This list contains items that the project must have and may have. Item size can increase every time.
Sprint Backlog: Sprint is a time interval (generally 2-4 weeks) that a group of items must be completed (similar with "iteration" in unified process and some other processes). Sprint backlog contains items that must be completed in that sprint.

Meeting Types:

Daily Scrum/Standup Meeting: Max. time is 15 minutes. Performed at the start of the day and generally in stand-up style. Every member should answer 3 questions:

What did you do yesterday?
What will you do today?
Is there a problem about your work item(s)?

Sprint Planning Meeting: Performed at the start of each sprint. Sprint backlog is created using product backlog items and priority opinions of all team members.
Sprint Review: Performed at the end of each sprint. Status of sprint backlog items are discussed and results are recorded.
Sprint Retrospective: Performed at the end of each sprint. Sprint process issues are discussed to improve process quality.

Process:

Scrum Process

From product owner opinions and other internal/external sources, product backlog is created.
Sprint planning meeting is performed at the start of each sprint. Previous sprint's unfinished items (if exists) and product backlog are sources of sprint backlog. Backlog is created according to item priority opinions of all team members. Sprint length (in weeks) may also be defined here for once.
In sprint time, daily meetings are performed. Team members take responsibility of items from item pool of sprint backlog continiously when an item is finished. By the way scrum master solve possible problems and product owner criticizes results.
Sprint review and retrospective meetings are performed at the end of each sprint. Results are discussed in these meetings. Results are recorded to be applied for next sprints.

20 Database Design Best Practices

2011-07-24T23:14:00.000-07:00

Use well defined and consistent names for tables and columns (e.g. School, StudentCourse, CourseID ...).
Use singular for table names (i.e. use StudentCourse instead of StudentCourses). Table represents a collection of entities, there is no need for plural names.
Don’t use spaces for table names. Otherwise you will have to use ‘{‘, ‘[‘, ‘“’ etc. characters to define tables (i.e. for accesing table Student Course you'll write “Student Course”. StudentCourse is much better).
Don’t use unnecessary prefixes or suffixes for table names (i.e. use School instead of TblSchool, SchoolTable etc.).
Keep passwords as encrypted for security. Decrypt them in application when required.
Use integer id fields for all tables. If id is not required for the time being, it may be required in the future (for association tables, indexing ...).
Choose columns with the integer data type (or its variants) for indexing. varchar column indexing will cause performance problems.
Use bit fields for boolean values. Using integer or varchar is unnecessarily storage consuming. Also start those column names with “Is”.
Provide authentication for database access. Don’t give admin role to each user.
Avoid “select *” queries until it is really needed. Use "select [required_columns_list]" for better performance.
Use an ORM (object relational mapping) framework (i.e. hibernate, iBatis ...) if application code is big enough. Performance issues of ORM frameworks can be handled by detailed configuration parameters.
Partition big and unused/rarely used tables/table parts to different physical storages for better query performance.
For big, sensitive and mission critic database systems, use disaster recovery and security services like failover clustering, auto backups, replication etc.
Use constraints (foreign key, check, not null ...) for data integrity. Don’t give whole control to application code.
Lack of database documentation is evil. Document your database design with ER schemas and instructions. Also write comment lines for your triggers, stored procedures and other scripts.
Use indexes for frequently used queries on big tables. Analyser tools can be used to determine where indexes will be defined. For queries retrieving a range of rows, clustered indexes are usually better. For point queries, non-clustered indexes are usually better.
Database server and the web server must be placed in different machines. This will provide more security (attackers can’t access data directly) and server CPU and memory performance will be better because of reduced request number and process usage.
Image and blob data columns must not be defined in frequently queried tables because of performance issues. These data must be placed in separate tables and their pointer can be used in queried tables.
Normalization must be used as required, to optimize the performance. Under-normalization will cause excessive repetition of data, over-normalization will cause excessive joins across too many tables. Both of them will get worse performance.
Spend time for database modeling and design as much as required. Otherwise saved(!) design time will cause (saved(!) design time) * 10/100/1000 maintenance and re-design time.

Sofware Management Antipatterns: E-Mail is Dangerous

2011-07-07T00:02:00.000-07:00

Using e-mail is an important communication tool in software companies, but performing communications mostly with e-mail is dangerous. In this post, this issue will be detailed together with common e-mail mistakes. This information can be generalized for most types of companies.

E-mails may be used for some kind of situations:

For sending a report, meeting record etc. which is not confidential, to a manager or a group.
For sending a short message which is not urgent, to a person who can’t be accessed via telephone and face-to-face.

E-mails should NOT be used for these situations:

For confidential messages and criticisms: E-mails can be distributed to other people or large groups easily, so this is not a good idea.
For situations which could be used as evidence in a court of law : For example, if you say “We will do X item in a month” to the customer with e-mail, it can be a mandatory item for you in the next days.
For explaining a complex topic: It will be time consuming to write hundreds of words. Speaking will be more effective.
For explaining an important, sensitive topic: Word emphasis, voice tone, gestures and mimics are very important for conversations. E-mails have none of them and this may cause misunderstandings.

And some e-mail suggestions:

Don’t use e-mail bodies as title, this is ridiculous:

Title: Please send me a report about X task.
Body: nothing

Don’t put hundreds of people to your e-mail’s “TO” or “CC” list. Use BCC. Otherwise all people and spam softwares will know all e-mails:

To:a1@a.com, a2@b.com, ... , a1000@z.com
CC:a1001@z1.com, …, a2345@zz.com

Don’t use infinite forwards for e-mails. These type of mails are not funny for most people.

To: hundreds of people
Title: FW:FW:FW:FW:FW:FW:FW:FW:FW:…

Don’t use e-mails as FTP. Use a file transfer protocol for sending messages larger than a few MB. A common wrong usage:

Attachments: AnImportantDocument.pdf (123 MB)

Don’t use e-mails as a version controlling system. Manage your documents with a real version controlling system:

Attachments: “CustomerReport_last_20122010_newest_veryVeryLast_1_1.doc”.

Don’t use so many smiley images, big signature images, long signatures, colorful decoration templates in your e-mail. These are generally disgusting and unnecessary. Besides, they will increase network load.

Sources:

· http://sourcemaking.com/antipatterns/e-mail-is-dangerous

· http://www.dzone.com/links/r/if_you_do_this_in_an_email_i_hate_you.html

Develop Rich Web Applications with Java by Vaadin Framework (Introduction)

2011-06-24T06:57:00.000-07:00

Vaadin (http://vaadin.com/home) is an open source web application framework having a server-side architecture which constructs user interface of web applications as RIA (rich internet applications), using Java code only.

Vaadin Logo

For developing Vaadin applications, you only use Java code, like Java Swing. This Java code is then converted to GWT (Google Web Toolkit) components (which are HTML and Javascript based) for browser side, and AJAX code sections are generated for some actions to support RIA concept. Server side validation is also performed for all actions.

An example source code is shown below:

import com.vaadin.ui.*;

public class HelloWorld extends com.vaadin.Application {

public void init() {

Window main = new Window("Hello window");

setMainWindow(main);

main.addComponent(new Label("Hello World!"));

}

And the result is:

Vaadin Hello World Example

Vaadin supports so many UI components and these can be extended with new GWT components if required, and CSS themes can be applied to results. For using Vaadin, only a JAR file is enough. Some Eclipse and NetBeans plugins are also available for easier development if required.

Vaadin supports JPA (java persistence API) container package JAR for database operations. By using containers, you can associate components to database operations directly, e.g. if the item list of a container changes, related visual component’s list is changed too.

Here is an example view of a Vaadin application layout VaadinTunes (http://demo.vaadin.com/VaadinTunesLayout/):

Vaadin Tunes

Because of Vaadin UI components are generated automatically from Java code, they may generally have some complex structure and a bit slow compared to a pure HTML page. For increasing the performance, some optimization rules are suggested: http://vaadin.com/wiki/-/wiki/Main/Optimizing%20Sluggish%20UI

But development time gain is very high and rich & interactive web components can be developed without any script language information. These parameters must be considered while choosing the technology.

Vaadin is very well documented. You can take a look at “Book of Vaadin”:

http://vaadin.com/book/-/page/preface.html

A Brief Look at Apache Velocity

2011-06-06T00:29:00.000-07:00

Introduction
Velocity is a template engine. Using Java classes, you can inject objects into template engine and use those injected objects in velocity template (.vm) files.

Its benefits are:

It can be used in desktop applications, web applications and other areas where a structured text or code is required.
It can be used as a powerful code generator. Dynamic codes are created by velocity injected objects.
It can access all public attribute and methods of given object.
It has an easy and clear syntax.
You can define user interfaces (HTML, JSP etc.) dynamically and developers and designers can work seperately. So, MVC pattern can be used too.

Examples

Here is an example velocity template file helloWorld.vm:

Hello $param

And below is an example Java file HelloWorld.java that uses the template:

import org.apache.velocity.app.VelocityEngine;

import org.apache.velocity.Template;

import org.apache.velocity.VelocityContext;

import java.io.StringWriter;

public class HelloWorld

{

    public static void main( String[] args ) throws Exception

{

        /*  first, get and initialize an engine  */

        VelocityEngine engine = new VelocityEngine();

        engine.init();

        Template template = engine.getTemplate( "helloWorld.vm" );

        VelocityContext context = new VelocityContext();

        context.put("param", "World");

        StringWriter writer = new StringWriter();

        template.merge( context, writer );

        System.out.println( writer.toString() );     

}

}

Console Result: Hello World

In the code Velocity engine is created, initialized, velocity tamplate file template is taken, required parameters are put into context, and at last the string is written to the screen.

Commands

Velocity also has a built-in VTL (Velocity Template Language) syntax that has following statements:

VTL Tags

Escape Tool

Because of the VTL is a template language, string operations are required widely. For that case, some escaping methods are supported for java, javascript, html, xml, sql and some character renderings exist:

(For more detail http://velocity.apache.org/tools/devel/generic/EscapeTool.html)

For example,
$val = “Stop!”
$esc.java($java) 
produces \”Stop!\”
or
${esc.d} produces $ output.
${esc.h} produces # output.

20 Software Development Best Practices

2011-02-26T14:56:00.000-08:00

Below are a compilation of 20 software development best practices:

Always use source control system even if the project has only one developer. By doing that, you don't lose some or whole code immediately, can share same source file by multiple person and can take the whole advantage of coding histories.
Follow coding standards and check that standard with automized tools.
Be consistent. If you do operations in a specific way, do that kind of operations in the same way (e.g. defining variable/method/class names, paranthesis usage etc.).
More code does not mean better code. Keep it simple and reduce complexity.
Don't use magic numbers and strings directly in the code. Use constants. This method provides more modularity and understandability.
Don't use comment lines to delete code, just delete. Version controling system will help you if deleted code is required.
Delete unused methods and classes. Version controling system will help you if deleted code is required.
Catch specific exceptions instead of highest level class 'Exception'. This will provide understandability and more performance.
Use understandable and long names for variables. Loop variable names can be i, j, k, index etc., local variable names must be longer than loop variables, parameter names must be longer than local variables and static variable names must be longer than parameters; proportional with scope size.
Package related classes (that changed together and/or used together) together.
Use understandable comments. Bad comment is worse than no comment.
Use positive conditionals. Readability of positive conditionals are better than negative ones.
Use dependency injection to manage too many singletons.
Use exceptions only for catching exceptions, not for control flow. Think as required and perform control flow with control statements/conditionals.
Don't use so many arguments with methods. Keep the number at most 8-10. If more is required, review your design.
Don't use method alternatives with boolean flag variables (public void someMethod(bool flag)). Write more than one method for each flag condition.
Method names must include "what is done by this method" information.
Think twice before defining a method as static and be sure if you really need to. Static methods are harder to manage.
Avoid using methods with reference parameters. Use multi attributed object parameters instead.
Number of interface methods must be minimized to decrease coupling/dependency.

A Brief Explanation of HttpModule and HttpHandler

2011-02-26T13:39:00.000-08:00

An HTTP request from client to server can be explained as a chain of IIS, AspNET_ISAPI, Asp.NET Work Processor, HttpModules and HttpHandlers. The last part of the chain which is HttpHandler, creates the HTML and sends the result to HttpModule. AspNet_IASPI.dll is used for Asp.NET pages. And chain completes in reverse order this time, as shown below:

Http Request Lifecycle

HttpModules and Usage:

We can use several predefined methods of the Global.asax file to perform actions on start/end of the application, on start/end of the request etc., and an HttpModule do the same thing with more modularity. So, an HttpModule can be thought as a modular alternative of Global.asax file and its usage is recommended.

For creating an HttpModule, you should implement IHttpModule interface, and then Init and Dispose methods. We can use HttpApplication object:

using System;
using System.Web;
namespace CodeBalance.Web
{
   public class ExampleHttpModule : IHttpModule
   {
   public void Init(HttpApplication app)
   {
   app.BeginRequest += new EventHandler(newBeginRequest);
   }
   public void Dispose()
   {
   // dispose operations, if necessary
   }
   void newBeginRequest(object sender, EventArgs e)
   {
   HttpApplication context = (HttpApplication)sender;
   string Url = context.Context.Request.RawUrl;
   if (!Url.Contains("SystemMonitoring.aspx"))
   {
   // show error page
   }
   }
   }
}

You can easily add/remove HttpModule via web.config file:

HttpHandlers and Usage:

HttpHandlers define actions for different type of requested files. They also can perform actions even if that file does not exist. An HTML page can perform all of the operations of an HttpHandler. But an HttpHandler has better performance and has more modularity than pages.

For creating an HttpHandler, you should implement IHttpHandler interface and then IsReusable and ProcessRequest methods. We can use HttpContext's Request and Response objects:

using System;
using System.Web;
namespace CodeBalance.Web
{
   public class ExampleHttpHandler : IHttpHandler
   {
   public void IsReusable(HttpApplication app)
   {
   // readonly.determines if this handler can be used in another requests
   }
   public void ProcessRequest(HttpContext context)
   {
   context.Response.Write("Hello World!");
   }
   }
}

You can easily add/remove HttpHandler via web.config file:

A Selection of Successful Software Engineering Posts - Part 1

2011-01-18T13:43:00.000-08:00

This selection (Part 1) contains 25 blog posts selected by CodeBalance which were placed on DZone in 2010.

Project Management & IT Business
You're a Bad Manager. Embrace It.

Starting your own Software Company? Think twice.

Comparing Open Source Agile Project Management Tools

Software Architecture

10 Suggestions for the Architect of an Agile Team

Sessions, Sessions Everywhere

Modelling/Analysing

Understanding Code Visually: Three Ways that Work

Role of UML in Agile & Evolutionary Architecture

About Programmers/Software Engineers:

The Psychology of Programmers

Can You Be Too Old For Software Development?

Developers Still the Most In-Demand IT Workers

Programming/Software Engineering Practices

Always code as...

Things to do to improve code quality

Pair programming Issues

Java

How to write Secure Java Code

The Unbearable Lightness of Java – jodd

.NET

Code Review: .NET Application Performance

Parallelizing Windows Applications in .NET 4.0

ASP.NET Developer Guidance Map

Mobile Programming

Beginning Android Game Programming

Android UI development tools

Development Tools

Top 10 Most Popular Eclipse Plugins

.NET Developer Tools - What you should (could) have in your toolbox

5 Maven Tips

and Some Fun...

If you do this in an email, I hate you.

For whom do we develop software!

10 Differences Between WCF and ASP.NET Web Services

2011-01-16T10:34:00.000-08:00

Here are the 10 important differences between WCF Services and ASP.NET Web Services:

10 Differences Between WCF and ASP.NET Web Services

For details: http://msdn.microsoft.com/en-us/library/aa738737.aspx

A Theorical Introduction to Data Mining

2010-12-14T13:00:00.000-08:00

This article introduces the aim of data mining and explains basic concepts and terms.

Data Mining (i. e. Knowledge discovery from data): Extraction of interesting (non-trivial, implicit, previously unknown and potentially useful) patterns or knowledge from huge amount of data.

Data Warehouse : A single, complete and consistent store of data obtained from a variety of different sources made available to end users in a what they can understand and use in a business context. [Barry Devlin] Data warehouses are used for data mining.

Potential Usages : Web information mining, spam filtering, medical data mining, weather data mining, market sale strategies etc.

Data Mining Related Operations

Preprocessing:

Handling Noisy Data : Handling missing, duplicate or errorneous data before data mining. Noisy data can be removed, or corrected by a specific approach (i.e. correlation analysis).

Integration : Combining data from multiple sources.

Normalization : Scaling data to specified range. For example, scaling 750 in [500, 1000] to range [0,1] (the result is 0.5)

Feature Selection : Selecting only useful features (i.e. attributes for record data) of data.

Data Mining:

Classification: Finding a model for a class attribute of data to predict the values of other attributes. (An example class attribute: CustomerBuysProduct (bool))

Different methods can be used for classification:

Decision Trees: Uses decision trees to make model and evaluates new data on the tree.
Rule-Based Classifying: Deduces rules on the data (if X = Y and if Z z T result is W etc.).
Bayes Classifying: Uses previous probabilities to classify.
K-Nearest Neighbor Classifying: Uses distances between previous data to new data, to classify.
...

Clustering: Finding groups of objects such that the objects in a group will be similar (or related) to one another and different from (or unrelated to) the objects in other groups.

Different methods can be used for clustering:

K-means Clustering: Splits data according to a previously known number of clusters.
Hierarchical Clustering: Produces a set of nested clusters organized as a hierarchical tree.
...

Association (Rule) Discovery: Producing dependency rules which will predict occurrence of a feature (i.e. attribute) of data based on occurrences of other features.

Pattern Discovery: Deducing patterns as a result of classification, clustering, Pattern discovery etc.

Postprocessing: Evaluating and selecting interesting patterns, interpreting and visualizing them as an information report.

Software Antipatterns : The Golden Hammer

2010-10-29T10:46:00.000-07:00

Preface

A "software pattern" is a predefined and accepted solution for a specific software problem. Similarly, a "software antipattern" is a predefined and accepted unsuccesful solution. It's known as a bad solution, and should not be used.

The Golden Hammer Antipattern

The Golden Hammer can be defined as an architecture, a solution or a software tool that is believed to be the best solution for every software problem/project.

If a software team had successful experiences with a software architecture, tool or solution they may want to use that in every other problem/project. Especially if that experience had a success in the past, this probability will be higher. Or if that experience had been costly for the company and new experiences will be more costly, managers may not give resource for new techniques.

There can be other causes: The software team either don't want to learn new technologies and techniques, so they want to use their "known" technology/technique in every problem or they are not aware of the growing world of technology and new solutions.

For example, "using well known software patterns in every software project" is a golden hammer antipattern. Because of one or more causes told before, this approach can be used and probably will be harmful for the software. And maybe it will not be corrected in the future because of project calendar.

Eventually, each software problem/project is different is its own context. And must be evaluated in its own cases. Using same approaches for every problem is dangerous.

10 Free, Standalone and Easy to Use UML Editors

2010-10-14T12:24:00.000-07:00

Below is a compilation of UML drawing & editing tools which are:

Free (and most of them are open source),
Standalone (not installed as plug-in or add-in),
Easy to download and install,
No-need to registration and activation keys,
Fast to start and use.

Note: Last 2 editors are text based web uml tools.

1. Violet

2. Argo UML

3. DIA

9. yUML (text based online tool)

10. Web Sequence Diagrams (text based online tool)

Most Useful Shortcuts for Visual Studio 2010 & Eclipse 3.6

2010-10-06T12:51:00.000-07:00

Below is the most useful shortcuts for Visual Studio 2010 and Eclipse 3.6 Helios. Many of them are also available for every version of these editors:

Shortcuts for Visual Studio 2010 and Eclipse 3.6 Helios

10 Successful e-Book Search Engines

2010-09-26T13:54:00.000-07:00

Below are 10 successful (with large e-book databases, easy to use and minimal design) e-book search engines:

1. Mega PDF

2. Doc Jax

3. PDF Database

4. PDFind

5. PDF Geni

6. Type PDF

7. PDF SE

8. E-Book Search Engine

9. E-Book EE

10. Flazx

OOP SOLID Rules : Interface Segregation Principle (ISP)

2010-09-22T11:30:00.000-07:00

Introduction:

Object Oriented Programming (OOP) has 5 basic rules which shortly named as SOLID:

S : Single Responsibility Principle

O : Open Closed Principle

L : Liskov Substitution Principle

I : Interface Segregation Principle

D : Dependency Inversion  Principle

Interface Segregation Principle is explained with examples (in Java language) in this article.

Explanation:

Some interfaces are created with huge amount of functionalities. But when those interfaces are implemented by client implementor classes, not required functionalities are forced to be implemented, and so the code will have many dummy or empty implementations.

This situation can be prevented by segregating (i.e seperating) big interfaces into smaller ones. Only strictly related method definitions must be in the same interface. Different types of functionalities must be placed in different interfaces.

Examples:

Below is a wrong design that's not using Interface Segregation Principle. Implementor classes have to implement unnecessary methods.

public interface Animal {

    void fly();

    void run();

    void bark();

}

public class Bird implements Animal {

    public void bark() { /* do nothing */ }

    public void run() {

        // write code about running of the bird

}

    public void fly() {

        // write code about flying of the bird

}

}

public class Cat implements Animal { 

    public void fly()  { throw new Exception("Undefined cat property"); }

    public void bark() { throw new Exception("Undefined cat property"); } 

    public void run() {

        // write code about running of the cat

}

}

public class Dog implements Animal { 

    public void fly()  { }

    public void bark() {  

        // write code about barking of the dog

}

    public void run() {

        // write code about running of the dog

}

}

And below is the implementation which uses ISP:

public interface Flyable {

    void fly();

}

public interface Runnable {

    void run();

}

public interface Barkable {

    void bark();

}

public class Bird implements Flyable, Runnable {

    public void run() {

        // write code about running of the bird

}

    public void fly() {

        // write code about flying of the bird

    } 
}

public class Cat implements Runnable{ 

    public void run() {

        // write code about running of the cat

}

}

public class Dog implements Runnable, Barkable { 

    public void bark() {  

        // write code about barking of the dog

}

    public void run() {

        // write code about running of the dog

}

}

Interface Segregation Principle is one of the key points in OOP. By following this principle, growing interfaces will no longer be a problem.

Creating a Visual Studio Add-In in 1 Minute

2010-09-16T12:44:00.001-07:00

This article introduces the basics of Visual Studio Add-In (aka "Plug-In" in Java terminology) creation.

Note: This information is valid for every version of Microsoft Visual Studio. Examples will be given over Visual Studio 2008 and .NET version 3.5.

First, choose File --> Create --> Project. After that choose "Extensibility Project" type and "Visual Studio Add-In".

Then, you can choose "Next" for every step of the Add-in wizard. And finally press "Finish" for the last step:

After that, the add-in project is created. Required DLLs and directory structures are ready. "Connect.cs" class is the most important part and starting point of the add-in. And ExampleAddIn.AddIn file is the add-in descriptor file, which has the basic information (eg. add-in DLL file location, about info...) of add-in.

"OnConnection" method is the starting point of add-in execution. _applicationObject and _addInInstance objects are taken at the start as default. These objects are used to have control over Visual Studio application actions. As an example, let's put an "hello world" dialog at the startup of add-in:

You can enable add-in (and also set the add-in to run on the startup and/or command line) using Tools --> Add-in Manager... menu and the following screen:

Once you press F5, you will see Visual Studio re-starting and the "hello world" dialog:

Specific add-in examples, details and configurations will be explained in future posts.

4 Rules of User Interface Design

2010-09-06T07:38:00.000-07:00

1. Consistency

First of all, user interface design must be consistent. For example, all text alignment of labels must be the same for the whole application. If capital letters are used, all labels must be capitalised. Also, predefined company based user interface components (e.g. text fields with type conversion, table with add/remove buttons etc.) can be used for design consistency and functional equality.

The best way to provide consistency is using templates. If there are rules, whole software team will obey them. And those rules are preferred to be formed and used on the way, because if all user interfaces are completed there may not be enough time to change all screens.

Inconsistent and Consistent Labels of a Screen

2. Usability

User interfaces are preferred to be used by a person who hasn't got any information about that screens. For achieving this, screen components must be placed correctly and information on the screens must be enough. Component sizes, selection types, obligations and placing priorities must serve the purpose.

3. Simplicity

Simple is always the best. Complex screens also violates the "usability" rule. User interfaces must contain as least element as they can. Unnecessary elements causes complexity. In addition, a function of user interface may be reached by only one way (menu item, button or keyboard shortcut) for decreasing complexity. But if the structure of a complex application requires a function to be run by more than one ways (by menu item & shortcut keys & quick launch button on the screen) to guide user, this approach can be discarded.

4. Elegance

For the most end-users, managers and for customers, user interface equals the whole software. Those people are not related with sublevel implementation design, they only see the screens. So, elegant design is very important.

This requires employers which have the viewpoint of art. Only by improving the screen designs, a software can seem to be renewed and upgraded.

A Windows 95 and Windows 7 File Dialog

5 Implementations of Singleton Pattern

2010-08-25T11:21:00.000-07:00

This article introduces singleton design pattern and its 5 implementation variations (with C#).

Problem
At most one instance of a class must be created in an application.

Solution
That class (singleton) is defined including its own instance, and the constructor must be private.

Implementations

1. Lazy initialization, non-thread safe: This is the classical version, bot it's not thread safe. If more than one thread attempts to access instance at the same time, more than one instance may be created.

public class Singleton {

    private static Singleton instance = null;

    public static Singleton Instance() {

        if (instance == null) {

            instance = new Singleton(); 

}

        return instance;

}

    private Singleton() {}

}

2. Non-lazy initialization, thread safe: This is the simplest thread safe version, but it does not support lazy initialization.

public class Singleton {

    private readonly static Singleton instance = new Singleton();

    public static Singleton Instance() {

        return instance;

}

    private Singleton() {}

}

3. Lazy initialization, thread safe: This version supports both properties, but has performance problems. Once a thread uses singleton instance, the others have to wait because of lock.

public class Singleton {

    private static Singleton instance = null;
    private static readonly object lockObj = new object(); 

    public static Singleton Instance() {
        lock (lockObj) { 

            if (instance == null) {

                instance = new Singleton(); 

}

            return instance;
        } 

}

    private Singleton() {}

}

4. Double-check locking: An improved version of the third solution. Two null controls prevent lock waits for most time, but not always. Also, it does not work properly for Java because of Java memory management approach.

public class Singleton {

    private static Singleton instance = null;
    private static object lockObj = new object(); 

    public static Singleton Instance() {
        if (instance == null) {
            lock (lockObj) { 

                if (instance == null) {

                    instance = new Singleton(); 

}

            } 
        }
        return instance;

}

    private Singleton() {}

}

5. Nested initialization: A nested class is used for lazy initialization. This version is also thread safe, but a bit complex. For most situations, solutions 2 or 4 will be suitable according to performance parameters.

public class Singleton {

    public static Singleton Instance() {

         return Nested.instance;

}

    private Singleton() {}

    class Nested {
        static Nested() {}
        internal static readonly Singleton instance = new Singleton(); 
    } 

}

Usage:

public static void Main(string[] args)

{

Singleton instance = Singleton.Instance();

}