Showing posts with label HTML. Show all posts
Showing posts with label HTML. Show all posts

Saturday, June 16, 2012

Everything you need to know about HTML 5 and its impact on SEO

HTML5

HTML goes back a long way. It was first published as an Internet draft in 1993. The ’90s the HTML version 2.0, versions 3.2, and 4.0 (in the same year!), and finally, in 1999, version 4.01 were released.Since then the focus of web standards shifted to XML and XHTML, and HTML was put on the back burner. But looks like HTML was quite stubborn and thus refused to die, it saw its rebirth as HTML 5. It was a result of work of a few people who started the Web Hypertext Application Working Group (WHATWG) in 2004 and created the HTML5 specification. W3C published the first working draft for HTML5 in 2008. While HTML5 is still under development it is quite essential to understand its basics to get the most out if it.

HTML gives search engines the needed context they need to understand what’s contained in a web page. A search Engine won’t look at how beautiful your site looks, it won’t make a difference to the crawlers whether it’s having all the glitter and sparks or not, though it may affect your visitors. To understand the way a Search Engine Crawler works you may Download Lynx a web browser that displays only text and attributes, you may be able to view your website from the eyes of a Search Engine.

So What’s New in HTML 5?


Well if you look at the HTML5 websites and applications you may feel that it is more of a programming language, but the truth is that it’s the same old HTML with some new markup tags and attributes, which make web designing easier than ever before. It’s backward compatible with HTML4 and thus you need not learn it from scratch. The new semantic tags, web page segmentation, the new link types, improved Media Handling with and tags are just a few important new features that we will discuss in this article, that are sure to affect your SEO strategies.

And what are the features that affect My SEO and How?

HTML5 is based on various design principles,

  • Compatibility

  • Utility

  • Interoperability

  • Universal access


With these four principles around HTML5 has made sure that it is coded in an intelligent way to move a step closer towards semantic web.

Well anyone who has been in the game of SEO will be surely aware of its basic pillars:

  • Search Engine crawlers indexing your pages in their databases

  • Speed , faster loading WebPages are ranked high

  • Quality (not quantity) of links, pingbacks.


HTML5 promises to deliver all of it to you, but in a bit more intelligent yet simple way.

Web Page Segmentation for enhanced Search Engine Indexing


Remember HTML5 is all about evolution and not more of a revolution. Thus it has introduced simple yet effective way to arrange our code so as to make it more semantic and express it better.  For example, Google when analyzed, found out that many a people were using common ID names for DIV tags ,like DIV id=”header” to mark up header content. The problem here is that DIV tags don’t add semantic value or give context to what’s inside it.

Here comes the evolution with HTML5, with the new elements such as,< header>, <article>, <aside> and <footer>, the segmentation of the web page becomes more meaningful. Once HTML5 becomes widely accepted search engines will surely look for these tags for better understanding.

html5_page_structure

Presentation and Content


Although Content is often considered as the King in a Blog or website, nowadays it’s the way of presentation (read: SEO) that matters a lot. With the new Tags to separate various sections of your page HTML5 gives you a way to affect your SEO. Those of you who have designed websites in the past must have tried to divide your pages into various sections like Headers, footers navigation, sidebars etc. for better classification so as to make it easier to understand which part contains what information, the same is now very smoothly done with the help of HTML5 tags like <header>, <article>, <aside> and <footer>, etc.

html5

<article>

Article tag is just the perfect way to define the main contents of your page. With so many different information on the same page, the <article> tag offers you to indicate the content of a web page, blog post, comment, article . It would help directing the search engines to pay more emphasis to the article (i.e. the main content) via this tag. For further reading read http://dev.w3.org/html5/spec/Overview.html#the-article-element

<section>

The new <section> tag can be used to identify separate sections on a page. A<section> tag can be used to group content together and may contain further<section> tags to create the subsections. This is quite similar to sections and subsections that we see in a book. This allows
each section to have its own heading, giving search engines a clear hint of what the content in the section is all about. Thus search engines can get a better understanding of how the web page is segmented and structured.




<header>

header element is used to set the header section of a document and represents a group of introductory or navigational aids. Often they contain the standard h1 to h6 heading elements, i.e. the hgroup elements though not necessary always. Header should not be confused with hgroup elements (standard h1 to h6 heading elements) actually headers may contain may contain all sorts of content, from the company logo to the search box. So now instead of using <div id=”header”> for header section you can directly use <header>,as it offers better semantics.

<footer>

Traditionally footers of two types, 1st those of text type, which basically carry a copyright info, email, and the second one is the Web2.0 Footers with larger area and which carry Categories , links and content in them. In a Web page footer is located at the bottom and usually contains the copyright information, links to pages etc. etc. about the page, although, it isn’t necessary to be that way. A Footer element represents the footer content of its nearest sectioning element.

Footers have been described as the most abused part of a website which is often given the least care. Thus while search engines might not pay much interest to them as header, they do have their own role in SEO. For example a good footer with adequate links extremely helpful to search engines, especially if your navigation appears as graphic elements. At the same time, it’s helpful to users, who can navigate to another section without scrolling back to the top.

The <header> and <footer> tags can be used many times on one page, thus providing a very flexible layout.

<nav>

The purpose of this element is to summarize a group of links that serves as a collection of offsite links, document or site navigation. It’s a common practice by many developers to use <ul> and <li> tags for navigation and then style these elements as menu items. But this practice often leads to confusion between a list that has links in it and a list that is simply navigation. However you can also use<ul> and <li> tags with <nav> .

<aside>

It is used for related content or pull quotes. It usually contains the content which could be considered separate from that content. Such sections are often represented as sidebars

All these elements and sectioning elements can be styled with CSS. They may not have an effect on Search engine ranking now but in future search engines will definitely be taking advantage of these elements as they crawl and index pages.

Different Link Types for improved links


Other Major improvements are Link Types. Anyone with even the most basic knowledge of SEO is aware of the importance of hyperlinks in and out of a web page. It is not a hidden fact that search engines study links in a web page to see what web pages it points to as well as to see what web pages point to it, and many bookmarking sites have grown along this concept of linking. HTML5 gives a better way of managing these links with new Link Types. It helps the crawlers know that what type of hyperlink the link actually is. Attribute values likerel=”author” and rel=”license” essentially allow us to describe our links better.

A full list of link types can be found over here.

A Plugin Free Environment for enhanced Webpage speed


HTML5 provides native support for many features that used to be possible only with plugins. Very often plugins present problems like them being not installed, disabled, blocked and more over they are difficult to integrate with the rest of an HTML. This is where HTML5 introduces its native functionality. The native elements such as and can mean increased interoperability with search engines. Thus search Engines will easily index our audio and video content as well. Various websites are already gearing up to adopt HTML5.

For example to insert video, use a <video> tag and set its src attribute to URL containing a movie. You can also display playback controls by including thecontrols attribute, thus removing the need of a flash player. However using this codec can also put you in trouble if the user is using a browser that doesn’t support <video> tag or the media codec is not supported.

I want to know more about HTML5


Well after reading this post if you wish to learn more about HTML5 we have a few recommended sources that may help you learn more about this wonderful technology:

If you found this post interesting consider leaving a piece of comment.

Monday, June 11, 2012

Symbol Caddy


The Symbol Caddy Dashboard widget keeps a bunch of common special characters at your fingertips. Keyboard mode copies the special character and HTML mode copies the HTML entity code. Mac OS X 10.5.0 or higher is required. CharacterPal does the same and is also freeware.

Symbol Caddy Dashboard widget

Tuesday, May 29, 2012

J2EE Tutorial-5 (Development Roles)

Reusable modules make it possible to divide the application development and deployment process into distinct roles so that different people or companies can perform different parts of the process.

The first two roles involve purchasing and installing the J2EE product and tools. Once software is purchased and installed, J2EE components can be developed by application component providers, assembled by application assemblers, and deployed by application deployers. In a large organization, each of these roles might be executed by different individuals or teams. This division of labor works because each of the earlier roles outputs a portable file that is the input for a subsequent role. For example, in the application component development phase, an enterprise bean software developer delivers EJB JAR files. In the application assembly role, another developer combines these EJB JAR files into a J2EE application and saves it in an EAR file. In the application deployment role, a system administrator at the customer site uses the EAR file to install the J2EE application into a J2EE server.

The different roles are not always executed by different people. If you work for a small company, for example, or if you are prototyping a sample application, you might perform the tasks in every phase.

J2EE Product Provider


The J2EE product provider is the company that designs and makes available for purchase the J2EE platform, APIs, and other features defined in the J2EE specification. Product providers are typically operating system, database system, application server, or Web server vendors who implement the J2EE platform according to the Java 2 Platform, Enterprise Edition Specification.

Tool Provider


The tool provider is the company or person who creates development, assembly, and packaging tools used by component providers, assemblers, and deployers. See the section Tools for information on the tools available with J2EE SDK version 1.3.

Application Component Provider


The application component provider is the company or person who creates Web components, enterprise beans, applets, or application clients for use in J2EE applications.

Enterprise Bean Developer


An enterprise bean developer performs the following tasks to deliver an EJB JAR file that contains the enterprise bean:

  • Writes and compiles the source code

  • Specifies the deployment descriptor

  • Bundles the .class files and deployment descriptor into an EJB JAR file


Web Component Developer


A Web component developer performs the following tasks to deliver a WAR file containing the Web component:

  • Writes and compiles servlet source code

  • Writes JSP and HTML files

  • Specifies the deployment descriptor for the Web component

  • Bundles the .class.jsp.html, and deployment descriptor files in the WAR file


J2EE Application Client Developer


An application client developer performs the following tasks to deliver a JAR file containing the J2EE application client:

  • Writes and compiles the source code

  • Specifies the deployment descriptor for the client

  • Bundles the .class files and deployment descriptor into the JAR file


Application Assembler


The application assembler is the company or person who receives application component JAR files from component providers and assembles them into a J2EE application EAR file. The assembler or deployer can edit the deployment descriptor directly or use tools that correctly add XML tags according to interactive selections. A software developer performs the following tasks to deliver an EAR file containing the J2EE application:

  • Assembles EJB JAR and WAR files created in the previous phases into a J2EE application (EAR) file

  • Specifies the deployment descriptor for the J2EE application

  • Verifies that the contents of the EAR file are well formed and comply with the J2EE specification


Application Deployer and Administrator


The application deployer and administrator is the company or person who configures and deploys the J2EE application, administers the computing and networking infrastructure where J2EE applications run, and oversees the runtime environment. Duties include such things as setting transaction controls and security attributes and specifying connections to databases.

During configuration, the deployer follows instructions supplied by the application component provider to resolve external dependencies, specify security settings, and assign transaction attributes. During installation, the deployer moves the application components to the server and generates the container-specific classes and interfaces.

A deployer/system administrator performs the following tasks to install and configure a J2EE application:

  • Adds the J2EE application (EAR) file created in the preceding phase to the J2EE server

  • Configures the J2EE application for the operational environment by modifying the deployment descriptor of the J2EE application

  • Verifies that the contents of the EAR file are well formed and comply with the J2EE specification

  • Deploys (installs) the J2EE application EAR file into the J2EE server

J2EE Tutorial-4 (Packaging)



J2EE components are packaged separately and bundled into a J2EE application for deployment. Each component, its related files such as GIF and HTML files or server-side utility classes, and a deployment descriptor are assembled into a module and added to the J2EE application. A J2EE application is composed of one or more enterprise bean, Web, or application client component modules. The final enterprise solution can use one J2EE application or be made up of two or more J2EE applications, depending on design requirements.

A J2EE application and each of its modules has its own deployment descriptor. A deployment descriptor is an XML document with an .xml extension that describes a component's deployment settings. An enterprise bean module deployment descriptor, for example, declares transaction attributes and security authorizations for an enterprise bean. Because deployment descriptor information is declarative, it can be changed without modifying the bean source code. At run time, the J2EE server reads the deployment descriptor and acts upon the component accordingly.

A J2EE application with all of its modules is delivered in an Enterprise Archive (EAR) file. An EAR file is a standard Java Archive (JAR) file with an .ear extension. In the GUI version of the J2EE SDK application deployment tool, you create an EAR file first and add JAR and Web Archive (WAR) files to the EAR. If you use the command line packager tools, however, you create the JAR and WAR files first and then create the EAR. The J2EE SDK tools are described in the section Tools.

  • Each EJB JAR file contains a deployment descriptor, the enterprise bean files, and related files.

  • Each application client JAR file contains a deployment descriptor, the class files for the application client, and related files.

  • Each WAR file contains a deployment descriptor, the Web component files, and related resources.


Using modules and EAR files makes it possible to assemble a number of different J2EE applications using some of the same components. No extra coding is needed; it is just a matter of assembling various J2EE modules into J2EE EAR files.

J2EE Tutorial-3 (J2EE Components)

J2EE Components


J2EE applications are made up of components. A J2EE component is a self-contained functional software unit that is assembled into a J2EE application with its related classes and files and that communicates with other components. The J2EE specification defines the following J2EE components:

  • Application clients and applets are components that run on the client.

  • Java Servlet and JavaServer Pages (JSP) technology components are Web components that run on the server.

  • Enterprise JavaBeans (EJB) components (enterprise beans) are business components that run on the server.


J2EE components are written in the Java programming language and are compiled in the same way as any program in the language. The difference between J2EE components and "standard" Java classes is that J2EE components are assembled into a J2EE application, verified to be well formed and in compliance with the J2EE specification, and deployed to production, where they are run and managed by the J2EE server.

J2EE Clients


A J2EE client can be a Web client or an application client.

Web Clients


A Web client consists of two parts: dynamic Web pages containing various types of markup language (HTML, XML, and so on), which are generated by Web components running in the Web tier, and a Web browser, which renders the pages received from the server.

A Web client is sometimes called a thin client. Thin clients usually do not do things like query databases, execute complex business rules, or connect to legacy applications. When you use a thin client, heavyweight operations like these are off-loaded to enterprise beans executing on the J2EE server where they can leverage the security, speed, services, and reliability of J2EE server-side technologies.

Applets


A Web page received from the Web tier can include an embedded applet. An applet is a small client application written in the Java programming language that executes in the Java virtual machine installed in the Web browser. However, client systems will likely need the Java Plug-in and possibly a security policy file in order for the applet to successfully execute in the Web browser.

Web components are the preferred API for creating a Web client program because no plug-ins or security policy files are needed on the client systems. Also, Web components enable cleaner and more modular application design because they provide a way to separate applications programming from Web page design. Personnel involved in Web page design thus do not need to understand Java programming language syntax to do their jobs.

Application Clients


A J2EE application client runs on a client machine and provides a way for users to handle tasks that require a richer user interface than can be provided by a markup language. It typically has a graphical user interface (GUI) created from Swing or Abstract Window Toolkit (AWT) APIs, but a command-line interface is certainly possible.

Application clients directly access enterprise beans running in the business tier. However, if application requirements warrant it, a J2EE application client can open an HTTP connection to establish communication with a servlet running in the Web tier.

JavaBeans Component Architecture


The server and client tiers might also include components based on the JavaBeans component architecture (JavaBeans component) to manage the data flow between an application client or applet and components running on the J2EE server or between server components and a database. JavaBeans components are not considered J2EE components by the J2EE specification.

JavaBeans components have instance variables and get and set methods for accessing the data in the instance variables. JavaBeans components used in this way are typically simple in design and implementation, but should conform to the naming and design conventions outlined in the JavaBeans component architecture.

J2EE Server Communications


Figure 1-2 shows the various elements that can make up the client tier. The client communicates with the business tier running on the J2EE server either directly or, as in the case of a client running in a browser, by going through JSP pages or servlets running in the Web tier.

Your J2EE application uses a thin browser-based client or thick application client. In deciding which one to use, you should be aware of the trade-offs between keeping functionality on the client and close to the user (thick client) and off-loading as much functionality as possible to the server (thin client). The more functionality you off-load to the server, the easier it is to distribute, deploy, and manage the application; however, keeping more functionality on the client can make for a better perceived user experience.



 

Figure 1-2 Server Communications

Web Components


J2EE Web components can be either servlets or JSP pages. Servlets are Java programming language classes that dynamically process requests and construct responses. JSP pages are text-based documents that execute as servlets but allow a more natural approach to creating static content.

Static HTML pages and applets are bundled with Web components during application assembly, but are not considered Web components by the J2EE specification. Server-side utility classes can also be bundled with Web components and, like HTML pages, are not considered Web components.

Like the client tier and as shown in Figure 1-3, the Web tier might include a JavaBeans component to manage the user input and send that input to enterprise beans running in the business tier for processing.

Business Components


Business code, which is logic that solves or meets the needs of a particular business domain such as banking, retail, or finance, is handled by enterprise beans running in the business tier.Figure 1-4 shows how an enterprise bean receives data from client programs, processes it (if necessary), and sends it to the enterprise information system tier for storage. An enterprise bean also retrieves data from storage, processes it (if necessary), and sends it back to the client program.



 

Figure 1-3 Web Tier and J2EE Application



 

Figure 1-4 Business and EIS Tiers

There are three kinds of enterprise beans: session beans, entity beans, and message-driven beans. A session bean represents a transient conversation with a client. When the client finishes executing, the session bean and its data are gone. In contrast, an entity bean represents persistent data stored in one row of a database table. If the client terminates or if the server shuts down, the underlying services ensure that the entity bean data is saved.

message-driven bean combines features of a session bean and a Java Message Service ("JMS") message listener, allowing a business component to receive JMS messages asynchronously. This tutorial describes entity beans and session beans. For information on message-driven beans, see The Java Message Service Tutorial, available at

http://java.sun.com/products/jms/tutorial/index.html 


Enterprise Information System Tier


The enterprise information system tier handles enterprise information system software and includes enterprise infrastructure systems such as enterprise resource planning (ERP), mainframe transaction processing, database systems, and other legacy information systems. J2EE application components might need access to enterprise information systems for database connectivity, for example.