Languages Designed for the JVM

Plenty of languages are specifically designed for the JVM; Table 1-1 describes a few of them. All but Clojure are discussed in this book.

Here are some important definitions:

• Dynamic typing: Dynamic typing keeps track of information about what sort of values the variables contain by carrying the type information on the values held in variables.
• Static typing: In static typing, the type information is all about the variables, not the values in them.
• Imperative languages: These are languages in which the state can be mutated by the instructions in the language.
• Functional languages: In functional languages, the functions operate on values as in procedural languages, but instead of mutating the state, the functions are purely mathematical functions that return new values.

Figure 1-1 shows where Java 8, Groovy, Scala, and Clojure fall on the functional language continuum. Java 8 introduces lambdas, which makes it slightly functional, Groovy has had functional constructs since its inception and is even more functional with Groovy 2.0, and Scala is the most functional of the three object-oriented (OO) languages. Clojure, on the other hand, is a purely functional, non-OO language.

Languages Ported to the JVM

JRuby, Jython, and Rhino are a few of the mainstream JVM implementations of existing languages. Table 1-2 describes them.

This book is based on some of the mainstream object-oriented JVM languages that were specifically designed for the JVM, namely, Java, Groovy, and Scala.

The Java EE Platform

The Java EE platform is driven by the following two goals:

• Providing the API specifications that are the building blocks of the web application.
• Standardizing and reducing the complexity of enterprise application development. It does this by providing an application model that defines an architecture for implementing services as multitiered applications.

Figure 1-2 summarizes the evolution of Java EE and, for the sake of brevity, shows only the new specifications added with each release.

The Java EE platform is aimed at standardizing and reducing the complexity of enterprise application development by providing an application model that defines an architecture for implementing services as multitiered applications. In a multitiered application, the functionality of the application is separated into distinct functional areas, called tiers. Figure 1-3 illustrates the typical multitiered architecturein a Java EE application model.

The Client Tier

The client tier is the top tier in a multitiered Java EE architecture; it consists of application clients that make requests to the Java EE server, which is often located on a different machine. The server processes the requests and returns a response to the client. An example of a client is a web browser or a stand-alone application.

The Web Tier

The web tier consists of components that handle the interaction between clients and the business tier. After receiving a request from the client, the web tier does the following:

1. Collects input from the client
2. Controls the flow of screens or pages on the client
3. Maintains the state of data for a user’s session
4. Obtains results from the components in the business tier
5. Generates dynamic content in various formats to the client

As shown in Figure 1-2, a new Web Profile specification has been added in Java EE 7.¹⁰ Table 1-3 lists technologies included in the Web Profile specification. As mentioned earlier, the goal of Web Profile is to allow developers to create web applications with the appropriate set of technologies.

Regarding the Web Profile specifications listed in Table 1-3:

• In Java EE 7, no changes were made to JSP and JSTL because these specifications have not been updated.
• Expression Language has been removed from JSP and now has its own JSR (341).
• Servlets and JSF have both been updated.
• WebSocket 1.0 was introduced in Java EE 7.

This book concentrates on the web tier of Java EE; we will dive deep into the web tier in Chapter 2.

The multitier architecture of Java EE has a tremendous impact on the development of Java enterprise applications. A Java enterprise applicationcan be defined as a Java application that utilizes the enterprise services offered by Java EE. In fact, a web application can be classified as an enterprise application if it utilizes Java EE services in the form of components packed in the web tier. Java EE isolates these services functionally into separate tiers, as illustrated in Figure 1-3, by providing an application model on which the Java enterprise applications should be built. As a consequence, the Java enterprise application mirrors the multitier architecture of Java EE. Figure 1-4 illustrates a generalized view of the layers of a typical web application.

Each layer in Figure 1-4 is an area of concern, for the application. For instance, the web layer deals only with employing the web tier components of Java EE. Having different layers in an application results in what is called a separation of concerns. In terms of implementation, this separation of concerns is achieved using coarse-grained interfaces.

The concern is the feature, functionality or business functions with which the application’s developer needs to be concerned. Crosscutting such concerns is inherent in complex systems and leads to code scattering, which is when code for one concern spans many modules, and code tangling, which is when code in one module concentrates on addressing multiple concerns. Code scattering and code tangling lead to a lack of clarity, redundancy, rigidity, and continuous refactoring. Figure 1-5 illustrates how the system services of logging, transaction, and security crosscut the business functions of the application.

BookService in Figure 1-5 is too involved with the system services. Each object knows and is responsible for logging, security, and transaction. A method, for example, to purchase a book in BookService should be concerned only with how to purchase the book and not with whether it is secure or transactional. Separation of concerns, one of the main goals of software engineering, lets you handle each service on its own and thereby does the following:

• Promotes traceability within and across the artifacts in the system, throughout the life cycle of the system
• Controls the impact caused by the change, thereby providing scope for evolution and noninvasive adaptation
• Promotes development of cohesive units, thereby facilitating reuse

Setting Up the Development Environment

The Java software is available in two distributions.

• The Java Runtime Environment (JRE)
• The Java Development Kit (JDK)

The JRE includes a JVM and the core libraries; it is essentially just an environment for running bytecode. The JDK includes the JRE, a Java compiler (javac), and other tools—the basic software you need to write and compile Java programs.

Before you can start compiling and running Java programs, you need to download and install the JDK and configure some system environment variables.

Most of the code in this book requires Java 7, but some of the code is based on Java 8, so you should install Java 8. To get the latest version of the JDK)), follow these steps:

1. Open www.oracle.com/technetwork/java/javase/downloads/index.html in a web browser.
2. Click the Download JDK button.
3. Follow the instructions provided by the web site.
4. Run the installer and accept any defaults.

To confirm you have installed the JDK correctly, type javac on the command line from any directory on your machine. If you see instructions on how to run javac correctly, then you have installed it successfully.

Creating and Running Your First Java Application

This section demonstrates how to create, compile, and execute a simple Java application on Windows. Every Java application has one class that is the program’s starting point (often called an entry point). Listing 1-1 illustrates a HelloWorld entry-point class.

Listing 1-1. A HelloWorld Java Application

1.    public class HelloWorld {
2.    public static void main(String[] args) {
3.    System.out.println("Hello World.");
4.     }
5.    }

• Line 2: The main method in line 2 makes this class an entry-point class. This method accepts inputs and starts the program.

The name of the Java application should be the name of the entry-point class, and the file that holds a Java class must have the same name as the class. Therefore, the HelloWorld class in Listing 1-1 must be stored in a file named HelloWorld.java.

You use the javac program in the bin directory of your JDK installation directory to compile Java programs. Assuming you have edited the PATH environment variable on your computer, you should be able to invoke javac from any directory. To compile the HelloWorld class in Listing 1-1, do the following:

1. Open a command prompt and change to the directory where the HelloWorld.java file is saved.
2. Type the following command:

   javac HelloWorld.java

If everything goes well, javac will create a file named HelloWorld.class in your working directory.

Running Your Java Application

To run your Java application, you have to use the java program that is part of the JDK with the command java <class name>. Again, having added the PATH environment variable, you should be able to invoke java from any directory. From your working directory, type the following:

java  HelloWorld

Note that you do not include the .class extension when running a Java application. You will see the following on your console:

Hello World.

Developing Java Applications with an IDE

In this book you will use the Eclipse Kepler integrated development environment (IDE). To download it, follow these steps:

1. Open www.eclipse.org/downloads/ in a web browser.
2. Follow the instructions provided by the web site.
3. Run the installer and accept any defaults.

packageapress.helloworld;
 
/**
 * A Hello World Java application
 * @author Vishal Layka
 *
 */
public class HelloWorld {
     
    /**
     * Entry point
     * @paramargs
     */
    public static void main(String[] args){
        System.out.println("Hello World");
    }
 
}

Data Access Layer for the Bookstore Application

Now that the database is ready, you will build the data access layer for application. The data access layer will retrieve the data via JDBC from the database and directly map the result set into Java objects. These Java objects are the domain objects in the application that are the Java representation of the tables in the database. The data access layer is responsible for interfacing with the underlying persistence mechanism in a transparent way in order to store and retrieve objects from the database. This transparency means that the data access layer can switch the persistence mechanism from plain JDBC¹⁴ to ORM¹⁵ persistence technologies such as Hibernate,¹⁶ JPA,¹⁷ and so on, without affecting the client of the data access layer. This transparency is achieved via the data access object (DAO) pattern, as illustrated in Figure 1-19. The DAO object provides an interface to the database or the underlying persistence mechanism, thus abstracting the underlying implementation from the client.

The DAO maps application calls to the persistence mechanism and provides specific data operations without exposing details of the database. The DAO interface abstracts the implementation details of accessing the data from the client (application object) and provides the domain-specific objects that the client (application object) needs.

First you need to create the domain-specific classes for the Java object representations of the database tables Listings 1-4, 1-5, and 1-6 show the Book, Author, and Category domain classes, respectively.

Listing 1-4. Model: Category

package com.apress.books.model;
 
public class Category {
    private Long id;
    private String categoryDescription;
 
    public Long getId() {
        return id;
    }
 
    public void setId(Long id) {
        this.id = id;
    }
 
    public String getCategoryDescription() {
        returncategoryDescription;
    }
 
    public void setCategoryDescription(String categoryDescription) {
        this.categoryDescription = categoryDescription;
    }
 
    public String toString() {
        return "Category - Id: " + id + ", Category Description: "
                + categoryDescription;
    }
 
}

Listing 1-5. Model: Book

package com.apress.books.model;
 
import java.util.List;
import com.apress.books.model.Author;
 
public class Book {
    private Long id;
    private Long categoryId;
    private String bookTitle;
    private List<Author> authors;
    private String publisherName;
 
    public Long getId() {
        return id;
    }
 
    public void setId(Long id) {
        this.id = id;
    }
 
    public Long getCategoryId() {
        return categoryId;
    }
 
    public void setCategoryId(Long categoryId) {
        this.categoryId = categoryId;
    }
 
    public String getBookTitle() {
        return bookTitle;
    }
 
    public void setBookTitle(String bookTitle) {
        this.bookTitle = bookTitle;
    }
 
    public List<Author> getAuthors() {
        return authors;
    }
 
    public void setAuthors(List272103_1_En authors) {
        this.authors = authors;
    }
 
    public String getPublisherName() {
        return publisherName;
    }
 
    public void setPublisherName(String publisherName) {
        this.publisherName = publisherName;
    }
 
    public String toString() {
        return "Book - Id: " + id + ", Book Title: " + bookTitle;
    }
 
}

Listing 1-6. Model: Author

package com.apress.books.model;
 
public class Author {
    private Long id;
    private Long bookId;
    private String firstName;
    private String lastName;
 
    public Long getId() {
        return id;
    }
 
    public void setId(Long id) {
        this.id = id;
    }
 
    public Long getBookId() {
        return bookId;
    }
 
    public void setBookId(Long bookId) {
        this.bookId = bookId;
    }
 
    public String getFirstName() {
        return firstName;
    }
 
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
 
    public String getLastName() {
        return lastName;
    }
 
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
 
    public String toString() {
        return "Author - Id: " + id + ", Book id: " + bookId + ", First Name: "
                + firstName + ", Last Name: " +lastName;
    }
 
}

Now let’s start with a simple interface for BookDAO that encapsulates all the data access by your web application. Listing 1-7 shows the BookDAO interface.

Listing 1-7. BookDAO Interface

 1.    package com.apress.books.dao;
 2.
 3.    import java.util.List;
 4.
 5.    import com.apress.books.model.Book;
 6.    import com.apress.books.model.Category;
 7.
 8.    public interface BookDAO {
 9.        public List<Book>findAllBooks();
10.
11.        public List<Book>searchBooksByKeyword(String keyWord);
12.
13.        public List<Category>findAllCategories();
14.
15.        public void insert(Book book);
16.
17.        public void update(Book book);
18.
19.        public void delete(Long bookId);
20.
21.    }

• Line 9: This is the findAllBooks() method for listing all the books from the database.
• Line 11: SearchBooksByKeyword(String keyWord) allows the user to search books by keyword in the title of the book or by the first and last names of the author.
• Line 13: findAllCategories() is required by the application to provide a categorized listing of books.

The methods in this interface correspond to the CRUD terms (in other words, create, read, update, and delete) of the application. Listing 1-8 illustrates the implementation of the BookDAO interface.

Listing 1-8. Implementation of the BookDAO Interface

 1.    package com.apress.books.dao;
 2.
 3.    import java.sql.Connection;
 4.    import java.sql.DriverManager;
 5.    import java.sql.PreparedStatement;
 6.    import java.sql.ResultSet;
 7.    import java.sql.SQLException;
 8.    import java.sql.Statement;
 9.    import java.util.ArrayList;
10.    import java.util.List;
11.
12.    import java.apress.books.model.Author;
13.    import java.apress.books.model.Book;
14.    import java.apress.books.model.Category;
15.
16.    public class BookDAOImpl implements BookDAO {
17.
18.        static {
19.            try {
20.                Class.forName("com.mysql.jdbc.Driver");
21.            } catch (ClassNotFoundException ex) {
22.            }
23.        }
24.
25.        private Connection getConnection() throws SQLException {
26.            return DriverManager.getConnection("jdbc:mysql://localhost:3306/books",
27.                    "root", "password");
28.        }
29.
30.        private void closeConnection(Connection connection) {
31.            if (connection == null)
32.                return;
33.            try {
34.                connection.close();
35.            } catch (SQLException ex) {
36.            }
37.        }
38.
39.        public List<Book> findAllBooks() {
40.            List<Book> result = new ArrayList<>();
41.            List<Author> authorList = new ArrayList<>();
42.
43.            String sql = "select * from book inner join author on book.id = author.book_id";
44.
45.            Connection connection = null;
46.            try {
47.                connection = getConnection();
48.                PreparedStatement statement = connection.prepareStatement(sql);
49.                ResultSet resultSet = statement.executeQuery();
50.                while (resultSet.next()) {
51.                    Book book = new Book();
52.                    Author author = new Author();
53.                    book.setId(resultSet.getLong("id"));
54.                    book.setBookTitle(resultSet.getString("book_title"));
55.                    book.setCategoryId(resultSet.getLong("category_id"));
56.                    author.setBookId(resultSet.getLong("book_Id"));
57.                    author.setFirstName(resultSet.getString("first_name"));
58.                    author.setLastName(resultSet.getString("last_name"));
59.                    authorList.add(author);
60.                    book.setAuthors(authorList);
61.                    book.setPublisherName(resultSet.getString("publisher"));
62.                    result.add(book);
63.                }
64.            } catch (SQLException ex) {
65.                ex.printStackTrace();
66.            } finally {
67.                closeConnection(connection);
68.            }
69.            return result;
70.        }
71.
72.
73.        public List<Book> searchBooksByKeyword(String keyWord) {
74.            List<Book> result = new ArrayList<>();
75.            List<Author> authorList = new ArrayList<>();
76.
77.            String sql = "select * from book inner join author on book.id = author.book_id"
78.                    + " where book_title like '%"
79.                    + keyWord.trim()
80.                    + "%'"
81.                    + " or first_name like '%"
82.                    + keyWord.trim()
83.                    + "%'"
84.                    + " or last_name like '%" + keyWord.trim() + "%'";
85.
86.            Connection connection = null;
87.            try {
88.
89.                connection = getConnection();
90.                PreparedStatement statement = connection.prepareStatement(sql);
91.                ResultSet resultSet = statement.executeQuery();
92.                while (resultSet.next()) {
93.                    Book book = new Book();
94.                    Author author = new Author();
95.                    book.setId(resultSet.getLong("id"));
96.                    book.setBookTitle(resultSet.getString("book_title"));
97.                    book.setPublisherName(resultSet.getString("publisher"));
98.                    author.setFirstName(resultSet.getString("first_name"));
99.                    author.setLastName(resultSet.getString("last_name"));
100.                    author.setBookId(resultSet.getLong("book_id"));
101.                    authorList.add(author);
102.                    book.setAuthors(authorList);
103.                    result.add(book);
104.                }
105.            } catch (SQLException ex) {
106.                ex.printStackTrace();
107.            } finally {
108.                closeConnection(connection);
109.            }
110.
111.            return result;
112.        }
113.
114.        public List<Category> findAllCategories() {
115.            List<Category> result = new ArrayList<>();
116.            String sql = "select * from category";
117.
118.            Connection connection = null;
119.            try {
120.                connection = getConnection();
121.                PreparedStatement statement = connection.prepareStatement(sql);
122.                ResultSet resultSet = statement.executeQuery();
123.                while (resultSet.next()) {
124.                    Category category = new Category();
125.                    category.setId(resultSet.getLong("id"));
126.                    category.setCategoryDescription(resultSet
127.                            .getString("category_description"));
128.                    result.add(category);
129.                }
130.            } catch (SQLException ex) {
131.                ex.printStackTrace();
132.            } finally {
133.                closeConnection(connection);
134.            }
135.            return result;
136.        }
137.
138.        public void insert(Book book) {
139.        }
140.
141.        public void update(Book book) {
142.        }
143.
144.        public void delete(Long bookId) {
145.
146.        }
147.    }

Listing 1-8 is an implementation of the BookDao interface for interacting with; this interaction includes connecting to the database and selecting, deleting, and updating data via pure JDBC. JDBC provides the driver that is specific to each database and that allows Java code the database.

• Lines 18 to 37: These lines show the code required for managing a JDBC connection.
• Line 26: The getConnection() method returns a driver-implemented java.sql.Connection interface. This interface allows you to run SQL statements against the database. For this to work, you need to provide a MySQL Connector/J JAR file. A MySQL Connector/J is a native Java driver that converts JDBC calls into a network protocol the MySQL database can understand. The DriverManager manages drivers and provides static methods for establishing connections to the database.

• Lines 30 to 37: The connections need to be closed because connections are expensive when it comes to the performance of the application.
• Lines 39 to 144: These lines are implementations of CRUD services in the BookDAO interface.
• Lines 67, 108, and 133: You created a connection for each statement in the CRUD services. You need to close these connections; keeping them open will result in the poor performance of the application.

Client for the Data Access Layer

Now that your data access layer is ready, you will query it with a stand-alone Java application. In Chapter 2, you will replace this Java app with a web application. Listing 1-9 illustrates the Java application.

Listing 1-9. Stand-Alone Bookstore Java App

 1.    package com.apress.books.client;
 2.    import java.util.List;
 3.
 4.    import com.apress.books.dao.BookDAO;
 5.    import com.apress.books.dao.BookDAOImpl;
 6.    import com.apress.books.model.Book;
 7.
 8.    public class BookApp {
 9.        private static BookDAO bookDao = new BookDAOImpl();
10.
11.        public static void main(String[] args) {
12.            // List all books
13.            System.err.println("Listing all Books:");
14.            findAllBooks();
15.            System.out.println();
16.            // search book by keyword
17.            System.err.println("Search book by keyword  in book title : Groovy:");
18.
19.            searchBooks("Groovy");
20.            System.out.println();
21.
22.            System.err.println("Search book by keyword  in author's name  : Josh:");
23.
24.            searchBooks("Josh");
25.
26.
27.        }
28.
29.        private static void findAllBooks() {
30.            List<Book> books = bookDao.findAllBooks();
31.            for (Book book : books) {
32.                System.out.println(book);
33.            }
34.        }
35.        private static void searchBooks(String keyWord) {
36.            List<Book> books = bookDao.searchBooksByKeyword(keyWord);
37.            for (Book book : books) {
38.                System.out.println(book);
39.            }
40.        }
41.    }

Figure 1-20 illustrates the directory structure of the stand-alone application.

Running this application gives the following output:

In the next chapter, you will develop the web layer that will replace this client and that will call the data access layer in the bookstore web application.

Responsive Web Applications

One of the greatest strengths of the Web is that it is flexible. This flexibility, however, is also its greatest weakness. This weakness manifests itself when a web application tested on one browser is viewed on the different browser and doesn’t perform properly. This cross-browser compatibility problem has only grown with the advent of smartphones. As shown in Figure 1-21, as of the end of 2013, there are 6.8 billion mobile subscriptions worldwide, and that number is poised to grow to 8 billion by 2016 (www.itu.int/ITU-D/ict/facts/index.html).

Web applications are expected to run on smartphones as well as on the desktop, but creating separate web applications for the desktop and the smartphone has significant overhead for development as well as maintenance. In May 2010, Ethan Marcotte wrote an article for A List Apart titled “Responsive Web Design” (http://d.alistapart.com/responsive-web-design/ex/ex-site-flexible.html) that defined a groundbreaking approach. He used existing tools (which will be explained later in this section) to create a site that displays beautifully on different devices, as illustrated in Figure 1-22 and Figure 1-23.

Responsive web applications are device-agnostic, in that they adapt themselves to the device on which they are run. The technique goes as far as rethinking the way page layouts are designed. You can go one step further by designing the web application with the smallest screen (smartphones) in mind and then progressively enhance the application to run on desktop screens. This technique is known as mobile-first design. The philosophy of a mobile-first design is that if you design the interface and the web components to run with acceptable performance on a smartphone, the performance on desktop screens will be blazing fast. In addition, using the smartphone real estate wisely will also be applied to the desktop screens, which will result in better usability of the application.

The core technologies employed in developing responsive web applications are CSS3,¹⁸ jQuery¹⁹ and jQuery plug-ins,²⁰ LESS,²¹ CoffeeScript,²² and front-end frameworks such as Bootstrap,²³ Polyfills, and Modernizr.

Here are some important definitions in the responsive world:

• Unobtrusive JavaScript²⁴: Unobtrusive JavaScript is a means of separation of concerns, that is, separating the look and feel from behavior concerns. This results in a pure markup, and the JavaScript (behavior) works unobtrusively across different browsers and devices. jQuery is a popular library that helps in writing unobtrusive JavaScript. CoffeeScript compiles into JavaScript. It is used as an alternative to JavaScript and considerably reduces code.
• CSS3 media queries: Media queries are the primary means of making web applications responsive. Media queries use media features such as device-width, device-height, orientation, and device-aspect-ratio in a CSS file to develop a responsive web application.
• LESS: LESS is the CSS preprocessor that is used when a CSS3 stylesheet gets unmanageable. LESS extends CSS with dynamic behavior such as mixins and functions.
• Polyfills: Polyfills are JavaScript, used to make a browser HTML5-enabled. The polyfills provide missing functionality in the browser and provide a fallback.
• Modernizr: Modernizr is a JavaScript library that detects HTML5 and CSS3 features in the browser and conditionally loads polyfills.

Single-Page Web Application (SPA)

Another trend in web application development is a single-page web application (SPA).

• The client-side code—such as HTML, JavaScript, and CSS—is retrieved with a single page load; the page does not reload at any point in the process, and the control is not transferred to another page.
• The resources, such as images, are dynamically loaded and added to the page in response to events.

SPAs are built using Node.js²⁵ as the web server. AngularJS is a full-featured SPA framework.

Real-Time Web Application

A real-time web application delivers responses to events in a measurable and acceptable time period, depending on the nature of the event, by means of asynchronous, bidirectional communication between the client and the server. WebSocket is the core technology employed for developing real-time web applications. WebSocket provides a full-duplex and bidirectional communication protocol over a single TCP connection. That is, a client and a server can send messages to each other and independent of each other.

A few examples of the applications that require real-time functionality are chat applications, multiplayer online games, stock trading applications, and so on.

Reactive Web Application

Reactive applications are a new class of applications that are fundamentally different from traditional web-based applications and are driven by the Typesafe²⁶ Reactive Platform. The Typesafe Reactive Platform is a suite of integrated products consisting of the Play 2 framework, Akka,²⁷ and Scala, along with the Typesafe Console for command and control. Reactive programming is becoming crucial because of multicore processors and because it advocates asynchronous and event-based programming. The Play framework is an alternative to the enterprise Java stacks. Play is built for the needs of modern web and mobile applications, leveraging technologies such as REST, JSON, and WebSocket, to name a few. These technologies allow the creation of rich, highly interactive user interfaces rendered via any modern browser, while at the same time making it easier to render portions of the page in parallel and to do partial-page updates or progressive enhancements.

Mashups and Web Services

A mashup is a web application that uses content from more than one source to create a new service displayed in a single graphical interface. With mashups you can develop powerful applications by combining web services. You can find popular APIs for mashups at www.programmableweb.com/apis/directory/1?sort=mashups. This section will focus on web services and then touch on a fascinating trend, which is still an area of research: the Semantic Web.

A web service is a software component stored on one machine that can be accessed over the network by an application (or other software component) on another machine. The machine on which a web service resides is referred to as a web service host. The client application sends a request over a network to the web service host, which processes the request and returns the response. Making a web service available to receive client requests is known as publishing a web service; using a web service from a client application is known as consuming a web service.

Web services use technologies such as XML and JSON²⁸ for data interchange.

Semantic Web (Web 3.0)

Web 2.0 began to take shape in 2004. It was pioneered by Google and followed by social applications such as video sharing, social networking, microblogging, photo sharing, Wikipedia, and virtual worlds such as Second Life. Mashups played a major role in the evolution of social applications and Web 2.0.

The term Semantic Web refers to the W3C’s vision of the Web of linked data. The Semantic Web can be viewed as a set of standards that allow machines to understand the meaning of information on the Web. The Web as it is today constitutes data that has no meaning in itself, and the meaning has to be constituted manually after gathering the data from the Web. Semantic Web technologies enable you to create data stores on the Web, build vocabularies, and write rules for handling data. Linked data are empowered by technologies such as RDF,³¹ SPARQL,³² and OWL.³³ The Semantic Web is the future of the Web and is a subject of ongoing research. I recommend Aaron Swartz’s A Programmable Web: An Unfinished Work³⁴ as an excellent resource on the Semantic Web. You can also follow the latest news on the Semantic Web.