Applications Demistified
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:
How do we deliver software functionality to users in a way that is efficient, maintainable, portable, and user-friendly?
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:
Application │ ├── User Interface ├── Business Logic ├── Data └── Runtime Environment
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
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
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
| 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:
Browser │ HTTP │ Web Server │ Database
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:
Browser
│
├── User Interface
├── Business Logic
└── API Calls
│
▼
Backend
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.
Web Application
+
Manifest
+
Service Worker
=
Progressive Web App
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:
Write once, deploy everywhere.
Electron
Electron combines:
Application + Chromium + Node.js = Desktop Application
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:
Write Once Run Anywhere
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:
Application
│
▼
Runtime
│
▼
Operating System
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.
