Daily Archives: December 17, 2010

Open Source Website Development – Benefits of Open Source Development

 

There are several advantages of using open website source software.

Lower Hardware Cost
Proprietary system has their own requirements of hardware and that is expensive. You need their own servers to run a website whilst in case of open source you can use other open source operating system etc. which conversely demand low cost hardware for instance Linux and open source solutions are easily portable and compressed, it takes lesser hardware power to carry out the same tasks when compared to the hardware power it takes on servers, such as, Solaris, Windows or workstations. You can use cheaper or older hardware power and still get same results with open source development.

High Quality
Open web source software are not low quality software they have their own standards and they maintain very well. Most of the open web source software are well designed and also efficiently used for coding. This way they are ideal choice for the organization. When you use open website source code is available that allow high degree of customization.

No Vendor Lock-in
Every IT manager has experience when they dealing with the vendor lock-in software. Their frustration is well known. In case of open website source you never face such embracing situation. There are other disadvantages with proprietary software and that are lack of portability, expensive license fees, inability to customize software, etc. Open source gives you freedom to address these all disadvantages.

Better Management
With open web source you can get benefits of integrated management. Open source software uses technologies, such as, common information model (CIM) and web based enterprise management (WBEM). These technologies enable you to integrate and combine server, application, service and workstation management. This integration would result in efficient administration.

Simple License
Open web source enables you to install license several times. You can use it from any location and it will be free from any tracking, monitoring or counting license compliance. You are free from the all tensions.

Big Community
There are big communities behind the open website source software. They are ready to serve you in different needs and problems. Their support is freely available. Most organization that creates open web source software solutions also provides maintenance and support.

Source: www.ezinearticles.com/?Open-Source-Website-Development—Benefits-of-Open-Source-Development&id=5374402

Beginning Web Development for Smartphones – Developing Web Applications With PHP, MySQL and JQTouch

 

Creating a Client-Side Database and Tables

In this example, we’ll be using a JavaScript database API for creating the client-side database. This API provides a simple method of storing, retrieving, and marinating user-supplied information. In addition, it provides a relational database model, and so can easily handle complex data. We can use standard SQL statements to perform all database-related tasks, such as creating databases and tables, as well as inserting, fetching, deleting, and updating rows in the tables.

Let’s start off by creating and opening a database. The code for creating and opening the client-side database is shown below:

var datab;
var shortName = ‘tmpCart’;
var version = ’1.0′;
var displayName = ‘tmpCart’;
var maxSize = 200000;
datab = openDatabase(shortName, version, displayName, maxSize);

The usage of the variables used in the code fragment is shown Table 1.

Table 1. Client-Side Database Variables

Variable
Usage

datab
Used to hold the reference to the database connection when it is established.

shortName
Stores the name of the database we will be creating on the client side.

version
Stores the version number assigned to the database. The version number is often needed for upgrades or changes to the database.

displayName
Stores the database name available to the user.

maxSize
Stores the expected size of our database in kilobytes. Should the size exceed the limit in this variable, we will be notified and asked if the increase should be allowed or denied.

The variable values defined in our code fragment say that we want to create a client-side database named tmpCart with a version number of 1.0 and a size limit of 200000 KB. After assigning these variable values. We can pass them to the openDatabase command, which actually creates the tmpCart database and stores the connection in databvariable.

The code fragment can also be written as:

datab = openDatabase(‘tmpCart’, ’1.0′, ‘tmpCart’, 200000);

That is, we can directly specify the parameter values in the openDatabase function without using variables at all.

Now that we’ve created and opened a server-side database, let’s create a table in it.

Creating Client-Side Tables

In this example, we’ll be using the client-side database for storing cart information. Let’s first create a table called shopcart in our client-side database tmpCart, as shown in this code fragment:

datab.transaction(
function(transaction) {
transaction.executeSql(
‘CREATE TABLE IF NOT EXISTS shopcart ‘ +
‘ (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, ‘ +
‘ cart_sess varchar(50), cart_isbn varchar(30), cart_item_name
varchar(100), cart_qty integer, cart_price float );’
);
}
);

The JavaScript database API supports SQL transactions and all database queries must take place in the context of a transaction. To execute a standard SQL query, we need to call the executeSql method of the transaction object. To do this, we call the transaction method of the datab object and pass it a anonymous function. We then pass the transaction to the anonymous function so that we can call executeSql method of the transaction object.
The executeSql method creates a table called shopcart if it doesn’t already exidst. The table has four fields: id, cart_sess, cart_ISBN, cart_item_name, cart_qty and cart_price. Theidfield is the primary key. It’s value cannot be null and is unique for each row of the table. We set this field to AUTOINCREMENT, so its value will increase by 1 for each table row added.

Inserting Rows in Client-Side Tables
Let’s assume that a user has dropped a book in the cart, so we now have some cart data to process-session id, ISBN, title, quantity, and price. This data is stored in the variablessid, ISBN, title, qty, and price respectively. We’ll transfer this data to a row in the client-side shopcart table, as shown in the following code fragment.
datab.transaction(
function(transaction) {
transaction.executeSql(
‘INSERT INTO shopcart (cart_sess, cart_isbn, cart_item_name, cart_qty,
cart_price) VALUES (?,?,?,?,?);’,
[sid, isbn, title, qty, price],
function(){
},
displayerrormessage
);
}
);

Note: Session id is used for session management-a mechanism used for tracking users visiting our web application. The Server generates a unique id for the current session.

First we use the executeSql method of the transaction object to execute a SQL query. We need to pass the data for five fields, or columns, to this method. The five question marks (?) in the VALUES parentheses are placeholders and take on the values in the array [sid, ISBN, title, qty, price]. The first question mark is replaced by the value in the sid variable, the second question mark is replaced by the ISBN value, and so on.

The array of values is followed by an anonymous function called the data callback function, which may contain statements to execute after successful execution of the SQL statement. For example, data callback may contain calls to other functions that display a confirmation message or navigate to an other panel. If we don’t want any action to take place after the successful execution of the SQL statement, we can leave this function empty, as we have actually done in the code fragment.

The last part of the fragment, displayerrormessage, is a call to the error handling function we want to evoke if the SQL statement fails. Here is an example of displayerrormessageusage:

function displayerrormessage(transaction, error) {
alert(‘Error: ‘+error.message+’ has occurred with Code: ‘+error.code);
return true;
}

Two parameters are passed to the displayerrormessagefunction: the transaction object and the error object. The errorobject displays the error message and the error code. The reason for passing transaction object to the displayerrormessage function is to allow more SQL statements to be executed from within the function, if desired. Thedisplayerrormessage function may return true to halt the execution and roll back the entire transaction, or false, in which case the transaction will continue.

Error Codes
Table2 contains a quick look at the common error codes generated while executing a transaction on client-side database tables.
Table 2 Error Codes and Occurrence

Error Code
Occurs When

0
The transaction failed for other non-database-related error.

1
The transaction failed for other database-related error.

2
The transaction failed because the version of the database didn’t match the one user requested.

3
The transaction failed because the data returned from the database was too large.

4
The transaction failed because either there was not enough storage space left or the user didn’t wanted the database to grow beyond the existing limit.

5
The transaction failed because the transaction included a syntax error, number of parameters mismatch, statement modifying the database in a read-only transaction, and so on.

6
The transaction failed because of constraint failure, for example, assigning two rows the same value in the primary field.

If we aren’t interested in capturing errors, we can omit both data callback and error handling callback functions. If we do that, the code fragment will appear as follows:

datab.transaction(
function(transaction) {
transaction.executeSql(
‘INSERT INTO shopcart (cart_sess, cart_isbn, cart_item_name, cart_qty,
cart_price) VALUES (?,?,?,?,?);’,
[sid, isbn, title, qty, price]
);
}
);

Source: www.ezinearticles.com/?Beginning-Web-Development-for-Smartphones—Developing-Web-Applications-With-PHP,-MySQL-and-JQTouch-&id=5089565

Seven Tips For Negotiating Your Website Development Contract

 

For many entrepreneurs the first major agreement you will execute will be the contract with your web site developer. Your company’s website is its portal to the world. The professionalism and creativity of your site will influence the way the world regards your product, your company, and you. Because your website will be such a principal branding tool, many entrepreneurs decide to utilize the services of a professional developer to assist them with its vision, creation and maintenance. Entrepreneurs running their own music label, film production, or television production companies face this issue more often, as they typically design separate websites for each album, feature film, or television show under their company’s banner. Because of the importance and prevalence of website development, this article will explore several key aspects of the development contract and provide some useful tips concerning their various provisions.

Tip One:

Every entrepreneur should control his company’s website (or websites). This includes all screens, graphics, domain names, content, formatting, underlying software, source code, object code, etc. Your site should be dynamic, with the ability to adjust to the trends in your target audience. You need the ability to alter the content, structure, and design of your site to conform with these trends or your visitors may stop coming. Your contract should clearly state that the developer is providing you with a "work for hire" as defined by the Copyright Act and the rights in and to the website are held by you. Without this language (and other provisions such as the developer’s agreement to assign any rights he may have in the website to you, if necessary) you could find your developer or another third party with rights in your company’s site. This could effect your ability to modify or update the site, or to keep the site active.

Tip Two:

Regardless of Tip One, often developers will utilize programming that they own, having developed it independently, prior to working on your site. The language suggested above may give you ownership of this code, once it is embedded in your site. Your developer will probably be unwilling to allow you to assume ownership or control of this code, which would probably be an unfair result. They would no longer be able to use the programming on future sites and it would cause issues for their previous customers, whose websites may contain this code. However, you don’t necessarily want them to develop your site from scratch. The use of this pre-programmed code could save you time (and money) in the development process. One solution to this problem is for you to acknowledge that any pre-programmed code will still be owned to the developer, but for you to obtain a license for the developer’s code broad enough to cover the current and future uses of your website. For instance, you may bargain for a "perpetual, irrevocable, worldwide, royalty free, and transferable" license to any pre-programmed code that the developer incorporates into your site. You should then be able to exert certain rights regarding this pre-programmed code, albeit solely with respect to your website. This gives you the right to make any revisions to your website that you wish, without worrying about developer’s ownership of the underlying code.

Tip Three:

If you want to use third party content (such as text, video or audio) on your site, don’t assume that the developer will obtain the licenses or clearances you need. In fact, many developers will not perform this service and the responsibility will be yours. Incorporating content that belongs to others on your site may be an infringement of the owner’s intellectual property rights. This can expose you to liability and result in your having to deactivate the site, at least until the infringing items can be replaced. Furthermore, do no assume that any content the developer provides will be non-infringing. Ask the developer to confirm his sources of content and give you a warranty that he can convey to you the rights you need to post the content online. The developer should hold you harmless if he provides you with material that infringes on another’s rights. This includes liability you may face due to violations of privacy and publicity rights, anti-defamation laws, anti-obscenity laws, anti-discrimination laws and other related causes of action. Of course, any "hold harmless" provision (also known as an "indemnity") is only as sound as the company that gives it, so do your best to double check the developer’s content yourself.

Tip Four:

You may be coordinating several events based on the anticipated launch of your website, such as your company’s opening, commencement of a major promotional campaign or the release of your artist’s album. Be sure to build in extra time to account for delays and adjustments to the site. Moreover, you want to motivate your developer to work efficiently on your site. You want your payment obligations to be triggered by the accomplishment of milestones, and you want to space out your payments, increasing them as the project nears completion. In addition to the mutually agreed upon project timetable and payment schedule, you might want to negotiate bonuses for early completion of project milestones and penalties for late deliverables. If you have room in your budget, this can keep your project on an accelerated time schedule.

Tip Five:

It’s the customer’s prerogative to change his mind. Make sure your contract has a mechanism that allows you to deviate from the specifications agreed upon before the project began. At that point, everything was conceptual. It is reasonable to expect that some of the ideas won’t satisfy you when you see them in front of you. It is also reasonable to expect that the concept in your head may be slightly different from what the developer envisioned when it was discussed. You should have a procedure for change orders that clearly delineates any extra costs and time that will be necessary to effectuate your new direction, before you authorize the developer to make the changes. Of course, you should also have a project management timeline that allows you to see samples, exemplars, and mockups as early as possible in the process, so you can modify your vision before much time and resources are invested.

Tip Six:

You do not want to have to rely on the developer to maintain the software associated with the site, or to make simple changes, post additional content or to do any of the tasks that you or your team can be trained to handle. Using the developer for simple tasks can become expensive and create undue delays. If your resources allow, negotiate with the developer to insure that certain key employees are trained in the basic functioning of the site. Make sure that your team can make the changes you will need to make on a regular basis. If this is not possible, try to negotiate a small retainer agreement with the developer, perhaps payable on a monthly basis, so that you can contact him often to maintain the site or make changes within a fixed cost. This may not alleviate undue delays, but if you want to update your site on a regularly scheduled basis, it may be possible to work out a fixed schedule with your developer. If nothing else, you should be trained in how to access, record and compile information about the website’s visitors and/or customers. Furthermore, make sure he delivers you the source code, so you can hire someone else to fix or maintain the site, should that be necessary.

Tip Seven:

When problems such as bugs and failed links occur, and they usually do, it should state clearly in your contract that the developer has a responsibility to correct them, including the timeframe for such corrections. When the site is done, it should perform exactly as outlined in the system specifications agreed upon before commencement of work. The developer should provide a warranty that the software for your site is free from viruses, disabling devices or "back-doors" and remove them and indemnify you should you discover any. Many developers will provide a limited warranty on their work for a specified time, so you can have some comfort that the site can be fixed without cost if it crashes from viruses, bugs, heavy traffic or other reasons after launch.

Odds and Ends:

Of course, there are a myriad of other issues to be concerned about that we do not have the space to cover in detail in this article. For instance, your developer may become privy to your confidential information or trade secrets, and you should want a provision regarding confidentiality. As the point of the website is to get your company’s brand into the marketplace, you may want to make sure your developer is knowledgeable about search engine optimization (SEO), which, if implemented properly, will drive traffic to your site. In the case of a dispute, you may want to arbitrate instead of going to court, as this is usually a less expensive and faster way to resolve conflicts. Lastly, you should want the contract to be unassignable by the developer, so that the person you hire is the person who works on your website. These examples are not exhaustive, and there are other provisions and clauses in website development agreements that are important. If your resources allow, you should seriously consider retaining an attorney to help you draft and negotiate this critical contract.

Furthermore, if your resources allow, you should seriously consider utilizing the skills of a lawyer to draft your website’s Privacy Policy and Terms of Use. These documents govern your company’s rights, responsibilities and obligations pertaining to the general public’s interactions with your website. Be very careful if you decide to use an "off the shelf" privacy policy and terms of use supplied by your developer. If your company’s actual policies and procedures are incongruent with the provisions of your Privacy Policy and Terms of Use, you could face lawsuits, governmental intervention, and a reduction in visitors and goodwill.

Source: www.ezinearticles.com/?Seven-Tips-For-Negotiating-Your-Website-Development-Contract&id=4653956

Web Development Basics: Understanding SEO and Its Importance

 

You can help to improve the ranking of your website in the search engines by using SEO, which stands for search engine optimization. The benefit of having a higher ranking with the top search engines is attracting a lot more targeted traffic to your website. SEO is an essential ingredient in building the popularity, traffic and overall sales of your website. There are two main types of search engine optimization, including on-page SEO and off-page SEO.

* Understanding On-page SEO
Relevant optimization of keywords in your website title, tags and content as well as other aspects of your website is what is known as on-page SEO. One of the most important tasks that must be done in on-page SEO is to optimize the website for relevant keywords. You should try to have a keyword density of at least 3%, yet no more than 6%, as anything under 3% probably will not get picked up by the search engines and more than 6% density will likely be seen as spam, getting your site penalized or blocked by the top engines. Keywords should also be included in your website title as well, placing keywords near the beginning of the title for best results, particularly if your website has a very long title. If possible, have your keywords or company name in your domain name as a way to increase traffic by optimizing the value of your website.

* Understanding Off-page SEO
Your options and opportunities for optimizing your website through the use of off-page SEO techniques are limitless. On-page SEO techniques are fairly limited to just a couple of specific tasks, however off-page SEO, which can help you to build relevant, quality backlinks to your website, has absolutely no limits.

* Blogging

* Niche Forums

* Online Ads

* PPC or Pay Per Click Advertising

* Social Networking

* Article Marketing

While it is in your best interest to utilize each and every one of these methods to build up the amount of quality backlinks to your website, you also need to be ready to commit to being consistent, which can be a lot to handle if you try to do too much, too soon. Consistency and variety of resources is key, particularly for the big engines like Google, which give better results to sites that submit one or two articles, blogs, posts or pages each day, rather than dumping them all in at once. Your start-up goal should be to submit at least one article to a top article directory each day and make one blog post each day. Once it becomes easy for you to meet your daily goal, start laying in a single forum post each day and then brush up on your various campaigns for PPC.

You need to set yourself a goal for how many backlinks you want to create in a day and stick with it – that’s the best way to consistently increase the number of off-page SEO campaigns you can successfully master. Your best bet is to commit to a daily, steady stream of quality, relevant content and if you can stick with it, you will be rewarded. Find a pace you can stick with and commit to either daily or weekly submissions for at least 3-6 months before trying something new. You will see a big difference not only in the quantity of traffic that visits your website, but the quality of it as well, if you work to improve and increase both your off-page and on-page SEO.

Source: www.ezinearticles.com/?Web-Development-Basics:-Understanding-SEO-and-Its-Importance&id=5500507