WEB X.

0 HANDY NOTES
1. Semantic Web Stack

 The Semantic Web is an extension of the World Wide Web that focuses on enhancing the
ability of computers to understand the meaning of information, allowing for more efficient
and intelligent information processing.
 It is a web of data that can be processed and understood by machines.
 At its core, the Semantic Web is built on a set of technologies, protocols, and standards
collectively referred to as the "Semantic Web stack." The components of the stack include:

i. Resource Description Framework (RDF): This is the foundation of the Semantic

Web, providing a framework for representing and exchanging information in a
machine-readable format. RDF uses a subject-predicate-object model to express
statements about resources, where each statement is represented as a triple of
information.
ii. RDF Schema (RDFS): This is a vocabulary used to define and describe the meaning
of terms used in RDF. RDFS provides a way to specify classes, properties, and
relationships between them, allowing for more precise modeling of concepts.
iii. Web Ontology Language (OWL): This is a more expressive language for creating
ontologies, or vocabularies of terms and their relationships. OWL enables the creation
of complex knowledge representations that can be used for advanced reasoning and
inference.
iv. SPARQL Protocol and RDF Query Language (SPARQL): This is a query language
used to access and manipulate RDF data. SPARQL allows for sophisticated queries and
filtering of RDF data, enabling more advanced data analysis and processing.
v. Uniform Resource Identifier (URI): This is a standard for identifying and locating
resources on the web. URIs are used to create unique identifiers for resources, which
can be used to connect and relate different pieces of data.

 Together, these components form the basis of the Semantic Web stack, enabling the
creation of a web of linked data that can be processed and understood by machines.
 The Semantic Web has the potential to revolutionize the way we interact with and use data,
enabling more intelligent and efficient information processing across a wide range of
domains.
 WEB X.0 HANDY NOTES
2. Web 1.0, 2.0 and 3.0

S. No. Web 1.0 Web 2.0 Web 3.0

1. Mostly Read-Only Wildly Read-Write Portable and Personal

2. Web Forms Web Applications Smart Applications

3. Banner Advertising Interactive Advertising Behavioural Advertising

4. Britannica Online Wikipedia The Semantic Web

5. HTML/Portals XML / RSS RDF / RDFS / OWL

6. Data was not focused. Data of many was Data was personalized and no
controlled by mediatory. use of mediatory.

7. Information sharing is the Interaction is the goal. Immersion is the goal.

goal.

8. It connects information as It aims to connect Focuses on relating

its primary goal. people. knowledge.

9. Static websites Introduction of web Intelligent web-based

applications functions and apps

10. A simpler, more passive An enhanced social Web A semantic web exists.
web.

11. Web and File Servers, AJAX, JavaScript, CSS, Web 3.0 technologies include
HTML, and Portals are and HTML5 are blockchain, artificial
technologies connected to examples of related intelligence, and
Web 1.0. technology. decentralized protocols.

3. TypeScript Inheritance
 In TypeScript, inheritance is a way to create a new class from an existing class, inheriting
the properties and methods of the existing class. The new class is called the derived class
or the subclass, and the existing class is called the base class or the superclass.
 Inheritance is a fundamental concept in object-oriented programming, providing code
reuse and polymorphism.
 To inherit from a base class, the “extends” keyword is used in the class declaration of the
derived class. The derived class can then access the properties and methods of the base
class using the “super” keyword.
 WEB X.0 HANDY NOTES
class Animal {
constructor(public name: string) {}
move(distance: number) {
console.log(`${this.name} moved ${distance} meters.`);
}
}
class Dog extends Animal {
bark() {
console.log(`${this.name} barked.`);
}
move(distance: number) {
super.move(distance);
console.log(`${this.name} ran ${distance} meters.`);
}
}
let dog = new Dog("Fido");
dog.move(10);
dog.bark();

Output:

4. TypeScript vs JavaScript

Feature TypeScript JavaScript

Typing Provides static typing Dynamically typed

Tooling Comes with IDEs and code editors Limited built-in tooling

Similar to JavaScript, with additional Standard JavaScript syntax

Syntax
features

Backward compatible with JavaScript Cannot run TypeScript in

Compatibility
JavaScript files

Stronger typing can help identify May require more debugging and
Debugging
errors testing

Learning Can take time to learn additional Standard JavaScript syntax is

curve features familiar
 WEB X.0 HANDY NOTES
5. AngularJS Expressions

 AngularJS expressions can be written inside double braces: {{ expression }}.

 AngularJS expressions can also be written inside a directive: ng-bind="expression".
 AngularJS will resolve the expression, and return the result where the expression is written.
 AngularJS expressions can contain literals, operators, and variables.

<!DOCTYPE html>
<html>
<script
src="https://ajax.googleapis.com/ajax/libs/angularjs/1.6.9/angular.min.js">
</script>
<body>
<div ng-app="">
<p>My first expression: {{ 5 + 5 }}</p>
</div>
</body>
</html>
Output: My first expression: 10

<div ng-app="" ng-init="myCol='lightblue'">

<input style="background-color:{{myCol}}" ng-model="myCol">
</div>

Output:

<div ng-app="" ng-init="quantity=1;cost=5">

<p>Total in dollar: {{ quantity * cost }}</p>
</div>
Output: Total in dollar: 5

<div ng-app="" ng-init="firstName='John';lastName='Doe'">

<p>The name is {{ firstName + " " + lastName }}</p>
</div>
Output: The full name is: John Doe

<div ng-app="" ng-init="person={firstName:'John',lastName:'Doe'}">

<p>The name is {{ person.lastName }}</p>
</div>
Output: The name is Doe

<div ng-app="" ng-init="points=[1,15,19,2,40]">

<p>The third result is {{ points[2] }}</p>
</div>
Output: The third result is 19
 WEB X.0 HANDY NOTES
6. Directives in Angular JS
a. ngRoute
Routing in AngularJS is used when the user wants to navigate to different pages in an
application but still wants it to be a single page application. AngularJS routes enable the user
to create different URLs for different content in an application. The ngRoute module helps in
accessing different pages of an application without reloading the entire application.

Output:

b. ng-click
The ng-click Directive in AngularJS is used to apply custom behavior when an element is
clicked. It can be used to show/hide some element or it can pop up an alert when the button is
clicked.
 WEB X.0 HANDY NOTES

Output:

c. ng-model
The ngModel directive is a directive that is used to bind the values of the HTML controls
(input, select, and textarea) or any custom form controls, and stores the required user value in
a variable and we can use that variable whenever we require that value. It also is used during
form validations. The various form input types (text, checkbox, radio, number, email, URL,
date, datetime-local time, month, week) can be used with the ngModel directive. This directive
is supported by <input>, <select> & <textarea>.

Output:
d. ng-bind
The ng-bind Directive in AngularJS is used to bind/replace the text content of any particular
HTML element with the value that is entered in the given expression. The value of specified
HTML content updates whenever the value of the expression changes in the ng-bind directive.
 WEB X.0 HANDY NOTES

Output:

e. ng-view
ngView is a directive that complements the $route service by including the rendered template
of the current route into the main layout (index.html) file. Every time the current route changes,
the included view changes with it according to the configuration of the $route service.

Output:
 WEB X.0 HANDY NOTES
7. AngularJS Data Binding
 Data Binding is a way to synchronize the data between the model and view components
automatically.
 AngularJS implements data-binding that treats the model as the single-source-of-truth in
your application & for all the time, the view is a projection of the model.
 Unlike React, angular supports two-way binding. In this way, we can make the code more
loosely coupled.
 One-way Binding: This type of binding is unidirectional, i.e. this binds the data flow from
either component to view (DOM) or from the view (DOM) to the component. There are
various techniques through which the data flow can be bind from component to view or
vice-versa. If the data flow from component to view (DOM), then this task can be
accomplished with the help of String Interpolation & Property Binding.
 Interpolation: Angular interpolation is used to display a component property in
the respective view template with double curly braces syntax. Interpolation is used
to transfer properties mentioned in the component class to be reflected in its
template.

<h5> Addition of 3 and 5 with Interpolation is {{3+5}} </h5>

<h5> Addition of 3 and 5 without Interpolation is 3+5 </h5>
Output:

 Property Binding: If we have to store Boolean or other data types then use
Property Binding. In simple words, we bind a property of a DOM element to a field
which is a defined property in our component TypeScript code.

Output:
 WEB X.0 HANDY NOTES
 Event Binding: It is used to handle the events raised by the user actions like button
click, mouse movement, keystrokes, etc. When the DOM event happens at an
element, it calls the specified method in the particular component.

Output:

 Two-way Binding: In this type of binding, the immediate changes to the view &
component, will be reflected automatically, i.e. when the changes made to the component
or model then the view will render the changes simultaneously. Similarly, when the data is
altered or modified in the view then the model or component will be updated accordingly.

Output:
 WEB X.0 HANDY NOTES
8. AngularJS Dependency Injection.

 AngularJS uses Dependency Injection (DI) to manage its components and their
dependencies. Dependency Injection is a design pattern that promotes loosely-coupled
code and makes it easier to test and maintain.
 In AngularJS, each component such as a controller, service, directive, or filter is created
by a provider, which is responsible for instantiating the component and its dependencies.
A provider is a function or object that defines the component and its dependencies.
 To use a component in another component, we declare its dependency as a parameter of
the constructor function. AngularJS then uses this information to inject the correct instance
of the dependency at runtime. This makes it possible to easily swap out dependencies and
test our components in isolation.
app.controller('MyCtrl', function($scope, $http) {
// Code here that uses $scope and $http
});
 In this example, the MyCtrl controller has two dependencies: $scope and $http. When the
controller is created, AngularJS injects the correct instances of $scope and $http into the
constructor function.
 Implicit Injection: Implicit injection is the most common way to use Dependency
Injection in AngularJS. In this approach, the dependencies are specified as parameters of
the constructor function. AngularJS then automatically injects the appropriate instances of
the dependencies.
app.controller('MyCtrl', function($scope, $http) {
// Code here that uses $scope and $http
});
 Explicit Injection: Explicit injection is used to inject dependencies that have not been
registered with AngularJS's built-in dependency injection system. This is useful for
injecting third-party libraries or modules.
To use explicit injection, we need to use the $injector service to create our component. We
define the dependencies as an array of strings and pass it to the $injector service along with
the constructor function.
var MyCtrl = function($scope, $http) {
// Code here that uses $scope and $http
};
MyCtrl.$inject = ['$scope', '$http'];
app.controller('MyCtrl', MyCtrl);
In this example, we define the MyCtrl constructor function and define its dependencies in
the $inject property. We then pass the MyCtrl function to the app.controller() method,
which registers it with the AngularJS dependency injection system.
 WEB X.0 HANDY NOTES
9. Form validation in Angular JS

Output:
 WEB X.0 HANDY NOTES
10. MongoDB Shell Commands

i. Connect to MongoDB Database: net start MongoDB

mongo

ii. Switch to a different port: mongo --port 28010

iii. Remote server: mongo --host mongodb0.example.com --port 28010
iv. Basic shell commands:
db show dbs

use company

11. MongoDB CRUD Operations

i. db.collection.insertMany([ <document1>, <document2>,.. ])

If you need to insert multiple documents within an already existing collection, then make
use of this command. Example:
db.books.insertMany( [{"isbn": 9780198321668, "title": "Romeo and Juliet",
"author": William Shakespeare", "category": "Tragedy", "year": 2008},
{"isbn": 9781505297409, "title": "Treasure Island", "author": "Robert Louis
Stevenson", "category": "Fiction", "year":2014}])

ii. db.collection.insert<document>)
If you need to insert a single new document into an already existing collection, then make
use of this command. Example:
db.books.insert({ "isbn": 9780060859749, "title": "After Alice: A Novel",
"author": "Gregory Maguire", "category": "Fiction" "year:2016 })
 WEB X.0 HANDY NOTES
iii. db.collection.find(<query>)
If you need to find a specific document within a collection by using a field value condition,
then use this command. Example:
db.books.find({ "title":"Treasure Island"})

iv. db.collection.find()
If you need to find all the documents in an already existing collection, then make use of
this command. Example:
db.books.find()

v. db.collection.findOne(<query>, <projection>)
If you need to find the first document that matches the query you have given, then make
use of this command. Example:
db.books.findOne({}, {_id:false })

vi. db.collection.find(<query>, <projection>)

If you need to find some specifie fields of a document in à collection, then you can make
use of this command. Example:
db.books.find({"title":"Treasure Island"}, {title:true, category:true,
_id:false})

vii. db.collection.update(<query>. <update> )

If you need to remove certain in an existing document, by matching a query then you can
make use of this command. Example:
db. books.update({ title: "Teasure Island"). {$unset : { category: "" }})

viii. db.collection.update(<query>. <update> )

If you need to update some specific fields of a document that match the given query, then
make use of this command. Example:
db.books.update({title:"Treasure Island"},($set:{ category: "Adventure Fiction"}})

ix. db.collection.remove(<query>, {justOne:true))

If in a certain situation, you need to delete a single document that matches your query then
use his command. Example:
db.books.remove({ title: "Treasure Island" }, { justOne:true })

x. db.collection.update(<query>, <update>, {multi:true})

If you need to delete certain fields of all the documents that match your query, then use
this command. Example:
db.books.update({category:"Fiction"},{$unset:{ category:""}, {multi:true})

xi. db.collection.remove({})
If you need to delete all the documents in a collection, irrespective if they match your
query or not, then use this command. Example: db.books.remove({ })

xii. db.collection.remove(<query>)
If you need to delete all the documents that match a certain query, then make use of this
command. Example: db.books.remove({ "category" : "Fiction"})
 WEB X.0 HANDY NOTES
12. Features of MongoDB

 Support ad hoc queries.

 We can index any field in a document.
 MongoDB supports Master Slave replication.
 MongoDB can run over multiple servers.
 It has an automatic load balancing configuration because of data placed in shards.
 Supports map reduce and aggregation tools.
 Uses JavaScript instead of Procedures.
 It is a schema-less database written in C++.
 Provides high performance.
 Stores files of any size easily without complicating your stack.
 Easy to administer in the case of failures.

13. REST API

 Representational State Transfer (REST) is an architectural style that defines a set of

constraints to be used for creating web services.
 REST API is a way of accessing web services in a simple and flexible way without having
any processing.
 REST technology is generally preferred to the more robust Simple Object Access
Protocol (SOAP) technology because REST uses less bandwidth, simple and flexible
making it more suitable for internet usage.
 It is used to fetch or give some information from a web service. All communication done
via REST API uses only HTTP request.
Working:
 A request is sent from client to server in the form of a web URL as HTTP GET or POST
or PUT or DELETE request.
 After that, a response comes back from the server in the form of a resource which can be
anything like HTML, XML, Image, or JSON. But now JSON is the most popular format
being used in Web Services.

 In HTTP there are five methods that are commonly used in a REST-based Architecture
i.e., POST, GET, PUT, PATCH, and DELETE. These correspond to create, read, update,
and delete (or CRUD) operations respectively.
 WEB X.0 HANDY NOTES
 GET: The HTTP GET method is used to read (or retrieve) a representation of a resource.
In the safe path, GET returns a representation in XML or JSON and an HTTP response
code of 200 (OK). In an error case, it most often returns a 404 (NOT FOUND) or 400
(BAD REQUEST).
 POST: The POST verb is most often utilized to create new resources. In particular, it’s
used to create subordinate resources. That is, subordinate to some other (e.g. parent)
resource. On successful creation, return HTTP status 201, returning a Location header with
a link to the newly-created resource with the 201 HTTP status.
 PUT: It is used for updating the capabilities. However, PUT can also be used to create a
resource in the case where the resource ID is chosen by the client instead of by the server.
 PATCH: It is used to modify capabilities. The PATCH request only needs to contain the
changes to the resource, not the complete resource.
 DELETE: It is used to delete a resource identified by a URI. On successful deletion, return
HTTP status 200 (OK) along with a response body.

14. Features of Flask

 Development server and debugger  100% WSGI 1.0 compliant

 Integrated support for unit testing  Unicode-based
 RESTful request dispatching  Complete documentation
 Uses Jinja templating  Google App Engine compatibility
 Support for secure cookies (client  Extensions available to extend
side sessions) functionality

15. Dynamic URL building in Flask

 When creating an application, it’s quite cumbersome to hard-code each URL. A better
way to resolve this problem is through building Dynamic URLs.
 Dynamic Routing is the process of getting dynamic data(variable names) in the URL and
then using it.
 We can build dynamic URLs by using variables in the URL. To add variables to URLs,
use <var> rule. The function then receives the <var > as keyword argument.

Example: Output:
from flask import Flask
app = Flask(__name__)
@app.route('/user/<username>')
def show_user(username):
return f'Hello {username} !'
if __name__ == "__main__":
app.run(debug=True)
 WEB X.0 HANDY NOTES
 We can also use a converter to convert the variable to a specific data type. By default, it
is set to string values. To convert use <converter:variable_name> and following
converter types are supported.
 string: It is the default type and it accepts any text without a slash.
 int: It accepts positive integers.
 float: It accepts positive floating-point values.
 path: It is like a string but also accepts slashes.
 uuid: It accepts UUID strings.

Example:
from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
return 'You are at home page.'
@app.route('/allow/<int:Number>')
def allow(Number):
if Number < 25:
return f'You have been allowed to enter because your number is
{str(Number)}'
else:
return f'You are not allowed'
if __name__ == '__main__':
app.run()
Output:

Benefits of Dynamic URL Building:

 It avoids hard coding of the URLs.
 We can change the URLs dynamically instead of remembering the manually changed
hard-coded URLs.
 URL building handles the escaping of special characters and Unicode data transparently.
 The generated paths are always absolute, avoiding unexpected behavior of relative paths
in browsers.
 If your application is placed outside the URL root, for example, in /myapplication instead
of /, url_for() properly handles that for you.
 WEB X.0 HANDY NOTES
16. Flask Templates

Flask facilitates us to render the external HTML file instead of hardcoding the HTML in the view
function. Here, we can take advantage of the jinja2 template engine on which the flask is based.
Flask provides us the render_template() function which can be used to render the external HTML
file to be returned as the response from the view function.

Example:

Output:

Delimiters: Jinja2 template engine provides some delimiters which can be used in the HTML to
make it capable of dynamic data representation. The template system provides some HTML syntax
which are placeholders for variables and expressions that are replaced by their actual values when
the template is rendered. The Jinja2 template engine provides the following delimiters to escape
from the HTML.

 {% ... %} : for statements

 {{ ... }} : for expressions to print to the template output
 {# ... #} : for the comments that are not included in the template output
 # ... ## : for line statements

Example:

Output:
 WEB X.0 HANDY NOTES
17. Flask Request Object (GET, POST)

The Request, in Flask, is an object that contains all the data sent from the Client to Server. This
data can be recovered using the GET/POST Methods. POST is used when your application expects
user input to be received by command or an HTTP request, while GET gets all the information
before it even has a chance for submission.

main.py:
from flask import *
app = Flask(__name__)
@app.route('/')
def input():
return render_template('form.html')
@app.route('/passing', methods=['GET', 'POST'])
def display():
if request.method == 'POST':
result = request.form
return render_template("result.html", result=result)
if __name__ == '__main__':
app.run(debug=True)
templates/form.html:
<html>
<style>
form {
display: inline-block;
}
</style>
<body>
<h3>Hey Folks, Please Fill out this Form</h3>
<form action="/passing" method="POST">
<p>Name <input type="text" name="name" /></p>
<p>Email <input type="email" name="email" /></p>
<p>Phone Num <input type="text" name="phone" /></p>
<p><input type="submit" value="Submit" /></p>
</form>
</body>
</html>
templates/result.html:
<html>
<style>
table {
display: inline-block;
border-collapse: collapse;
}
</style>
 WEB X.0 HANDY NOTES
<body>
<p><strong>Registration Successful!</strong></p>
<table border = 1>
{% for key, value in result.items() %}
<tr>
<th> {{ key }} </th>
<td> {{ value }} </td>
</tr>
{% endfor %}
</table>
</body>
</html>
Output:

18. Flask Cookies

 Cookies track user activity to save user information in the browser as key-value pairs,
which can then be accessed whenever necessary by the developers to make a website easier
to use.
 This enhances the personal user experience on a particular website by remembering your
logins, your preferences and much more.

set_cookie( ): Using this method we can generate cookies in any application code. The
syntax for this cookies setting method:

Response.set_cookie(key, value = '', max_age = None, expires =

None, path = '/', domain = None, secure = None, httponly = False)
 key – Name of the cookie to be set.
 WEB X.0 HANDY NOTES
 value – Value of the cookie to be set.
 max_age – should be a few seconds, None (default) if the cookie should last as long as
the client’s browser session.
 expires – should be a datetime object or UNIX timestamp.
 domain – To set a cross-domain cookie.
 path – limits the cookie to given path, (default) it will span the whole domain.

Example:
from flask import Flask, request, make_response
app = Flask(__name__)
@app.route('/setcookie')
def setcookie():
resp = make_response('Setting the cookie')
resp.set_cookie('GFG','ComputerScience Portal')
return resp
app.run()

Output:

cookies.get( ): This get( ) method retrieves the cookie value stored from the user’s web browser
through the request object.

Example:
from flask import Flask, request, make_response
app = Flask(__name__)
@app.route('/getcookie')
def getcookie():
GFG = request.cookies.get('GFG')
return 'GFG is a '+ GFG
app.run()

Output:
 WEB X.0 HANDY NOTES
19. AJAX (Asynchronous JavaScript and XML)
 AJAX is a new technique for creating better, faster, and more interactive web applications
with the help of XML, HTML, CSS, and Java Script.
 Ajax uses XHTML for content, CSS for presentation, along with Document Object
Model and JavaScript for dynamic content display.
 Conventional web applications transmit information to and from the sever using
synchronous requests. It means you fill out a form, hit submit, and get directed to a new
page with new information from the server.
 With AJAX, when you hit submit, JavaScript will make a request to the server, interpret
the results, and update the current screen.
 XML is commonly used as the format for receiving server data, although any format,
including plain text, can be used.

Working of Ajax:
i. User sends a request from the UI and a javascript call goes to XMLHttpRequest
object.
ii. HTTP Request is sent to the server by XMLHttpRequest object.
iii. Server interacts with the database using JSP, PHP, Servlet, ASP.net etc.
iv. Data is retrieved.
v. Server sends XML data or JSON data to the XMLHttpRequest callback function.
vi. HTML and CSS data is displayed on the browser.

Methods used by XMLHttpRequest in AJAX

Method Description
new XMLHttpRequest() Creates a new XMLHttpRequest object
abort() Cancels the current request
getAllResponseHeaders() Returns header information
 WEB X.0 HANDY NOTES
getResponseHeader() Returns specific header information
open(method, url, async, user, psw) Specifies the request
method: the request type GET or POST
url: the file location
async: true (asynchronous) or false (synchronous)
user: optional user name
psw: optional password
send() Sends the request to the server
Used for GET requests
send(string) Sends the request to the server.
Used for POST requests
setRequestHeader() Adds a label/value pair to the header to be sent

Example:

Output:

Standards used by AJAX

 Browser-based presentation using HTML and Cascading Style Sheets (CSS).
 Data is stored in XML format and fetched from the server.
 Behind-the-scenes data fetches using XMLHttpRequest objects in the browser.
 JavaScript to make everything happen.
 WEB X.0 HANDY NOTES
20. Rich Internet Applications (RIA)
 RIAs are web applications that have most of the characteristics of desktop applications,
typically delivered through web-browser plug-ins or via sandboxes or virtual machines.
 RIAs have always been about the UI, enhancing end-user experience in different ways.
 RIAs can run faster and be more engaging. They can offer users a better visual
experience, better accessibility, usability and more interactivity than traditional browser
applications that use only HTML and HTTP.
 A RIA can perform computation on both the client side and server side. User Interface,
its related activity and capability on the client side and the data manipulation and
operation on the application server side.
 RIA is developed using various technologies such as Java, Silverlight, JavaFX,
JavaScript, REST/WS etc.

Characteristics of RIA

 Performance: RIAs can often perform better than traditional applications on the basis of
the characteristics of network and applications in terms of UI responsiveness. Smoother
visual transitions and animations are key aspects of any RIA.
 Offline use: When connectivity is unavailable, it might still be possible to use an RIA.
An RIA platform let the user work with the application without connecting to the Internet
and synchronizing it automatically when the user goes live.
 Consistency of look and feel: With RIA tools, the UI and UX with different browsers,
devices and operating systems can be more carefully controlled and made consistent.
 Security: RIAs should be as secure as any other web application, and the framework
should be well equipped to enforce limitations appropriately when the user lacks required
privileges, especially when running within a constrained environment such as a sandbox.
 Advanced Communications: Sophisticated communications with supporting servers
through optimized network protocols can considerably enhance the user experience.
 Rapid Development: An RIA Framework should facilitate rapid development of a rich
user experience through its easy-to-use interfaces in ways that help developers.
 Direct Interaction: In RIA, users can interact directly with page elements through
editing or drag-and-drop tools. They can also do things like pan across a map or image.
 Better Feedback: Because of their ability to change parts of pages without reloading,
RIAs can provide the user with fast and accurate feedback, real-time confirmation of
actions and choices, and informative and detailed error messages.
 Improved Features: RIA allow programmers to embed various functionalities in
graphics-based web pages that look fascinating and engaging like desktop applications.
 Partial-page updating: RIAs incorporate additional technologies, such as real-time
streaming, high-performance client-side virtual machines, and local caching mechanisms
that reduce latency and increase responsiveness.