1. Choose a Niche - Today, anyone can have a website and sell merchandise or services on the internet. The choices are endless and only limited by your imagination. If you are already in a business and don’t currently have a website, then it’s simply a matter of deciding what name to chose. If you are thinking about setting up your first website and aren’t sure what niche to chose, you might consider a favorite hobby. I’ve always liked to collect & repair antique radios, so I setup a website called http://RadioExchange.net

The fastest way to achieve success and a high ranking on the internet is to build a website around a theme and niche which does not have a large amount of competition. For instance, if you were to start a web hosting website, it would be an uphill battle because there are thousands and thousands of hosting websites already on the internet fighting to get in the top 10 or 20 listings in the major search engines like Yahoo, MSN and Google. The more competition, the more costly and time consuming it is to get your website seen. An alternative is to research untapped markets or there’s a detailed report you can download on 109 Untapped Markets. The price is only $33. and it’s well worth it. To get your report go to Niche Topics http://7ac1x2.5millbucks.hop.clickbank.net

2. Purchase a Domain Name – Think of a domain name which uses the words which describes your business or what you will be selling. If your domain name contains the keywords which describe your business, you are likely to rank higher than with names which do not. For instance, if you are a realtor located in Orlando Florida it would be a good idea to register the domain name OrlandoFloridaRealEstate.com/net or org or Orlando-Florida-Real-Estate.com/net or org. A scientific way to determine the best name to use is to run keyword popularity searches using Overture's Keyword Tool at http://inventory.overture.com/

You can search for domain names and register them at http://fasthosting.com.au and they offer excellent 24/7 live customer service.

3. Set Up Web Hosting - Webster Hosting is what connects your Webster to the internet so it can be viewed by people around the world. Prices for hosting service range from free (I would not recommended a free service - you get what you pay for) to $39.95 per month which is on the high end. Some hosting companies charge a setup fee and demand a year commitment. I would not use any hosting service which charges a setup fee or expect a long term commitment because there’s so many which does not. http://Website-Supermarket.com offers excellent hosting services for only $7.95 per month with 24/7 live customer service and no set up fee and no annual commitment is required.

4. Design Your Website - If you have no experience or limited experience designing a website you can choose from thousands of professionally designed website templates for as low as $20. At http://fasthosting.com.au and they are available. Just browse through until you find a template you like, then click “Buy this Template” and download to your computer. They also offer 1000’s of clip art and photo art work ideal for customizing a website. Unlike many of the other template websites, after you’ve selected the site you want, if you need help customizing your template and getting on the Internet, they offer a set up service to get you up and running quickly. If you choose to customize the template yourself you will need web design software such as Macromedia Dreamweaver or Front Page and Image software such as Adobe Photoshop. Macromedia Fireworks is also a super software program for designing websites.

5. Upload Your Web Site files to your Hosting Service’s Server – Most Web creator software such as Front Page and Macromedia Dreamweaver has built in FTP (File Transfer Protocal) capability. A super program I recommend for uploading and downloading files is Cute FTP by GlobalScape. You can download a copy from their website at http://Cuteftp.com

6. Submit Your Website to the Search Engines - I recommend Submit-It which is a Free service that Submits your URL to all of the major Search Engines such as Yahoo, MSN & Google. Their website address is http://www.submitplus.com/scripts/affiliates/clickthru.cgi?id=bj7780

http://fasthosting.com.au has reference material and articles to help you make your Website a Success!

Search engine optimization is the process of choosing targeted keyword phrases related to a website, and ensuring that the website places well when those keyword phrases are part of a Web search.

ON-PAGE OPTIMIZATION FACTORS:

The Major Factors Are:

Meta Tags, Header Tags, Text-body tag and Alt image tags:

1- META TAGS:

Meta Tags are code in your HTML that is invisible to the visitors of your web site but are read by some web spiders and search engines.

Meta tags used by a large percentage of the top search engines as one of the main guidelines on how they will index your site

The Main Meta Tags are:

• Title Tag
• Description Tag
• Keyword Tag

Targeting the right keywords:

Do keyword research- it is very important in building traffic

To do your keyword research visit this website <a href='http://fasthosting.com.au'>http://fasthosting.com.au</a>

Select a short list of 3 to 4 keywords

Title tag:

The page title should include ONLY your main keywords. The least amount of words you can place in the title, the more weight Google will give to each of the keywords and the higher you will rank.

The title is the most important piece of information search engines use to index Web pages. Include the title of your page and 3-5 important keywords. Format your site title as follows:

Site title, keyword1, keyword2, keyword3

You may use your URL, or the name of your company as your site title.

• Make sure it specifically describes your product or service,
• Makes proper use of 3 or 4 keywords,
• Use between 10 and 80 characters long.

Tips:

• Taken out all of the "ands"
• Replaced one of the "ands" with a "|" character
• Always Combine Your Keywords In The Page Title

Description Tag:

The Meta description tag describes your site's content, giving search engines' spiders an accurate summary filled with multiple keywords.

• Use a descriptive paragraph or sentence that is relevant to your page.
• If possible, use a sentence or paragraph that is present in the content of your page
• Use up to 500 characters, including spaces.

Keyword Tag:

Use a list of keywords that are relevant to the content of your web page. Use your url as the first key word and separate the keywords with commas. Format the key words as follows:

www.sketch-plus.com, keyword1, keyword2, keyword3, …..

Add 5-10 Keywords

• For best results a tag sized between 50 and 250 characters.
• Note that keywords should be separated with commas.

Free Meta Tag Analyzer:

This Meta tag analysis tool will help you analyze your web pages and
check for search engine compatibility.
http://www.hypergurl.com/form.html

More Sites for SEO:

http://www.submitnet.net/
<a href='http://fasthosting.com.au'>http://fasthosting.com.au</a>

2- HEADER TAGS:

Headers are used to break entries up into logical sections.

Add h1 header tags- (Place your most important keyword) it's best to place your h1 header tag on the top left hand or top/middle portion of your page.

When Google reads a webpage, it views the text from the top left hand side of the page to the bottom right hand side of the page.

Add h2 header tags- (Place your 2nd most important keyword) should be placed somewhere towards the top half of your webpage.

3- TEXT- BODY TAG:

The body element defines the documents' body. It contains all the contents of the document (like text, images, colors, graphics, etc.).

• When writing the content, try to evenly sprinkle your main keywords throughout the copy. Don't overdo it though.
• Try to mention each keyword in a natural way as you are writing
• Include at least one of the keywords per 1-2 paragraphs, depending on how large your page is.
• Make sure to mention your main keyword at the very top left and the very bottom right hand side of the webpage
• Bolding, italicizing and underlining...Once we've finished writing the copy, we should go through and bold, italicize, or underline some of the keywords only 1 time each, maximum.
• Any keyword must be used 4 times or more in your site's HTML body. This is highly recommended for best ranking results.
• Avoid Excessive Keywords- No word to be used more than 30 times throughout the page.

4- ALT IMAGE TAGS:

ALT tags are images' descriptions.

• Place your keyword 1 in the alt image tag of the very top image in your webpage.
• Place your other 2 keywords plus an extra word like "picture" or "image in the alt image tag of 2 more graphics throughout your webpage.

LOAD TIME ANALYSIS:

If your Web site does not load in 12 seconds or less with a 56k connection, statistics show that about 45% of visitors will leave the site.

• Optimized you site for 56k modem users- Load time 12 second or less.
• Try to keep your homepage under 50k and your other pages under 40k.

SEARCH ENGINE GUIDELINES:

Always remember this general rule when building your site: “Search engines do not like to be fooled”. Do not try to manipulate your listings through sneaky methods. Provide useful, relevant content, and you will never have to worry about search engine guideline violations.

• Hidden Text - you never hide text.
• Excessive Keywords-Use keywords naturally in sentences and paragraphs.
• No word to be used more than 30 times throughout the page.
• Repeated Keywords- No keywords to be repeated multiple times in a row. We recommend using keywords naturally in sentences and paragraphs.
• Doorway Pages- Doorway pages are discouraged by most search engines.
• Harmful Redirects- Redirecting pages have a hard time being indexed by search engines.
• Frame Issues- It is recommended for sites that use frames to implement a descriptive NOFRAMES tag with relevant text content.
• Macromedia Flash Issues- Don't create all-Flash pages for any content you want to get indexed - instead, put that content in the HTML portion of the page.

To build an ecommerce web site yourself is really not such a difficult task when using the right kind of tools. You will want to build an ecommerce website using the latest technologies such as a user-friendly shopping cart, integrations with top auction sites as well as a payment gateway. Although the web site design is important, correct usage of the ecommerce marketing tools will result in many business transactions.

Here are some points to consider when getting down to building an ecommerce website.

a) Its design should facilitate easy buying of goods and services

b) Your products or services should be of value to the customers

c) Offer personal attention to all customers

d) Offer discounts and e-mail promotions to them so that they keep returning to your site

The design of your web site should mirror your business and what you want to market. The website is your interface with your customers and through it you must be able to convince them to buy your product. At the same time it should not be aggressive towards sales and scare off the visitors.

When you build an ecommerce website you need to use as many keywords (the words through which the search engines bring visitors to your online store) as possible to ensure that the search engines list your store higher when the visitors are looking for the items you sell.

With more than hundred different internet browsers currently available you need to ensure that your site is compatible to be picked up by all of them. Build an ecommerce website that is viewed in at least Internet Explorer 4.0+ and Netscape 4.0+. This is helpful in getting traffic to your site.

The images used on your site should detail your merchandise clearly. Also be sure to optimize your images for fast download; one loses a lot of customers who can’t wait endlessly for the pictures to show up.

Site navigation should be easy to understand and use. Answer any and all questions you think visitors may have in the FAQ section. Buyers hate to meander on a site if it leads nowhere, so the easier your site navigation the more sales you will have. Build an ecommerce website specially designed for your business in a cost effective way to promote your products or services.

There are many sites on the internet (about 50 million active sites and over 100 million active Hostnames). However, many of these sites don’t serve their intended purpose, or in other words, haven’t reached their full potential.

For a business that isn’t an internet based business that could still survive without the internet or computers, what is the purpose of a website you may ask? Other than selling something online, there are still a number of good reasons for having a website: To alleviate menial tasks, to market yourself inexpensively or merely to provide basic and freely available information about your business.

There are really two types of websites, either selling something online or providing online information. These two categories can be expanded to a great extent, covering types of online products or services and various categories of information, e.g. brochure ware type information, blogs, forums, educational, etc. But for the purpose of this article I have contained it to just the two – therefore, as a visitor to a website, you either pay money for something or you get information that is publicly available.

I will be focusing on the second type of website, i.e. where someone has information that they want to share.

The first reason to have an informative type website that I’m going to discuss would be to alleviate menial tasks. Most businesses have many repetitive tasks that need to be performed on a daily basis. If you can highlight these tasks and categorise them and separate out the tasks that involve client interaction, you then have valuable information that can be incorporated into your site. A very basic example would be if you have a form that each of your clients need to fill out (for an application, registering details or whatever), you could make that form available on your website and direct your clients there. This will free up a staff members’ time that is required to explain the procedure over and over, it will also save on postage costs, paperwork, paper or the actual time spent emailing the form to your clients. This in turn would also save time spent on processing the information on the completed forms; it will already be in soft copy in the correct format that you chose on your website. Your imagination is the only boundary of what can be achieved on your website and to what level you want to take it to...

The next reason to having a website would be to market your business. If you’re in business, it means that you want people to know you exist, and with the internet at our disposal, why not use it? In my article “As a Small Business Owner, Why Do You Need Your Own Domain Name?” I explained the benefits of owning your own domain name. If you have registered your domain already, then you may as well publish a website and get some marketing out of it. Again, it is entirely up to you how successful you want to make it. There are many guidelines on the internet explaining how to improve your website’s exposure and attract more traffic/potential clients to your site.

Finally, if neither of the two reasons for having a website have grabbed your attention, then you should still do it anyway; even if it’s just to advertise your contact details. In the past, people would solely use directory listings to find business details, however these days, the internet has made searching for businesses, including your competition, very easy and widely used. Therefore it’s a good idea to have your contact details on a simple site. Even a copy of your business card published as a one page site is better than nothing.

Next time you’re looking for information from a specific business, see if the information you are looking for is or could be found on their website and explore the possibilities.

<a href='http://fasthosting.com.au'>Fast Hosting</a> has been involved in the Hosting industry for over 6 years working with global companies.

Your domain name choice can be critical to your business yet many do not know how to choose a domain name. If you want a successful business you will need it to be accessible from the internet. To achieve that you will need a website, and hence a domain name. The domain name is the name by which your site is known, such as mysite.com and the number of domains registered on the internet has increased from about 10 million in the year 2000 to over 50 million now.

There are a few approaches that can be taken to choosing a domain name, and each can be appropriate according to the circumstances. It is not always a good thing to name your website after your product, especially if you are trying to get it established in the market place. For example, if you invented an ionic hydrogenator that no one had ever heard of, the domain ionichydrogenators.com would not be one that many people would search for, and neither would the keyword ionic hydrogenator.

It is important that the name you give to your website will have the possibility of being found by somebody searching for an answer to their problem on the internet. If your ionic hydrogenator made your car go faster, then fastcars.com or fastengines.com would be more likely to attract traffic.

If you already have an offline business that you want to put online, you will need a domain name that is either the same as that of your business, or that describes what it does. For instance, if your business is “Resume Writers” then your domain name should be resumewriters.com. If you find that is taken, do not opt instead for writeresumes.com since nobody will find you. Far better would be resumewriting.com or resumewriter.com.

For tips on choosing the right domain email href=' This e-mail address is being protected from spambots. You need JavaScript enabled to view it '> This e-mail address is being protected from spambots. You need JavaScript enabled to view it >.

An Overview of Object-Relational Mapping (ORM)

Note

•          A one-to-one relationship is when a record in table 1 can have exactly one associated record in table 2. For example, a record in a Person table might have exactly one related record in a JobTitle table.
•          A one-to-many relationship is typically seen in parent-child relationships where a parent record can have several related records in a child table (for example, related via the parent's primary key).
•          A many-to-many relationship is where a record in table 1 can have several related records in table 2 and vice versa. For example, an Employee table might have more than one record in a Project table (because an employee can be involved in multiple projects). On the flip side, a record in the Project table might have several related records in the Employee table because a project can have multiple employees assigned to it. Also, this type of relationship is typically achieved by using an (extra) association table (for example, a ProjectEmployee table that contains foreign keys pointing to the two main tables). 

Object Identity

Cascade

Mapping

In-Memory Versus Persisted Objects

CREATE TABLE Timesheet

(
   timesheetId IDENTITY NOT NULL,

copy \hsqldb\lib\hsqldb.jar \anil\rapidjava\timex\lib\

C:\anil\rapidjava\timex>ant -f timexhsqldb.xml starthsql

C:\anil\rapidjava\timex>ant -f timexhsqldb.xml execddl

      classname="${hclass}" classpath="${hjar}"
      args="${hfile} -dbname.0 ${halias} -port ${hport}"/>

     driver="org.hsqldb.jdbcDriver"
     url="jdbc:hsqldb:hsql://localhost:${hport}/${halias}"
     userid="sa" password=""
     print="yes"> 

ant -f timexhsqldb.xml hsqldm

jdbc:hsqldb:file:${catalina.base}/webapps/timex/WEB-INF/data/timexdb

    org.hsqldb.jdbcDriver

    jdbc:hsqldb:hsql://localhost:9005/timex

sa

String departmentCode;
String name;

SessionFactory sessionFactory = new Configuration().configure()
        .buildSessionFactory();
Session session = sessionFactory.getCurrentSession();
Transaction tx = session.beginTransaction(); Department department; department = (Department) session.get(Department.class, "IT"); System.out.println("Name for IT = " + department.getName());

List departmentList = session.createQuery("from Department").list();
for (int i = 0; i < departmentList.size(); i++) {
   department = (Department) departmentList.get(i);
    System.out.println("Row " + (i + 1) + "> " + department.getName()
 + " (" + department.getDepartmentCode() + ")"); }

sessionFactory.close();

classname="com.visualpatterns.timex.test. HibernateTest"/>

 XP and AMDD-Based Architecture and Design Modeling

IN THIS CHAPTER, WE FINALLY BEGIN to get into the technology side of things, so now begins the fun part.

In a truly iterative development environment, all the architecture and design issues would not necessarily be finalized up front. Refactoring (improving code without impacting its functionality) plays a big role in constant improvement to the initially established design because invariably you will find better ways to do something when you are actually coding. Furthermore, while the scope of the project can be defined up front, the user requirements can continue to evolve from iteration to iteration versus having everything locked-down up front. With requirements, the idea is to have a lot of interaction with the stakeholder and be able to ask ad hoc questions.

Although some work can be done up front, such as the user stories, high-level architecture, user interface prototypes, domain model, standards and so on, other design issues can be resolved in the iteration they are applicable to. Furthermore,  "Using Hibernate for Persistent Objects,", "The Spring Web MVC Framework," writing tests first can also help with the design of your classes, so you don't have to have all the fine details of your classes figured out up front; in other words, you can take a just-in-time approach to design, so to speak.

However, some upfront design is bound to happen, perhaps in iteration 0 (perhaps when you are trying to demonstrate a proof-of-concept, which shows that the chosen technologies can work end-to-end, from the user interface to the database, for example).

In this chapter, I hope to provide you with an end-to-end approach using modeling and process guidelines provided by Agile Model Driven Development (AMDD; agilemodeling.com) and Extreme Programming (XP; extremeprogramming.org).

Design Approach and Artifact Choices

In the previous chapter, we looked at an XP-based approach to defining business requirements and working with the customer. In this chapter, we will drill down into some minimal architecture and design to help us get going with building Time Expression, using popular technologies such as Hibernate, the Spring Framework, the Eclipse SDK, and many other related tools such as Ant, JUnit, and more.

If you have come across the myth that XP programmers don't design or document, I hope this misconception will be cleared up by the end of this chapter, because it couldn't be further from the truth. Let me give you a preview of what I'm talking about.

Take a look at Figure 3.1, which shows some possible artifacts you can produce at the release or iteration level. Release-level artifacts are ones you produce prior to a new release; iteration-level artifacts are ones you produce prior to each iteration. These aren't all mandatory for every project, so we can pick and choose the ones we need. However, between Chapter 2, "The Sample Application: An Online Timesheet System," and this chapter, I have chosen to demonstrate as many of these as possible, and practical, for Time Expression. At the end of this chapter, I will show you another diagram that will tie together all the artifacts produced as a result of our efforts between the previous and this chapter (but don't cheat by looking now, because it is a detailed diagram and I don't want to overwhelm you at this point).

At the very least, what you will see in this chapter will give you one perspective. This process might or might not work for you. However, there must be some things good about these methodologies, because developers love them, and I have seen many successful projects as a result of these methods. Also, in our case, the artifacts we will produce in this chapter are essential to the rest of this book, and this process will help get us there.

As you can see from Figure 3.1, we have a few artifacts to produce in this chapter, so let's move forward. However, before we do, I want to provide two perspectives from real-world users of XP.

A project director working at a Fortune 50 company told me recently, "When we kick off an iteration, the first day of the iteration is usually spent reviewing stories and breaking them into tasks. The exercise of breaking them into tasks is truly a design session. What we ended up observing is that something like 20% of the developer's time, during an iteration, was spent in design. If you add all that time for all developers, across all iterations, it was a large numberwhich truly debunked the 'no design' comments."

To give you another perspective on the XP style of working, consider this statement from a senior architect at a well-established IT solutions company that has deployed more than a dozen successful projects using XP and AMDD techniques: "There is also another level of design that happens on an XP project which is at the daily level. Refactoring is a design activity. Although the iteration-kickoff design is an important step, it is the design work after the code is written that makes the difference between an OK design and a truly elegant one."

The difference with the XP approach, is that the architecture and design happens throughout the application's release cycle, not just up front. In other words, the application continues to evolve through the various iterations. The benefit of this approach is that the design is actually applicable to what you are building, not three to six months into development when the requirements could have changedsomething that is certainly possible in our fast-paced and ever-changing world today.

Free-Form Architecture Diagram

Figure 3.2 shows the high-level architecture for our sample application. Note that this has been converted to an electronic version from the whiteboard version we saw at the end of the previous chapter. Converting it to an electronic format is a personal preference; you could just as easily take a digital picture of the whiteboard version, but I personally like clean and readable diagrams.

The architecture is fairly straightforward. We have our standard three-tier web architecture with the client tier (web browser), middle tier (application server), and our data tier (database).

Also standard is the use of the model-view-controller (MVC) design pattern, as you find in most Java-based web frameworks these days. The controller is the point of entry of the HTTP/web request; it controls the model and the view. The model deals with data, which is obtained by the controller and passed to the view for rendering in a presentable way. In our case, the view will be written using JavaServer Pages (JSP).

What makes our architecture interesting isn't that it uses a MVC pattern, but rather what's in the middle tier, namely the Spring Framework and Hibernate, two technologies we will cover in detail later in the book. Hibernate, as you will see later, makes database persistence very easy because you can reference database tables and records as plain old Java objects (POJOs). The Spring Framework (springframework.org) provides many benefits, as well, especially when you're working with POJOs. For example, we will use the Spring MVC for our web framework because it makes for cleaner code (when compared to something like Struts). Another notable feature of the Spring Framework is the support for scheduling jobs rather than depending on an external scheduling service such as CRON or the Windows Scheduler. Of course, the core feature provided by the Spring Framework is the inversion of control (IoC) functionality, which we will learn about in later chapters.

Exploring Classes Using CRC Cards

On the model part of the MVC, we already know some entity names for Time Expression from our domain model. For the controller part, we know the user story tag (Timesheet List, in this example) . Given these, we can now proceed with our initial class design using CRC cards.

In case you have been wondering, CRC stands for class, responsibilities, and collaborators. Table 3.1 shows the layout of a sample CRC card along with some explanations for the three components you see there. Note that although I have shown an electronic version, CRC cards can actually be done on basic 3" x 5" index cards and later translated into a class diagram (if needed).

CRC cards provide an informal object-oriented technique for discovering interactions between classes. I like CRC cards because they can be used in an informal session with developers or users to discover objects without the need for a computer. Furthermore, CRC cards can be used to develop a formal class diagram, if needed (something we will do later in this chapter).

Tables 3.2 through 3.4 show some sample CRC cards for the actual classes we will develop later in this book, to meet the requirements for the Timesheet List screen.

Application Flow Map (Homegrown Artifact)

A Complementary Technique

In comparing this application flow map to techniques such as class diagrams or CRC cards, you will find that this map complements CRC cards and class diagrams. CRC cards list, among other things, responsibilities of each class, which is lacking in the application flow map. Class diagrams on the other hand, show relationships, cardinality, behavior (methods), attributes, and possibly more, which are more details than I like to have in this map.

By putting together classes in a textual and table format, we could also search for class names (in a large system, for example) and also sort these easily using a spreadsheet program or command-line utilities.

Extending the Application Flow Map with CRUD Columns

This table can also be altered for use with non-UI stories such as the Reminder Email: Employee user story. For example, the view and controller class columns can be replaced with a single column named Job, for instance.

Furthermore, you can extend this table by splitting the Tables Impacted column into four separate CRUD (create, read, update, delete) columns. This not only shows which tables are impacted, but how they are impacted, by the various collaborator classes. By adding CRUD columns, you essentially provide end-to-end flow of a user story (from the view to the database and back) in one row of our table.

UML Class Diagram

UML Package Diagram

For our sample application, Time Expression, we will use the prefix com.visualpatterns.timex for our package name.

If you have worked with Java already, you probably know that the first part of the package name is typically tied to an organization's domain name, just used backwards. For example, com.visualpatterns is the reverse for visualpatterns.com, which happens to be my website. The timex portion of our package name is derived from the name of our sample application. The remainder, the suffixes, for our package names are shown in Figure 3.6, a rudimentary UML package diagram.

As you might guess, the controller package will have controller-related classes in it. The job package will contain our email reminder job. The util package contains common and/or utility code.

Last but not least, the test package will contain our unit test code. Although I have chosen to place our test classes in a separate package, many developers prefer keeping the test classes in the same directory as the implementation code they are testing. This is a matter of preference, but in my opinion, having a separate package/directory for the test classes keeps things nice and clean in the actual implementation package directories.

Directory Structure

Sample File Names

End-to-End Development Steps

Given what we have learned in this chapter so far, we can put together the steps that will be required to develop (code) for our first user story, from the web UI to the database, and back. Here are tasks that will most likely be required to complete the first user story:

• Set up our environment including the JDK, Ant, and JUnit

• Write test and implementation classes for model package

• Write test and implementation classes for controller package

Acceptance Tests

Acceptance tests can serve as our detailed requirements as they do in many Agile style projects. One example is a list of valid operations a user can perform on a given screen. The idea of using acceptance tests as requirements is feasible because these tests are something our customer expects our application to conform to. For our purposes, we will use them only for our unit tests; however, it is becoming more and more common in the real world to use acceptance tests as detailed requirements.

The following sections are our list of acceptance tests and something we will implement for the user stories we will develop. In the real world, these types of acceptance tests would be provided by the customer.

Sign In

•  The employee id can be up to 6 characters. The password must be between 8 and 10 characters.
•  Only valid users can sign in.

Timesheet List

•   Only a user's personal timesheets can be accessed.

Enter Hours

• Hours must contain numeric data.

• Daily hours cannot exceed 16 hours. Weekly hours cannot exceed 96 hours.

• Hours must be billed to a department.

• Hours can be entered as two decimal places.

• Employees can view and edit only their own timesheets.

Other Considerations

As I mentioned earlier, we need to do just enough architecture and design to get us going. Although we did a reasonable amount of architecture and design in this chapter, there are a lot of things we haven't discussed yet but will in later chapters, such as the following:

•          Application security
•          Transaction management .We will see how to programmatically implement transaction management using Hibernate.
•          Exception handling .We will look at handled and unhandled exceptions and provide some guidance on when to use one versus the other.
•          Other features Features required for Time Expression such as scheduling jobs and sending emails..

Exploration Phase

The Sample Application: An Online Timesheet System

As I mentioned in the previous chapter, this book tries to follow a flow similar to how a real-world project might flow. In this book, we will pretend that we have a requirement from an internal group (a fictional customer) and use this requirement to build a sample application named Time Expression.

I considered several types of applications to use as an example in this book; in the end I settled on a rudimentary timesheet system because I believed that it was an application most readers would be able to relate to. For example, you might be an employee or consultant who works by the hour, and you submit your timesheet online (and also get it approved online, and so on).

Our sample application, Time Expression, will have a user interface (UI) as well as some background processing. The UI will be web based and will contain screens that provide the capability to enter hours worked, approve timesheets, run management reports, and more. The background processing will include a weekly (scheduled) batch job that is automatically run to send out a reminder email.

Business Requirements

I mentioned earlier that our fictional customer requires a simple online time entry and approval system. Let's go into a bit more detail here.

It is always a good idea to define what business problem is being solved, whom it is being solved for, and why our solution is important to the customer. In addition, it is important to understand what the customer's expectations are: for example, when is the solution needed, and what is the project scope.

Let's assume that a fictional organization wants to build a timesheet system to manage its hourly staff. To get things started, we can define the problem statement as follows.

Given our general problem statement, we can break this down into the following feature set or business requirements; this process could be considered a part of use case analysis, in the Unified Modeling Language (UML) world:

• Hourly employees should be able to sign in to a web application (once or more each week) and enter their hours for each day of a given week. Along with the hours, the employee must select which department the hours are being billed to.

• Employees will be required to submit their timesheets each week.

• An employee's manager is notified of successfully submitted timesheets. The manager must then approve or disapprove the timesheets.

• After a timesheet is approved or disapproved, a notification is sent back to the employee indicating the updated status of the timesheet. If the timesheet is approved, an email is also sent to the accounting department to process the paycheck for the given employee.

• All users of Time Expression will have one or more relevant reports available to them.

• A weekly reminder email will be sent out to employees who have not submitted their timesheets. Another reminder email is sent to managers who have employee timesheets pending approval.

Now that we have some basic business requirements, we can proceed with our software development process.

Software Development Methodology

Every project, small or large, should have some basic structure or process (methodology) it must follow. This could be a simple one-page checklist or a slightly more formal process. Having no process at all is bad, but too much is equally bad. Finding the right balance depends on the customer's needs and the project size, but in summary, I lean toward having less process with minimal (and "good enough") documentation requirements, rather than having a bloated process that can bog down the customer and developers in paperwork and procedures. In this chapter, I'll provide a basic software development process based on XP and AMDD.

Overview of XP and AMDD

XP and AMDD provide some fundamental guidelines for building software applications effectively and rapidly. XP and AMDD are complementary methods because XP provides a disciplined, full life cycle software development approach that stresses customer satisfaction. AMDD, on the other hand, generally provides effective practices for modeling and documentation, but goes a lot further by providing a wealth of additional best practices that can be tailored to each software development project.
 

The Exploration Phase (Beck, 2000) typically involves a combination of exploratory activities that help you better understand the customer's needs and subsequently how the resulting application will be designed and built. The following are some examples of activities that might take place in this phase of the project.

• Domain model A domain model helps to define major business concepts (entities) and the relationships among them.

• User interface prototypes and storyboard These are initial screen mockups to get a feel for how the customer visualizes the application. The storyboard is the flow of the screens.

• User stories A few user stories get the project started and make up the first release or version of the application. User stories (similar to shall statements in other methods) are written by the customer in a brief sentence or two explaining what the customer wants the application to do. Note that the number of user stories you gather up front will depend on the project, but you should have enough to make a good and useful release.

• Scope definition It is important to define the scope of the project up front so that you know what needs to be developed and what can be deferred. It also clarifies the customer's expectations.

• Analysis : This can include a combination of whiteboarding, an informal architectural diagram, a glossary, and more.

Planning Phase
 

Planning can mean different things to different people. For me, it should at least include the following:

• Release plan This is essentially a plan for the next release (version) of a system and can easily be put together using a spreadsheet program or even a word processing program and/or HTML table. It lists all the user stories that will be included in the next release of the system, grouped together in several iterations. Releases are typically of fixed length, anywhere between one to three months; two months is typically an optimal size.

• Iteration plan An iteration plan is developed prior to each iteration. It includes the user stories the customer wants implemented in the next iteration. Iterations are typically of fixed length, anywhere between one to three weeks; two weeks is typically an optimal size.

• Define standards (code, database, process) Before beginning any development, it is a good idea to standardize such things as coding conventions, database naming conventions, processes (build, integrate, deploy), and more.

Iterations to Release Phase (Building Software in Increments)

Iterative development is a term you are probably familiar with. However, understanding of iterative development and what each iteration should include varies from person to person and from methodology to methodology.

For me, iterative development means that each iteration includes design, coding, user acceptance, and deployment of "production ready" code. This code can be deployed to the production environment or, if you are in a large corporation and deploying to production frequently is not practical, perhaps deploying to the acceptance environment will do, so long as it is accepted by the customer, thus allowing you to move on to the next iteration. To summarize, each iteration might include the following activities:

• Development tasks, estimates by developers, and a plan for the next iteration.

• Ad hoc Q & A between developers and the customer.

• Design CRC cards, UML diagrams, and so on.

• Code test first, refactor code/database/architecture as required, optimize later.

• User acceptance testing (UAT).

• Deploy iteration to production (or UAT); this step is also referred to as a small release.

By delivering iterations in this fashion, you can incrementally build the next release of an application. For example, we might estimate three months for a given project and break it down into two-week iterations, resulting in approximately six iterations.

The bottom line at the end of each iteration is that the project should be deliverable; in other words, the small releases should contain production-ready (stable) code, even it provides only a subset of the complete system.

Scope of Project

The scope of project can be defined in many formats. Sometimes it is as simple as a oneto two-line paragraph described by the customer, or it can be more structured using diagrams. Many organizations go one step further and sign service level agreements (SLAs) with the development team. Also, functional and nonfunctional requirements discussions can also occur to help define the scope.

In the past, I have used a table to show what is included in the scope and what is deferred (or excluded) from scope, as demonstrated in Table 2.1, a sample scope table for Time Expression.

 

Maintenance

This is where the application enters a maintenance state. This phase might include training for the user, minor enhancements/fixes (in the form of user stories), as needed. Or the customer might want to do another major release, in which case you would start back from the Exploration Phase mentioned earlier in this chapter.

Applying XP and AMDD to Our Sample Application

Now that we have looked at some background on a generic software development process, let's apply parts of this to our sample application.

Domain Model

Let's start our domain model, which essentially has all the data entities and their relationships, but no attributes. This helps to define some initial domain concepts and their relationships to each other. The domain model is typically sketched while working with domain experts and people with business knowledge, such as business users and analysts.

Figure 2.2 shows the domain model for our application, Time Expression. As you can see, our domain model has a simple design because it contains the bare-minimum number of entities to get us going while following a clean design. Again, we just need a simple domain model to start with, something good enough for us to move forward with, which we have now.

User Interface (UI) Prototype

Now that we have a fairly good idea of the features our customer is looking for in Time Expression, we can rapidly mock up some prototype screens to allow the customer to test drive the mocked web application.

By developing prototype screens early on, you put a face to the application, which gets people excited and motivated to get the application built. This is also a good way to eliminate many of the cosmetic changes up front (such as fonts, colors) and come up with an agreed upon consistent look and feel that can be implemented using cascading style sheets (CSS). Furthermore, you can use prototypes to model the business process and subsequently use the same prototypes to define the users' stories (covered later in this chapter).

Figures 2.3 through 2.10 show what the various screens in the Time Expression application will look like. We will begin designing this application in the next chapter; then, in subsequent chapters, we will get our environment set up and begin developing some code!

At this point, let's keep these screens as simple HTML (versus JSP) files so that we can pull them up locally in a browser instead of having to run them in a Java web server or pull them up in a JSP/HTML editor each time. When working with a customer, it is a good idea to keep technology out of the picture, as much as possible, until you are ready for developmentthis keeps things simple, so you can avoid any "technical difficulties" and instead focus on the business requirements at hand.

User Stories

Given the business requirements and UI prototypes defined for Time Expression earlier in this chapter, we can now define a set of user stories for our application. As explained earlier in this book, I decided to use XP/AMDD; therefore, you see the use of the term user story versus use case. Although these serve similar purposes, user stories tend to be shorter than use casesfor example, one to three sentences each. The remaining details can be discussed between the developer and the customer when the developer begins working on a given user story in the planned iteration; hence, the term active stakeholder participation.

Use cases come in many formats themselves. The three I'm familiar with are formal, brief, and casual. The casual format is probably closest to a user story because it is short and informal. Formal use cases can entail a page or two of requirements with preconditions, postconditions, success/basic path, failure/alternative path, and other sections for each use case. The reason I have described use case and their formats here is because certain organizations define essential use cases (or even business requirements with "shall" statements) first, and then later break each use case down into one or more (maybe even several) user stories using our guideline of one- to three-day development per user story or development task.

We will use user stories in this book to not only define the requirements, but also to name our Java classes, using the story name/tag, and create acceptance tests. Table 2.2 shows the user stories with the priority and initial estimate to complete. Note that the user stories you might find in the real world might be a bit more detailed than what I have shown in Table 2.2; however, given the simplicity of Time Expression, these work fine for us.

Incidentally, a good book to check out on user stories is Mike Cohn's User Stories Applied: For Agile Software Development (Addison-Wesley Signature Series, 2004).

The estimates shown in Table 2.2 are initial estimates, or sizing. The developer provides more accurate estimates at the beginning of the iteration when the user story will be developed, because the user story can be broken down into development tasks to better size the time required to complete the entire user story. Incidentally, I have come across real-world projects where they did not do the breaking down of user stories into tasks, nor did they size the user stories during iteration planning. The reason for this was because sometimes the user story priorities changed or the user story itself changed, so the upfront work was for nothing. Instead, they picked two to three stories on day one of a new iteration and only estimated those.

Points (last column of Table 2.2) are some unit of measure relative to the given project. For example, 1 point could equal 1 regular workday, 1 ideal workday, 1 week or another periodwhatever the customer and developers agree on. Whatever each point might measure is then used to provide estimates to the customer.

Ideal (development) days are a good way to estimate projects because it factors in planned and unplanned events (for example, meetings, computer problems, sick leave, and so on). The difference between a regular day and an ideal day is referred to as the load factor.

A load factor, typically between 2 and 4, is a number you multiply your initial estimate by to come up with an ideal day. For example, I like to use a load factor of 3 for projects where I have a good understanding of the business requirements and technologies. (Note: If you believe there are risks involved, such as a learning curve related to a new technology, you can use a higher number, such as 4 or even 5.) For example, if we know a development task will take me approximately 8 hours of uninterrupted, totally focused, heads-down time, we can multiply that by 3 (that is, 8 * 3) and come up with 24 ideal hours or 3 ideal days (assuming a 8-hour work day).

In this book, we will develop the Enter Hours and Timesheet List (items 1 and 2 in Table 2.2; both with priority 1). So, if we use these two screens as example, it would take 9 actual days to complete these screens (that is, 3 ideal days times the load factor of 3).

Release (and Iteration) Plan

After the customer (end user and/or business analyst) has defined the user stories, the customer and development project manager (and/or developer) can put together a release plan for the next release or version of the application.

A release plan is essentially a project plan listing various system releases and the dates for each release. In this book, we will assume that we have only one releasefor example, v1.0.

Releases are typically small, about 1 to 3 months in length. Each release consists of a set of user stories the customer wants implemented in that release. Each release is then further broken down into iterations.

Iterations range between 1 to 3 weeks in length. Each iteration contains a list of user stories chosen from the set of user stories for the given release that the customer wants implemented in that iteration (along with defect fixes from previously failed acceptance tests).

Based on the user stories we defined earlier in this chapter, we can come up with an initial release plan, shown in Table 2.3, to incrementally build release v1.0 of our application.

Our release plan does not use priority 5 user stories because these will be pushed off to release 2 of our application. Of course, this is all fictional and many of the examples we have looked at so far, such as the iteration and release plans, are for demonstration purposes only. In the real world, you are bound to see more detailed plans.

After the release plan containing the various iterations is defined for the next release of the software, the developer can begin working on the first iteration.

Prior to each iteration, the customer and development staff get together for an iteration-planning meeting, the outcome of which is an iteration plan for the next iteration. The customer picks the user stories that will be developed in the next iteration. The developers break down each user story into individual development tasks required to implement the user story. This is done so that each development task can be assigned to a developer, but more importantly, the tasks can be used to more accurately estimate the total development effort for the given user story and, in turn, the next iteration.

If the total estimate or points (to implement all chosen user stories for the next iteration) exceeds the total points implemented in the previous iteration (known as the Project Velocity in Extreme Programming), the customer must choose which user stories (or defect fixes) to defer to a future iteration or release. If the opposite is truethat is, there is room to get more done in the next iteration, the customer may add additional user stories, defect fixes, or enhancements, if needed.

For our purposes in this book, I have skipped including a sample iteration plan because this book is more about development than process. Also, formats of an iteration (and release) plan can vary, so instead I chose to leverage the release plan (see Table 2.3) and group our user stories by priority in it instead of breaking them down individually in each iteration plan.

Glossary

This is probably a good time for us to define a glossary for Time Expression.

A glossary is essentially a set of common terms, or project vocabulary, that everyone agrees on for the project. This list can include business terms (for example, Timesheet and Approved) or technical terms (for example, Entity, used while discussing the logical data model). The obvious benefit of a glossary is that it gets everyone in agreement with the terminology and definitions of each term to avoid any confusion. (We have enough of that already given the terminology/acronym madness that exists in our industry.)

• Accounting The accounting department/staff.

• Approved Status of a timesheet when a Manager approves a previously submitted timesheet.

• Employee A person who works on an hourly basis and reports to a manager.

• Executive An officer of the company, such as CEO, CFO, or COO.

• Hour A full hour of billable work that can be entered into a timesheet and the employee can get paid for.

• Manager Direct supervisor of an employee.

• Paid Status of a timesheet when the accounting department has issued a check.

• Period Ending Date This is the last day of each week (Sunday, in our case).

• Pending Status of a timesheet until the user submits it.

• Submitted Status of a timesheet when an employee has submitted a timesheet. Timesheet is "locked" from further changes by employee.

• Week A 40-hour workweek from Monday through Friday.

Whiteboard Architecture

By now, we have enough information to put together an informal architecture diagram. Figure 2.12 shows a high-level architecture diagram for Time Expression (on an indispensable tool of the trade, the whiteboard). By establishing this diagram, the developers and customer can agree on major technologies (for example, Java, database, web/app server) that will be used to build Time Expression.

We will use an electronic and more detailed version of this architecture diagram in the next chapter to help us go one level deeper into the design of the applications. Converting whiteboard diagrams or CRC cards to electronic formats are my personal preference because legibility isn't a real concern with electronic artifacts. However, you could simply digitize artifacts such as whiteboard drawings and CRC cards via tools such as a digital camera and scanner, respectively.

Although I have some fundamental practices I use on all projects, I typically pick and choose what applies to each project and customize the software development process based on the needs of that project and customer. For example, in our sample project/application in this book, Time Expression, I have used several of the techniques described next and shown in Figure 2.1 (refer to agilemodeling.com/essays/agileModelingXPLifecycle.htm for details). Note that although I have adopted the XP and AMDD way, there might be a few spots where I customize these methods (Project kick-off, for example) to accommodate what we need for Time Expression.