Web framework

Short description: Software framework to support the development of websites

A web framework (WF) or web application framework (WAF) is a software framework that is designed to support the development of web applications including web services, web resources, and web APIs. Web frameworks provide a standard way to build and deploy web applications on the World Wide Web. Web frameworks aim to automate the overhead associated with common activities performed in web development. For example, many web frameworks provide libraries for database access, templating frameworks, and session management, and they often promote code reuse.[1] Although they often target development of dynamic web sites, they are also applicable to static websites.[2]

## Contents

* 1 History
* 2 Types of framework architectures
* 2.1 Model–view–controller (MVC)
* 2.1.1 Push-based vs. pull-based
* 2.2 Three-tier organization
* 3 Framework applications
* 3.1 General-purpose website frameworks
* 3.1.1 Server-side
* 3.1.2 Client-side
* 3.2 Capabilities and Trade-offs in Modern Frameworks
* 4 Features
* 4.1 Web template system
* 4.2 Caching
* 4.3 Security
* 4.4 Database access, mapping and configuration
* 4.5 URL mapping
* 4.6 AJAX
* 4.7 Web services
* 4.8 Web resources
* 5 See also
* 6 References

## History

As the design of the World Wide Web was not inherently dynamic, early hypertext consisted of hand-coded HTML text files that were published on web servers. Any modifications to published pages needed to be performed by the pages' author. In 1993, the Common Gateway Interface (CGI) standard was introduced for interfacing external applications with web servers, to provide a dynamic web page that reflected user inputs.[3]

Original implementations of the CGI interface typically had adverse effects on the server load however, because each request started a separate process.[4] More recent implementations utilize persistent processes amongst other techniques to reduce the footprint in the server's resources and offer a general performance boost.

## Types of framework architectures

### Model–view–controller (MVC)

Many frameworks follow the MVC architectural pattern to separate the data model into business rules (the "controller") and the user interface (the "view"). This is generally considered a good practice as it modularizes code, promotes code reuse, and allows multiple interfaces to be applied. In web applications, this permits different views to be presented, for example serving different web pages for mobile vs. desktop browsers, or providing machine-readable web service interfaces.

#### Push-based vs. pull-based

Most MVC frameworks follow a push-based architecture also called "action-based". These frameworks use actions that do the required processing, and then "push" the data to the view layer to render the results.[5] An alternative to this is pull-based architecture, sometimes also called "component-based". These frameworks start with the view layer, which can then "pull" results from multiple controllers as needed. In this architecture, multiple controllers can be involved with a single view.

### Three-tier organization

In three-tier organization, applications are structured around three physical tiers: client, application, and database.[6][7][8][9] The database is normally an RDBMS. The application contains the business logic, running on a server and communicates with the client using HTTP.[10] The client on web applications is a web browser that runs HTML generated by the application layer.[11][12] The term should not be confused with MVC, where, unlike in three-tier architecture, it is considered a good practice to keep business logic away from the controller, the "middle layer".[13][14]

## Framework applications

Frameworks are built to support the construction of internet applications based on a single programming language, ranging in focus from general purpose tools such as Zend Framework and Ruby on Rails, which augment the capabilities of a specific language, to native-language programmable packages built around a specific user application, such as content management systems (CMS), some mobile development tools and some portal tools.[15]

### General-purpose website frameworks

Server-side page changes typically require that the page be refreshed, but allow any language to be used and more computing power to be utilized. Client-side changes allow the page to be updated in small chunks which feels like a desktop application, but are limited to JavaScript and run in the user's browser, which may have limited computing power. Some mix of the two is typically used.[16] Applications which make heavy use of JavaScript and only refresh parts of the page, are called single-page applications and typically make use of a client-side JavaScript web framework to organize the code.

#### Server-side

* Apache Wicket
* ASP.NET Core
* CakePHP
* Catalyst
* CodeIgniter
* CppCMS
* Django
* Express.js
* Flask
* FastAPI
* Grails
* Laravel
* Mojolicious
* Pop PHP Framework
* Phoenix
* Ruby on Rails
* Sails.js
* Seaside
* Symfony
* Spring MVC
* Wt (web toolkit)
* Yii
* Zend Framework

#### Client-side

Examples include Backbone.js, AngularJS, Angular, Ember.js, ReactJS, jQuery UI, Svelte, and Vue.js.[17]

### Capabilities and Trade-offs in Modern Frameworks

JavaScript-based web application frameworks, such as React and Vue, provide extensive capabilities but come with associated trade-offs. These frameworks often extend or enhance features available through native web technologies, such as routing, component-based development, and state management. While native web standards, including Web Components, modern JavaScript APIs like Fetch and ES Modules, and browser capabilities like Shadow DOM, have advanced significantly, frameworks remain widely used for their ability to enhance developer productivity, offer structured patterns for large-scale applications, simplify handling edge cases, and provide tools for performance optimization.[18][19][20]

Frameworks can introduce abstraction layers that may contribute to performance overhead, larger bundle sizes, and increased complexity. Modern frameworks, such as React 18 and Vue 3, address these challenges with features like concurrent rendering, tree-shaking, and selective hydration. While these advancements improve rendering efficiency and resource management, their benefits depend on the specific application and implementation context. Lightweight frameworks, such as Svelte and Preact, take different architectural approaches, with Svelte eliminating the virtual DOM entirely in favor of compiling components to efficient JavaScript code, and Preact offering a minimal, compatible alternative to React. Framework choice depends on an application’s requirements, including the team’s expertise, performance goals, and development priorities.[18][19][20]

A newer category of web frameworks, including enhance.dev, Astro, and Fresh, leverages native web standards while minimizing abstractions and development tooling.[21][22][23] These solutions emphasize progressive enhancement, server-side rendering, and optimizing performance. Astro renders static HTML by default while hydrating only interactive parts. Fresh focuses on server-side rendering with zero runtime overhead. Enhance.dev prioritizes progressive enhancement patterns using Web Components. While these tools reduce reliance on client-side JavaScript by shifting logic to build-time or server-side execution, they still use JavaScript where necessary for interactivity. This approach makes them particularly suitable for performance-critical and content-focused applications.[18][19][20]

## Features

Frameworks typically set the control flow of a program and allow the user of the framework to "hook into" that flow by exposing various events.[24] This "inversion of control" design pattern is considered to be a defining principle of a framework, and benefits the code by enforcing a common flow for a team which everyone can customize in similar ways.[24] For example, some popular "microframeworks" such as Ruby's Sinatra (which inspired Express.js) allow for "middleware" hooks prior to and after HTTP requests. These middleware functions can be anything, and allow the user to define logging, authentication and session management, and redirecting.[25]

### Web template system

### Caching

### Security

### Database access, mapping and configuration

Many web frameworks create a unified API to a database backend, enabling web applications to work with a variety of databases with no code changes, and allowing programmers to work with higher-level concepts. Additionally, some object-oriented frameworks contain mapping tools to provide object-relational mapping, which maps objects to tuples.[26]

Some frameworks minimize web application configuration through the use of introspection and/or following well-known conventions. For example, many Java frameworks use Hibernate as a persistence layer, which can generate a database schema at runtime capable of persisting the necessary information. This allows the application designer to design business objects without needing to explicitly define a database schema. Frameworks such as Ruby on Rails can also work in reverse, that is, define properties of model objects at runtime based on a database schema.[26]

Other features web frameworks may provide include transactional support[27] and database migration tools.[26]

### URL mapping

See also: Front controller and URL redirection

### AJAX

Ajax, shorthand for "Asynchronous JavaScript and XML", is a web development technique for creating web applications. The intent is to make web pages feel more responsive by exchanging small amounts of data with the server behind the scenes, so that the entire web page does not have to be reloaded each time the user requests a change. This is intended to increase a web page's interactivity, speed, maintainability, and usability.[28]

### Web services

Some frameworks provide tools for creating and providing web services. These utilities may offer similar tools as the rest of the web application.[29]

### Web resources

## See also

* CSS framework (for frontend)
* Comparison of JavaScript-based web frameworks (client-side, for frontend)
* Comparison of server-side web frameworks (for backend)
* Application server
* Application framework
* Application security
* Convention over configuration
* Don't repeat yourself (DRY)
* List of web service frameworks
* Rich web application (obsolete)
* List of rich web application frameworks
* Solution stack

## References

1. ↑ Multiple (wiki). "Web application framework". http://docforge.com/wiki/Web_application_framework.
2. ↑ "Top Open-Source Static Site Generators". https://www.staticgen.com/.
3. ↑ "CGI: Common Gateway Interface". http://hoohoo.ncsa.uiuc.edu/cgi/intro.html.
4. ↑ "CGI" (in en-us). https://www.ibm.com/docs/en/i/7.4?topic=functionality-cgi.
5. ↑ Thomson, Kris (2003-10-29). "Clarification on MVC= Pull and MVC Push". https://www.theserverside.com/discussions/thread/22143.html.
6. ↑ Microsoft. "Three-tiered distribution". http://msdn.microsoft.com/en-us/library/ff647546.aspx.
7. ↑ Oracle. "clustering_concepts_10en". http://download.oracle.com/docs/cd/E10316_01/cs/cs_doc_10/documentation/integrator/clustering_concepts_10en.pdf.
8. ↑ Robert R. Perkoski. "Introduction to Web Development". http://www.sis.pitt.edu/~perkoski/is1092/slides/chapter01.ppt.
9. ↑ IBM. "Using Client Access Express in a three tier environment". http://publib.boulder.ibm.com/html/as400/v5r1/ic2933/index.htm?info/rzaii/rzaiithreetier.htm.
10. ↑ Oracle. "Understanding the Three-Tier Architecture". http://download.oracle.com/docs/cd/B25221_05/web.1013/b13593/undtldev010.htm.
11. ↑ Microsoft. "Pragmatic Architecture: Layering". http://msdn.microsoft.com/en-us/library/aa905336.aspx.
12. ↑ Arokia. "3-Tier Web Architecture". http://www.arokiait.com/3-tire-web-architechture.htm.
13. ↑ "ASP.NET MVC Controller Best Practices". http://www.arrangeactassert.com/asp-net-mvc-controller-best-practices-–-skinny-controllers/.
14. ↑ Jamis Buck. "Skinny Controller, Fat Model". http://weblog.jamisbuck.org/2006/10/18/skinny-controller-fat-model.
15. ↑ "Getting Started With Web Frameworks" (in en). Wired Magazine. https://www.wired.com/2010/02/get_started_with_web_frameworks/.
16. ↑ KLIMUSHYN, Mel (6 April 2015). "Web Application Architecture – Client-Side vs. Server-Side". https://spin.atomicobject.com/2015/04/06/web-app-client-side-server-side/.
17. ↑ "AngularJS vs. Backbone.js vs. Ember.js" (in en-US). https://www.airpair.com/js/javascript-framework-comparison.
18. ↑ 18.0 18.1 18.2 Uzayr, Sufyan bin; Cloud, Nicholas; Ambler, Tim (November 2019). JavaScript Frameworks for Modern Web Development: The Essential Frameworks, Libraries, and Tools to Learn Right Now. Apress. ISBN 978-1484249949.
19. ↑ 19.0 19.1 19.2 Rojas, Carlos (13 November 2020). Building Native Web Components: Front-End Development with Polymer and Vue.js. Apress. ISBN 978-1484259047.
20. ↑ 20.0 20.1 20.2 Hands-On JavaScript High Performance: Build faster web apps using Node.js, Svelte.js, and WebAssembly. ISBN 978-1838821098.
21. ↑ "Enhance". https://github.com/enhance-dev.
22. ↑ "Astro framework". https://github.com/withastro/astro.
23. ↑ "Fresh". https://github.com/denoland/fresh.
24. ↑ 24.0 24.1 Fowler, Martin. "bliki: InversionOfControl". http://martinfowler.com/bliki/InversionOfControl.html.
25. ↑ Xue, Qiang. "Capital One Engineering – Philosophies that Shaped Successful Frameworks". http://www.capitalone.io/blog/successful-framework-philosophies/.
26. ↑ 26.0 26.1 26.2 "Active Record Basics". https://guides.rubyonrails.org/active_record_basics.html. "Object Relational Mapping, commonly referred to as its abbreviation ORM, is a technique that connects the rich objects of an application to tables in a relational database management system...Active Record automatically creates methods to allow an application to read and manipulate data stored within its tables."
27. ↑ "Active Record Transactions". https://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html.
28. ↑ "create site with ajax webplano". https://webplano.com.
29. ↑ Maximilien, E. M. (2006). "Tutorial 4: Web Services on Rails: Using Ruby and Rails for Web Services Development and Mashups". 2006 IEEE International Conference on Web Services (ICWS'06). pp. xliii. doi:10.1109/ICWS.2006.139. ISBN 0-7695-2669-1.

* v
* t
* e

Web frameworks

* Comparison

C++|

* CppCMS
* Wt

CLI|

* ASP.NET
* Core
* AJAX
* Dynamic Data
* MVC
* Razor
* Web Forms
* DNN
* BFC
* MonoRail
* OpenRasta
* Umbraco
* WebSharper

ColdFusion|

* CFWheels
* ColdBox Platform
* ColdSpring
* Fusebox
* Model-Glue

Common Lisp|

* Caveman2
* CL-HTTP
* Weblocks

Haskell|

* Yesod
* Snap

Java|

* AppFuse
* Flexive
* Grails
* GWT
* ICEfaces
* ItsNat
* JavaServer Faces
* JHipster
* Jspx
* JWt
* OpenXava
* Play
* Remote Application Platform
* RIFE
* Seam
* Sling
* Spring
* Stripes
* Struts
* Tapestry
* Vaadin
* Vert.x
* WebWork
* Wicket
* WaveMaker
* ZK

JavaScript|

* Angular/AngularJS
* Backbone.js
* Chaplin.js
* Closure
* Dojo Toolkit
* Ember.js
* Express.js
* Ext JS
* jQuery
* Knockout.js
* Meteor
* MooTools
* Node.js
* OpenUI5
* Prototype
* React
* Rico
* script.aculo.us
* Sencha Touch
* SproutCore
* Svelte
* Vue.js
* Wakanda

Perl|

* Catalyst
* Dancer
* Mason
* Maypole
* Mojolicious
* WebGUI

PHP|

* CakePHP
* CodeIgniter
* Drupal
* Fat-Free
* FuelPHP
* Flow
* Grav
* Gyroscope
* Horde
* Joomla
* Kohana
* Laravel
* Lithium
* Midgard
* MODX
* Nette
* Phalcon
* PHP-Fusion
* Pop PHP
* PRADO
* ProcessWire
* Qcodo
* Silex
* SilverStripe
* Symfony
* TYPO3
* WordPress
* XOOPS
* Yii
* Zend Framework

Python|

* BlueBream
* CherryPy
* Django
* Flask
* Grok
* Nevow
* Pyjs
* Pylons
* Pyramid
* Quixote
* TACTIC
* Tornado
* TurboGears
* web2py
* Webware
* Zope 2
* more...

Ruby|

* Camping
* Merb
* Padrino
* Ruby on Rails
* Sinatra

Scala|

* Lift
* Play
* Scalatra

Smalltalk|

* AIDA/Web
* Seaside

Other languages|

* Vibe.d (D)
* Application Express (PL/SQL)
* Grails (Groovy)
* Kepler (Lua)
* OpenACS (Tcl)
* Phoenix (Elixir)
* SproutCore (JavaScript-Ruby)
* Yaws (Erlang)

* v
* t
* e

Web interfaces

Server-side|

| Protocols|

* HTTP
* CGI
* SCGI
* FCGI
* AJP
* WSRP
* WebSocket

|

Server APIs|

* C NSAPI
* C ASAPI
* C ISAPI
* COM ASP
* Java servlet
* container
* CLI OWIN
* ASP.NET Handler
* Python WSGI
* Ruby Rack
* JavaScript JSGI
* Perl PSGI
* Lua WSAPI
* Portlet
* container

Apache modules|

* mod include
* mod jk
* mod lisp
* mod mono
* mod parrot
* mod perl
* mod php
* mod proxy
* mod python
* mod wsgi
* mod ruby
* Phusion Passenger

Topics|

* Web resource vs. Web service
* Open API
* Webhook
* Application server
* comparison
* Scripting

Client-side|

| Browser APIs|

* C NPAPI
* LiveConnect
* XPConnect
* C NPRuntime
* C PPAPI
* NaCl
* ActiveX
* BHO
* XBAP

|

Web APIs|

| W3C|

* Audio
* Canvas
* CORS
* DOM
* DOM events
* EME
* File
* Geolocation
* IndexedDB
* MSE
* SSE
* SVG
* Video
* WebAuthn
* WebRTC
* WebSocket
* Web messaging
* Web storage
* Web worker
* XMLHttpRequest
* WebAssembly

|

Khronos|

* WebCL
* WebGL

Others|

* Gears
* Web SQL Database (formerly W3C)
* WebUSB

Topics|

* Ajax and Remote scripting vs. DHTML
* Mashup
* Web IDL
* Scripting

Topics|

* Dynamic web page
* Web standards
* Rich web application
* Web API security
* Web application
* Web framework

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Web framework. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Software:Web_framework&oldid=4344842"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template