Dex: /* Applications Demystified */

2026-08-13T08:57:23Z

Applications Demystified

← Older revision		Revision as of 08:57, 13 August 2026
Line 1:		Line 1:
	~~= Applications Demystified =~~

	'''Summary:'''		'''Summary:'''
	Applications have existed for as long as computers have been capable of running software, yet the term ''application'' has become increasingly ambiguous. Today an application may be a traditional executable, a web site that behaves like a desktop program, a mobile app installed from a store, a Progressive Web App (PWA), or a hybrid solution combining several technologies.		Applications have existed for as long as computers have been capable of running software, yet the term ''application'' has become increasingly ambiguous. Today an application may be a traditional executable, a web site that behaves like a desktop program, a mobile app installed from a store, a Progressive Web App (PWA), or a hybrid solution combining several technologies.

Dex: Created page with "= Applications Demystified = '''Summary:''' Applications have existed for as long as computers have been capable of running software, yet the term ''application'' has become increasingly ambiguous. Today an application may be a traditional executable, a web site that behaves like a desktop program, a mobile app installed from a store, a Progressive Web App (PWA), or a hybrid solution combining several technologies. This article explores the major application delivery m..."

2026-08-13T08:57:04Z

Created page with "= Applications Demystified = '''Summary:''' Applications have existed for as long as computers have been capable of running software, yet the term ''application'' has become increasingly ambiguous. Today an application may be a traditional executable, a web site that behaves like a desktop program, a mobile app installed from a store, a Progressive Web App (PWA), or a hybrid solution combining several technologies. This article explores the major application delivery m..."

New page

= Applications Demystified =

'''Summary:'''
Applications have existed for as long as computers have been capable of running software, yet the term ''application'' has become increasingly ambiguous. Today an application may be a traditional executable, a web site that behaves like a desktop program, a mobile app installed from a store, a Progressive Web App (PWA), or a hybrid solution combining several technologies.

This article explores the major application delivery mechanisms, explains how they differ, and demonstrates that most solutions ultimately consist of the same building blocks: code, a user interface, a runtime environment, and a method of delivery.

== Context ==

The software industry often introduces new terminology to describe evolving approaches to application delivery.

Terms such as:

* Native Application
* Web Application
* Single Page Application (SPA)
* Progressive Web App (PWA)
* Hybrid Application
* Widget
* Cloud Application
* Software as a Service (SaaS)

are frequently used interchangeably despite referring to very different concepts.

In reality, most application technologies attempt to solve the same challenge:

<blockquote>
How do we deliver software functionality to users in a way that is efficient, maintainable, portable, and user-friendly?
</blockquote>

Understanding the evolution of application delivery helps architects and developers make informed design decisions rather than simply following current trends.

== What Is An Application? ==

At its simplest, an application consists of four elements:

<pre>
Application
│
├── User Interface
├── Business Logic
├── Data
└── Runtime Environment
</pre>

The runtime environment provides the services the application requires to operate.

Examples include:

* Windows
* Linux
* macOS
* Android
* iOS
* Java Runtime Environment (JRE)
* .NET Runtime
* Web Browser

Different application technologies primarily differ in the runtime they target.

== A Taxonomy of Applications ==

<pre>
Applications
│
├── Native Applications
│ ├── Windows
│ ├── macOS
│ ├── Linux
│ ├── Android
│ └── iOS
│
├── Web-Based Applications
│ ├── Traditional Web Apps
│ ├── SPAs
│ ├── PWAs
│ └── SaaS Platforms
│
├── Hybrid Applications
│ ├── Electron
│ ├── Cordova
│ ├── Capacitor
│ └── MAUI Hybrid
│
└── Historical Technologies
├── HTA
├── Java Applets
├── Widgets
├── AIR
└── Silverlight
</pre>

== Native Applications ==

A native application is compiled specifically for a particular operating system and executes directly against that platform's APIs.

=== Characteristics ===

* Direct access to operating system functionality
* High performance
* Deep platform integration
* Platform-specific development tools
* Platform-specific deployment mechanisms

=== Examples ===

{| class="wikitable"
! Platform
! Typical Technologies
|-
| Windows
| Win32, MFC, .NET, WinUI
|-
| macOS
| Cocoa, Swift
|-
| Linux
| GTK, Qt
|-
| Android
| Kotlin, Java
|-
| iOS
| Swift, Objective-C
|}

=== Advantages ===

* Excellent performance
* Rich operating system integration
* Full access to device capabilities

=== Disadvantages ===

* Multiple codebases may be required
* Higher development and maintenance costs
* Platform-specific expertise required

== Web-Based Applications ==

Web applications execute within a web browser rather than directly on the operating system.

Historically, a web application was little more than a website capable of processing user input. Modern web applications can be remarkably sophisticated and often rival desktop applications in functionality.

=== Traditional Web Applications ===

Traditional web applications generate pages on a server and return fully rendered responses to the browser.

Examples include:

* Early SharePoint sites
* Webmail systems
* Content Management Systems
* E-commerce platforms

Typical architecture:

<pre>
Browser
│
HTTP
│
Web Server
│
Database
</pre>

=== Single Page Applications (SPA) ===

Single Page Applications move much of the application logic into the browser.

Examples include:

* React applications
* Angular applications
* Vue applications

Typical architecture:

<pre>
Browser
│
├── User Interface
├── Business Logic
└── API Calls
│
▼
Backend
</pre>

This model often provides a more responsive user experience by reducing page reloads.

=== Progressive Web Applications (PWA) ===

A Progressive Web Application is a web application enhanced with browser technologies that allow it to behave more like an installed application.

Common features include:

* Offline support
* Service Workers
* Push Notifications
* Installation from the browser
* Home Screen integration

A PWA remains fundamentally a web application.

<pre>
Web Application
+
Manifest
+
Service Worker
=
Progressive Web App
</pre>

=== Software as a Service (SaaS) ===

SaaS describes a delivery model rather than a specific technology.

Examples include:

* Microsoft 365
* Salesforce
* ServiceNow
* Google Workspace

A SaaS platform may internally use:

* Traditional web applications
* SPAs
* PWAs
* Hybrid technologies

The defining characteristic is that the software is consumed as a service.

== Hybrid Applications ==

Hybrid applications attempt to bridge the gap between web technologies and native platforms.

The objective is usually:

<blockquote>
Write once, deploy everywhere.
</blockquote>

=== Electron ===

Electron combines:

<pre>
Application
+
Chromium
+
Node.js
=
Desktop Application
</pre>

Examples include:

* Visual Studio Code
* Discord
* Slack

Advantages:

* Cross-platform
* Familiar web technologies

Disadvantages:

* Large deployment size
* Significant memory usage

=== Apache Cordova ===

Cordova packages web applications inside a native mobile container.

This allows:

* HTML
* CSS
* JavaScript

to access selected device capabilities.

=== Capacitor ===

Capacitor evolved from the Cordova model and provides modern native integration for web applications.

It is commonly used with:

* Angular
* React
* Vue

=== .NET MAUI Hybrid ===

.NET MAUI Hybrid combines native desktop or mobile interfaces with embedded web technologies.

This approach permits organisations with existing web development experience to leverage their skills while still producing native deployments.

== Historical Technologies ==

Many modern application platforms are built upon ideas first explored decades ago.

=== HTML Applications (HTA) ===

HTAs were introduced by Microsoft as trusted desktop applications based on Internet Explorer technologies.

Characteristics included:

* HTML user interfaces
* JavaScript and VBScript support
* Windows integration
* Reduced browser security restrictions

An HTA can be viewed as a web application running with desktop-level trust.

=== Java Applets ===

Java Applets allowed Java applications to execute within web browsers.

Their promise was:

<pre>
Write Once
Run Anywhere
</pre>

Despite early popularity, browser support gradually disappeared due to security, performance, and usability concerns.

=== Opera Widgets and W3C Widgets ===

Widgets attempted to provide small, focused applications that could be installed independently or embedded into larger environments.

Examples included:

* Desktop widgets
* Dashboard widgets
* Mobile widgets

Many widget concepts later influenced modern application component architectures.

=== Adobe AIR ===

Adobe AIR combined:

* Flash
* HTML
* JavaScript

with desktop deployment capabilities.

AIR was particularly popular for media-rich applications before the decline of Flash technologies.

=== Microsoft Silverlight ===

Silverlight was Microsoft's browser-hosted application framework.

It provided:

* Rich user interfaces
* .NET programming
* Multimedia capabilities

Silverlight was eventually superseded by modern web standards and HTML5 technologies.

== Common Themes ==

Although application technologies vary greatly, most share a common structure:

<pre>
Application
│
▼
Runtime
│
▼
Operating System
</pre>

The primary differences are:

* Where the runtime exists
* Which APIs are exposed
* How the application is delivered
* How the application is updated

The business logic itself is often remarkably similar.

== Choosing the Right Approach ==

No application technology is universally superior.

Considerations include:

* Performance requirements
* Platform targets
* Offline requirements
* Security constraints
* Development cost
* Existing team skills
* Long-term maintainability

The best solution is often the one that balances business requirements with technical constraints rather than the newest or most fashionable technology.

== Key Takeaways ==

* An application consists of code, data, a user interface, and a runtime environment.
* Native applications execute directly against operating system APIs.
* Web applications execute within a browser.
* PWAs are enhanced web applications rather than a separate application type.
* Hybrid technologies attempt to combine the benefits of native and web approaches.
* Many modern solutions are evolutionary improvements upon ideas explored decades earlier.
* Understanding application delivery mechanisms helps architects make informed design decisions and avoid reinventing previous mistakes.

== Related Topics ==

* [[Progressive Web Applications]]
* [[Single Page Applications]]
* [[Software as a Service]]
* [[Runtime Environments]]
* [[Application Architecture]]
* [[Offline First Design]]
* [[Opera Widgets]]
* [[Microsoft HTA]]
* [[Cross Platform Development]]

Applications Demistified - Revision history

Dex: /* Applications Demystified */