Types of Applications

1. Standalone application:
software installed in one computer and used by only one person.
For ex – Installing s/w of a Calculator, Adobe Photoshop, MS Office, AutoCAD.
Advantages:
 Faster in access.
 Secured from Data hacking and virus.
Disadvantages:
 Single user access at a time.
 Installation is required.
 End user system resources utilized.
 No data sharing
 Maintenance is tough with respect to both user and company
Architecture:
In the stand-alone application architecture, there is no question of any servers and entire
application is installed at the end user machine.

** Desktop application is just a standalone application with GUI.

2. Client Server application:

Client Server application, unlike Standalone Application, part of application is installed on
to the client system and the remaining part is installed on to the server machine.
Architecture:

Both Client and server interact with the help of network/internet.

Advantages:
Easy to access and faster in access if the bandwidth is more
Data security from data hacking and virus
Data sharing is possible
Maintenance is not so tough
Multiple users can access the application.
Disadvantages:
  Installation is still required at client’s place
 End user’s resources are utilized low
 If the server goes down no one can access the application

3. Web based application:

Any application which can be accessed through the URL is called web-based application.
In the web-based application entire software is installed at the server. Users access the
application from a browser using URL.
Architecture / Functions of web-based application:

Web based application consists of Web server, Application server and Database server.
Web server contains all the pages like images, static HTML files, JS etc
Application server contains the entire business logic written in Programs like Java and has
been uploaded in jars, ears, wars etc.
Database server Contains entire data stored in the form of tables.
Advantages of Web based applications:
1. Faster in access if the bandwidth is high
2. security from data hacking and virus
3. maintenance is easy
4. Multiple users can access the application
5. No installation is required
6. end user’s resources are not utilized
Disadvantages of Web based applications:
1. If the server goes down no one can access the application.
4. Cloud based application:
A cloud application simply refers to any software application that is deployed in a cloud
environment rather than being hosted on a local server or machine.
Advantages of Cloud based applications:
1. Cost reduction
2. reliability
3. management is easy
Disadvantages of Cloud based applications:
1. downtime
2. security
3. control

 Difference between Web-based and Cloud-based:

The difference between cloud-based and web-based apps is that all cloud apps are web-
based, but the same cannot be said for all web apps. Specifically, cloud apps utilize
multiple data centres while web apps use a single location; cloud apps have synchronized
versions for all users, while web apps treat each version as unique to a user, among
others. Web app example- static, dynamic web pages; e-commerce site etc. Cloud Apps
example- software-as-a-service, infrastructure as a service, platform as a service.
 Difference between Client-server and Web-based:
An application that runs on the client side and accesses the
remote server for information is called a client/server application whereas an application
that runs entirely on a web browser is known as a web application. The client server
always makes requests to the remote server to get some information. The user interaction
with the server is always through a user interface or application on the client side. The
user interaction in a web application is through a web browser.
A client/server application uses a two-tier architecture whereas a web application uses
multi-tier architecture.
In a client/server application, the user interaction with the server is mainly through a user
interface whereas in a web application the user interaction is through a compatible web
browser.
A client/server application lacks robustness because if a server fails, the requests cannot
be completed whereas a web application exhibits robustness.
A client/server application requires installation on the client’s machine whereas a web
application can run directly from a compatible web browser.
In a client/server model, the server may become overloaded with the increasing client
requests which results in low performance whereas multiple users can use a web
application at the same time and also deliver superior performance.
 Difference between Client-server and Cloud-based:
There is a thin line between a cloud-based application and server or web-based
application. This is because they possess a lot of similarities in terms of functionality, but
there are noteworthy differences as well.
The primary difference in cloud computing and traditional networking or hosting is the
implementation, and in one word that is “virtualization.” Virtualization allows for
extensive scalability, giving clients virtually limitless resources.

Cloud Computing Client-Server Computing 

It refers to delivery of different It refers to delivery of different services

services such as data and
programs through internet on
different servers.
It takes place on third-party servers
that is hosted by third-party hosting
companies.  
It is ability to access data anywhere
at any time by user.   which data is stored.
It is more cost effective as
compared to tradition computing as
operation and maintenance of
server is shared among several
on local server. 
It takes place on physical hard drives
and website severs.  
User can access data only on system in
 
It is less cost effective as compared to
cloud computing because one has to
buy expensive equipment’s to operate
and maintain server.  
parties that in turn reduce cost of
public services. 
It is more user-friendly as It is less user-friendly as compared to
compared to traditional computing cloud computing because data cannot
because user can have access to be accessed anywhere and if user has
data anytime anywhere using to access data in another system, then
internet.  he need to save it in external storage
medium.  
It provides more storage space and It provides less storage as compared to
servers as well as more computing cloud computing.  
power so that applications and
software run must faster and
effectively.  
It also provides scalability and It does not provide any scalability and
elasticity i.e., one can increase or elasticity.  
decrease storage capacity, server
resources, etc., according to
business needs.  
Cloud service is served by It requires own team to maintain and
provider’s support team.   monitor system that will need a lot of
time and efforts.  
Software is offered as an on- Software in purchased individually for
demand service (SaaS) that can be every user and requires to be updated
accessed through subscription periodically.
service.  

*** Coupling refers to the degree of direct knowledge that one element has of
another.
Tight coupling: In general, Tight coupling means the two classes often
change together. In other words, if A knows more than it should about the
way in which B was implemented, then A and B are tightly coupled.
Loose coupling: In simple words, loose coupling means they are mostly
independent. If the only knowledge that class A has about class B, is what
class B has exposed through its interface, then class A and class B are said
to be loosely coupled.
 DESIGN PATTERNS
What are they?
A design pattern provides a general reusable solution for the common problems
that occur in software design. The pattern typically shows relationships and
interactions between classes or objects. The idea is to speed up the development
process by providing well tested, proven development/design paradigms. Design
patterns are programming language independent strategies for solving a common
problem. That means a design pattern represents an idea, not a particular
implementation. By using design patterns, you can make your code more flexible,
reusable, and maintainable.
It’s not mandatory to always implement design patterns in your project. Design
patterns are not meant for project development. Design patterns are meant for
common problem-solving.
What is their use? / Why do we need them? / Advantages
The code we write today could be irrelevant tomorrow. And so that code should
be flexible enough so that it's not too costly to alter. Design Patterns are best
practices to cover such attribute. They are proven solutions, easily reusable,
flexible, expressive and also prevent the need for refactoring the code.
Types
1. Creational 
These design patterns are all about class instantiation or object creation,
trying to create objects in a manner suitable to the situation. The basic form
of object creation could result in design problems or added complexity to the
design. Creational design patterns solve this problem by somehow
controlling this object creation.
These patterns can be further categorized into Class-creational patterns and
object-creational patterns. While class-creation patterns use inheritance
effectively in the instantiation process, object-creation patterns use
delegation effectively to get the job done. 
Creational design patterns are the  Factory Method, Abstract Factory,
Builder, Singleton, Object Pool, and Prototype. 
 Abstract Factory
Creates an instance of several families of classes
Let’s you produce families of related objects without specifying their concrete
classes.
 Builder
Separates object construction from its representation
Let’s you construct complex objects step by step. The pattern allows you to produce
different types and representations of an object using the same construction code.
 Factory Method
Creates an instance of several derived classes
Provides an interface for creating objects in a superclass, but allows subclasses to
alter the type of objects that will be created.
 Object Pool
Avoid expensive acquisition and release of resources by recycling objects that are no
longer in use
 Prototype
A fully initialized instance to be copied or cloned
Let’s you copy existing objects without making your code dependent on their classes.
 Singleton
A class of which only a single instance can exist
Let’s you ensure that a class has only one instance, while providing a global access
point to this instance.

2. Structural 
These design patterns are about organizing different classes and objects to
form larger structures and provide new functionality. 
Structural design patterns are Adapter, Bridge, Composite, Decorator,
Facade, Flyweight, Private Class Data, and Proxy. 
Structural patterns explain how to assemble objects and classes into larger
structures while keeping these structures flexible and efficient.
 Adapter
Match interfaces of different classes
Allows objects with incompatible interfaces to collaborate.
 Bridge
Separates an object's interface from its implementation
Let’s you split a large class or a set of closely related classes into two separate
hierarchies—abstraction and implementation—which can be developed
independently of each other.
 Composite
A tree structure of simple and composite objects
Let’s you compose objects into tree structures and then work with these structures as
if they were individual objects.
 Decorator
Add responsibilities to objects dynamically
Let’s you attach new behaviours to objects by placing these objects inside special
wrapper objects that contain the behaviours.
 Facade
A single class that represents an entire subsystem
Provides a simplified interface to a library, a framework, or any other complex set of
classes.
 Flyweight
A fine-grained instance used for efficient sharing
Let’s you fit more objects into the available amount of RAM by sharing common parts
of state between multiple objects instead of keeping all of the data in each object.
Private Class Data
Restricts accessor/mutator access
 Proxy
An object representing another object
Let’s you provide a substitute or placeholder for another object. A proxy controls
access to the original object, allowing you to perform something either before or after
the request gets through to the original object.

3. Behavioural 
Behavioural patterns are about identifying common communication patterns
between objects and realizing these patterns. 
 Behavioural patterns are Chain of responsibility, Command, Interpreter,
Iterator, Mediator, Memento, Null Object, Observer, State, Strategy,
Template method, Visitor 

Behavioural design patterns are concerned with algorithms and the

assignment of responsibilities between objects.
 Chain of responsibility
A way of passing a request between a chain of objects
Let’s you pass requests along a chain of handlers. Upon receiving a request, each
handler decides either to process the request or to pass it to the next handler in the
chain.
 Command
Encapsulate a command request as an object
Turns a request into a stand-alone object that contains all information about the
request. This transformation lets you pass requests as a method argument, delay or
queue a request's execution, and support undoable operations.
 Interpreter
A way to include language elements in a program
 Iterator
Sequentially access the elements of a collection
Let’s you traverse elements of a collection without exposing its underlying
representation (list, stack, tree, etc.).
 Mediator
Defines simplified communication between classes
Let’s you reduce chaotic dependencies between objects. The pattern restricts direct
communications between the objects and forces them to collaborate only via a
mediator object.
 Memento
Capture and restore an object's internal state
Let’s you save and restore the previous state of an object without revealing the
details of its implementation.
 Null Object
Designed to act as a default value of an object
 Observer
A way of notifying change to a number of classes
Let’s you define a subscription mechanism to notify multiple objects about any events
that happen to the object they're observing.
State
Alter an object's behaviour when its state changes
Let’s an object alter its behaviour when its internal state changes. It appears as if the
object changed its class.
 Strategy
Encapsulates an algorithm inside a class
Let’s you define a family of algorithms, put each of them into a separate class, and
make their objects interchangeable.
 Template method
Defer the exact steps of an algorithm to a subclass
Defines the skeleton of an algorithm in the superclass but let’s subclasses override
specific steps of the algorithm without changing its structure.
 Visitor
Defines a new operation to a class without change
Let’s you separate algorithms from the objects on which they operate.