which javascript is also called server-side javascript
Ad rotation


-side and service-based. With server-side ad rotation, the ad is selected on the server and the corresponding HTML markup is generated and then served. Client-side ad rotation typically involves JavaScript of some sort (either straight client-side JavaScript or else AJAX calls to the server. Service-based ad rotation is similar to client-side ad rotation in that it typically involves placing a small amount of JavaScript in the web page, but the JavaScript calls against a third-party service that provides its
18775088
Quicknet


Quicknet is an Ajax framework (using XMLHttpRequest in JavaScript) designed to develop web applications or websites that use passwords to identify correct users. Using this framework, no cleartext password would be sent over the network or stored in the server. Quicknet supports multi-language, JavaScript cooperative multitasking, AJAX call, session and password management, modular structure, XML content, and JavaScript animation. It uses PHP on the server side, and JavaScript on the client side. Server-side Quicknet should run on any server with Apache 2.2
18474527
List of Ajax frameworks


This is a list of notable Ajax frameworks, used for creating web applications with a dynamic link between the client and the server. Some of the frameworks are JavaScript compilers, for generating JavaScript and Ajax that runs in the web browser client; some are pure JavaScript libraries; others are server-side frameworks that typically rely on JavaScript libraries. JavaScript frameworks are browser-side frameworks very commonly used in Ajax development. There are hundreds of JavaScript frameworks available. According to latest surveys, the most used JavaScript frameworks are: Other
15989914
Aptana


side and server-side code can be written in JavaScript. Jaxer's server-side engine is based on Mozilla Gecko, the same browser engine that is used in Firefox. The Mozilla engine allows Jaxer to provide a server-side DOM in which a page may be manipulated during server-side processing using the techniques familiar to client-side programmers. Jaxer's server-side JavaScript APIs enable database access, file system access, network communications, user sessions and other functions typical of web application servers. Jaxer also provides
2960954
AppJet


to the server-side JavaScript framework that powers AppJet applications. This is an example of a recent trend in web development, to run JavaScript on both the client and the server, allowing developers to code entire web apps in one language, instead of using a separate language for server-side and client-side scripting. The virtual machine that powers AppJet apps is based on the Java Virtual Machine, using the Rhino Javascript implementation. Scala libraries are also used. Appjet is often updated with bug-fixes, improvements,
18582084
JavaScript


page scripting to Netscape, though Web page scripting was not a new concept, as shown by the ViolaWWW Web browser. Nombas later switched to offering JavaScript instead of Cmm in their ScriptEase product and was part of the TC39 group that standardized ECMAScript. In December 1995, soon after releasing JavaScript for browsers, Netscape introduced an implementation of the language for server-side scripting with Netscape Enterprise Server. Since 1996, the IIS web-server has supported Microsoft's implementation of server-side Javascript—JScript—in ASP and .NET
9748106
JavaScript


pages. Since the mid-2000s, additional server-side JavaScript implementations have been introduced, such as Node.js in 2009. Microsoft script technologies including VBScript and JScript were released in 1996. JScript, a reverse-engineered implementation of Netscape's JavaScript, was part of Internet Explorer 3. JScript was also available for server-side scripting in Internet Information Server. Internet Explorer 3 also included Microsoft's first support for CSS and various extensions to HTML, but in each case the implementation was noticeably different from that found in Netscape Navigator at
9748107
Node.js


Node.js is an open-source, cross-platform JavaScript run-time environment that executes JavaScript code outside of a browser. Node.js lets developers use JavaScript to write command line tools and for server-side scripting—running scripts server-side to produce dynamic web page content before the page is sent to the user's web browser. Consequently, Node.js represents a "JavaScript everywhere" paradigm, unifying web application development around a single programming language, rather than different languages for server- and client-side scripts. Though codice_1 is
14565348
Isomorphic JavaScript


Isomorphic JavaScript, also known as Universal JavaScript, describes JavaScript applications which run both on the client and the server. Isomorphic JavaScript works in the context of a single-page application (SPA). In a typical SPA, most of the application logic, including routing, is encapsulated in a bundled JavaScript file that is sent to the client. Whilst this frees up the server, as it does not have to handle so many requests, it also makes the initial load slow for the client, as the entire application needs
9962585
Microsoft TypeScript


Microsoft TypeScript is an open-source programming language developed and maintained by Microsoft. It is a strict syntactical superset of JavaScript, and adds optional static typing to the language. TypeScript is designed for development of large applications and transcompiles to JavaScript. As TypeScript is a superset of JavaScript, existing JavaScript programs are also valid TypeScript programs. TypeScript may be used to develop JavaScript applications for both client-side and server-side (Node.js) execution. There are multiple options available for transcompilation. Either the default TypeScript Checker can be
2845323
JavaScript


are now embedded in many other types of host software, including server-side in web servers and databases, and in non-web programs such as word processors and PDF software, and in runtime environments that make JavaScript available for writing mobile and desktop applications, including desktop widgets. The terms "Vanilla JavaScript" and "Vanilla JS" refer to JavaScript not extended by any frameworks or additional libraries. Scripts written in Vanilla JS are plain JavaScript code. Although there are similarities between JavaScript and Java, including language name,
9748099
Aptana


for access to Java objects via the open source DWR project. Jaxer is now on GitHub. Aptana Jaxer provides a page-processing environment based on the Mozilla engine. This provides a Gecko-based DOM and SpiderMonkey JavaScript engine to allow pages to be rendered and manipulated on the server before being sent to the browser. Jaxer also provides an Ajax model for performing asynchronous requests to the server. Its client and server APIs allow such requests to be made by simply calling server-side JavaScript functions from the client. Behind the
2960955
Echo (framework)


Echo is a web application framework created by the company NextApp. The latest iteration, Echo3, allows writing applications in either server-side Java or client-side JavaScript. Server-side applications do not require developer knowledge of HTML, HTTP, or JavaScript. Client-side JavaScript-based applications do not require a server, but can communicate with one via AJAX. It is free software licensed under the terms of the Mozilla Public License (MPL). Echo originally started as a request-response web application framework that
21214124
Isomorphic JavaScript


to be sent over to the client. With Isomorphic JavaScript, when a client web page is first requested from the server, the view of the page is generated on the server, similar to server-side dynamic web pages, and sent over to the client. The client can then render the view immediately. After the initial view is rendered, the complete SPA is downloaded in the background, and subsequent actions are handled client-side. The naming of the term 'Isomorphic JavaScript' has been a matter of controversy
9962586
Document Update Markup Language


Document Update Markup Language (DUML) is an XML specification created by Brian Kardell to enable server-side logic DOM manipulation outside the context of conventional JavaScript functions. DUML supports a simpler approach to AJAX. With most current approaches, DOM manipulation is accomplished through arbitrarily complex client-side JavaScript. With the DUML approach, the browser makes a standard AJAX call to the server. Then DOM manipulation instructions (such as appending nodes, replacing nodes, etc.) are generated server-side as a DUML document, delivered to
3469479
Form (HTML)


languages include both client-side and/or server-side languages. Although any programming language can be used on the server to process a form's data, the most commonly used languages are scripting languages, which tend to have stronger string handling functionality than programming languages such as C, and also have automatic memory management which helps to prevent buffer overrun attacks. The "de facto" client-side scripting language for web sites is JavaScript. Using JavaScript on the Document Object Model (DOM) leads to the method of Dynamic HTML
20654040
Xajax


xajax is an open source PHP class library implementation of Ajax that gives developers the ability to create web-based Ajax applications using HTML, CSS, JavaScript, and PHP. Applications developed with xajax can asynchronously call server-side PHP functions and update content without reloading the page. Unlike some other Ajax frameworks, xajax is designed to allow the programmer to have no prior knowledge of JavaScript. Server-side xajax runs on any PHP 4.3.x and PHP 5.x Apache or IIS server. Client-side xajax runs on (but is
13440783
XPages


XPages is an IBM extension of Java Server Faces with a server side JavaScript runtime and the built-in NoSQL database IBM Domino. It allows data from IBM Notes and Relational Databases to be displayed to browser clients on all platforms. The programming model is based on web development languages and standards including JavaScript, Ajax, Java, the Dojo Toolkit, Server-side JavaScript and JavaServer Faces. XPages uses IBM Domino, IBM's rapid application development platform, including functionality such as the document-oriented database. By utilizing web standards
14148084
Verbosus


the Latex-Code. A preview is displayed on the side of the Latex Code. Additionally, the editor supports syntax highlighting which increases the readability as well as code completion. The connection between the web browser and server is secured by using the HTTPS protocol which provides encryption and secure identification of the server. The client side of Verbosus was developed entirely in JavaScript. In addition, it uses the Dojo Toolkit for Server communication. The integrated approach of using JavaScript-On-Demand allows the (for the user transparent)
4197116
RichFaces


write any JavaScript code by hand. By controlling everything from the server side, almost no JavaScript is needed and the page state can be maintained easily in the server. The architecture of RichFaces consists of an Ajax filter, Ajax action components, Ajax containers, and a JavaScript engine. Skinnability is a special feature of RichFaces that is used for defining common interface styles. The feature is based on XCSS technology which provides flexibility and dynamics. RichFaces provides a set of predefined skins: Skin properties, such as, generalBackgroundColor, generalLinkColor
17964296
Dynamic web page


term AJAX originally indicated the use of JavaScript. (As well as XML.) With the rise of server side JavaScript processing (e.g. NodeJS originally developed in 2009) JavaScript is also used to dynamically create pages on the server that are sent fully formed to clients. Execusite introduced the first dynamic website solution for the professional marketplace in June 1997. Execusite was acquired by Website Pros (now Web.com) in January 2000. During the bust cycle of the Dot-com bubble, the original Execusite founders bought back the company from
12072498
Cross-site scripting


all data processing on the server side. User input (including an XSS vector) would be sent to the server, and then sent back to the user as a web page. The need for an improved user experience resulted in popularity of applications that had a majority of the presentation logic (maybe written in JavaScript) working on the client-side that pulled data, on-demand, from the server using AJAX. As the JavaScript code was also processing user input and rendering it in the web page content, a
10723811
JavaScript


represent the DOM in JavaScript. The Web server is another common host environment. A JavaScript Web server would typically expose host objects representing HTTP request and response objects, which a JavaScript program could then interrogate and manipulate to dynamically generate Web pages. JavaScript is the only language that the most popular browsers share support for and has inadvertently become a target language for frameworks in other languages. The increasing speed of JavaScript engines has made the language a feasible compilation target, despite the performance limitations inherent to its dynamic nature. Below is a
9748135
Google Analytics


", in this case, called the Google Analytics Tracking Code, which is a snippet of JavaScript code that the website owner adds to every page of the website. The tracking code runs in the client browser when the client browses the page (if JavaScript is enabled in the browser) and collects visitor data and sends it to a Google data collection server as part of a request for a web beacon. The tracking code loads a larger JavaScript file from the Google web server and then sets variables with the user's account
3914594
JavaScript


as seen by the proliferation of Server-side JavaScript platforms. In January 2009, the CommonJS project was founded with the goal of specifying a common standard library mainly for JavaScript development outside the browser. With the rise of single-page applications and JavaScript-heavy sites, it is increasingly being used as a compile target for source-to-source compilers from both dynamic languages and static languages. "JavaScript" is a trademark of Oracle Corporation in the United States. It is used under license for technology invented and implemented
9748117
JavaScript


horse, although JavaScript Trojan horses are uncommon in practice. In 2015, a JavaScript-based proof-of-concept implementation of a rowhammer attack was described in a paper by security researchers. In 2017, a JavaScript-based attack via browser was demonstrated that could bypass ASLR. It's called "ASLR⊕Cache" or AnC. In addition to Web browsers and servers, JavaScript interpreters are embedded in a number of tools. Each of these applications provides its own object model that provides access to the host environment. The core JavaScript
9748150
Rhino (JavaScript engine)


1.7R1, Rhino supports Java 4 and up, and supports version 1.7 of JavaScript. Rhino converts JavaScript scripts into classes. Rhino works in both compiled and interpreted mode. It is intended to be used in server-side applications, hence there is no built-in support for the Web browser objects that are commonly associated with JavaScript. Rhino can be used as a debugger by using the Rhino shell. The JavaScript shell provides a simple way to run scripts in batch mode or within an interactive environment for exploratory programming. It
407399
Unobtrusive JavaScript


. Take, for example, a webpage where thumbnail images need JavaScript behaviours so that full-size images will appear in front of the page when the mouse is rolled over them or they are clicked. First, server-side markup should ensure that the relevant full-size image is served to users without JavaScript who click on a thumbnail. In this case the basic HTML markup may look like the following, for each thumbnail: This will work as it is without JavaScript. Unobtrusive JavaScript, in this case, during
9795844
JavaScript


information (such as the content of an e-mail message) to the server. The wider trend of Ajax programming similarly exploits this strength. A JavaScript engine (also known as JavaScript interpreter or JavaScript implementation) is an interpreter that interprets JavaScript source code and executes the script accordingly. The first JavaScript engine was created by Brendan Eich at Netscape, for the Netscape Navigator Web browser. The engine, code-named SpiderMonkey, is implemented in C. It has since been updated (in JavaScript 1.5) to conform to ECMAScript
9748133
ActiveReports


these report designer in their own Microsoft Windows and web applications to let end users create and modify reports. It also includes a client side JavaScript viewer, server-side ASP.NET web viewer, ASP.NET HTTP Handlers that export reports to HTML or PDF format without custom code and advanced PDF encryption. Latest Service Releases Standard Edition ActiveReports Designer Windows Forms Viewer Reporting Engine Includes all of the Standard Edition features, and adds the following:. End-User Report Designer ASP.NET JavaScript Viewer Web Designer Component ActiveReports Server is a scalable server platform with
14856659
Front-end web development


declarative language model) that is used to transform a static HTML page into a dynamic interface. JavaScript code can use the [Document Object Model] (DOM), provided by the HTML standard, to manipulate a web page in response to events, like user input. Using a technique called AJAX, JavaScript code can also actively retrieve content from the web (independent of the original HTML page retrieval), and also react to server-side events as well, adding a truly dynamic nature to the web page experience.
19116970
Unobtrusive JavaScript


to discriminate against people with disabilities and applies to anyone providing any service in the public, private and voluntary sectors. While a lot of effort may be put into designing and implementing a slick client-side user interface in unobtrusive JavaScript, it will not remain unobtrusive to a user without client-side scripting if they find that they cannot access published information. To meet this goal, it is often necessary to implement equivalent, albeit clunkier, server-side functionality that will be available without the use of JavaScript at all
9795843
World Wide Web


To make web pages more interactive, some web applications also use JavaScript techniques such as Ajax (asynchronous JavaScript and XML). Client-side script is delivered with the page that can make additional HTTP requests to the server, either in response to user actions such as mouse movements or clicks, or based on elapsed time. The server's responses are used to modify the current page rather than creating a new page with each response, so the server needs only to provide limited, incremental information. Multiple Ajax requests can be
14607566
V8 (JavaScript engine)


V8 is an open-source JavaScript engine developed by The Chromium Project for Google Chrome and Chromium web browsers. The project’s creator is Lars Bak. The first version of the V8 engine was released at the same time as the first version of Chrome: September 2, 2008. It has also been used in Couchbase, MongoDB and Node.js that are used server-side. V8 compiles JavaScript directly to native machine code before executing it, instead of more traditional techniques such as interpreting bytecode or compiling the whole program to machine
4787072
Mustache (template system)


ex. CakePHP). The support in JavaScript includes both client-side programming with many JavaScript libraries and Ajax frameworks such as jQuery, Dojo and YUI, as well as server-side JavaScript using Node.js and CommonJS. There are many "Mustache Engine" implementations available, and all of them meet a common specification (see external links) — that for final users results in the common syntax. As of March 2011, the last SPEC_VERSION was 1.1.2. All "Mustache Engines", in the v1.X architecture, have a
19990340
Single-page application


e.g., XML or JSON), or new HTML being returned. In the case where HTML is returned by the server, JavaScript on the client updates a partial area of the DOM (Document Object Model). When raw data is returned, often a client-side JavaScript XML / (XSL) process (and in the case of JSON a template) is used to translate the raw data into HTML, which is then used to update a partial area of the DOM. An SPA moves logic from the server to
21008459
JavaScript


or included from HTML pages and interact with the Document Object Model (DOM) of the page. Some simple examples of this usage are: JavaScript code can run locally in a user's browser (rather than on a remote server), increasing the application's overall responsiveness to user actions. JavaScript code can also detect user actions that HTML alone cannot, such as individual keystrokes. Applications such as Gmail take advantage of this: much of the user-interface logic is written in JavaScript, and JavaScript dispatches requests for
9748132
Form (HTML)


element. A tree view could also be mimicked through nested tables or, more semantically appropriately, nested lists. In both cases, a server-side process is responsible for processing the information, while JavaScript handles the user-interaction. Implementations of these interface elements are available through JavaScript libraries such as jQuery. HTML 4 introduced the codice_2 tag, which is intended to represent a caption in a user interface, and can be associated with a specific form control by specifying the codice_3 attribute of the control in the label tag's
20654035
Google+


, experts and other influencers. According to Joseph Smarr, one of the Google+ team's technical leads, Google+ is a typical Google web application: it uses Java servlets for the server code and JavaScript for the browser-side of the UI, largely built with Google's Closure framework, including the JavaScript compiler and the template system. They use the HTML5 History API to maintain good-looking URLs in modern browsers despite the AJAX app. To achieve fast response times Google often renders the Closure templates on the server side before
20279490
Server-side scripting


Server-side scripting is a technique used in web development which involves employing scripts on a web server which produce a response customized for each user's (client's) request to the website. The alternative is for the web server itself to deliver a static web page. Scripts can be written in any of a number of server-side scripting languages that are available (see below). Server-side scripting is distinguished from client-side scripting where embedded scripts, such as JavaScript, are run client-side in
9947256
JavaScript


their JScript .NET language. Over time it was clear that Microsoft had no intention of cooperating or implementing proper JavaScript in Internet Explorer, even though they had no competing proposal and they had a partial (and diverged at this point) implementation on the .NET server side. So by 2003, the original ECMAScript 4 work was mothballed. The next major event was in 2005, with two major happenings in JavaScript's history. First, Brendan Eich and Mozilla rejoined Ecma International as a not-for-profit member and work started
9748111
Jargon Software


all mobile devices, running any flavor of MS Windows. The development tool creates XML files that define the client-side user interface (UI), with embedded JavaScript for client-side logic. Developers create applications that directly manipulate individual client components via a server's responses to HTTP requests or via embedded JavaScript functions that are linked to UI events. The deployment engine runs on various mobile devices, including handhelds, tablets, and laptop PCs. It interprets and executes XML applications that are downloaded from a host server (similar
17916877
Pagination


every web application to divide returned data and display it on multiple pages. Pagination also includes the logic of preparing and displaying the links to the various pages. Pagination can be handled client-side or server-side. Server-side pagination is more common. Client-side pagination can be used when there are very few records to be accessed, in which case all records can be returned, and the client can use JavaScript to view the separate pages. By using AJAX, hybrid server/client-side pagination can
9518723
NPAPI


programming interface (API) for invoking native C++ calls from Java, called JRI. The JRI technology has long since been supplanted by JNI. XPConnect (Cross Platform Connect) is a technology which enables simple interoperation between XPCOM and JavaScript. XPConnect allows JavaScript objects to transparently access and manipulate XPCOM objects. It also enables JavaScript objects to present XPCOM compliant interfaces to be called by XPCOM objects. A main goal is that objects communicating from either side of an XPCOM style interface should not generally need to know or care about the implementation
8352713
Web-based SSH


Web-based SSH makes it possible to access Secure Shell (SSH) servers through standard web browsers. Respective clients are typically based on JavaScript/Ajax or JavaScript/WebSockets, and, if they work together with an Ajax/WebSocket-to-SSH proxy, can be used to access SSH servers from behind a firewall or proxy that allows HTTP traffic but does not allow SSH traffic. Web-based SSH clients basically consist of the following parts: Web-based SSH servers that utilize client-side terminal emulation typically
14388373
Synchronet


for DOS to run on the Unix-like platforms. Around the same time, Swindell started embedding the SpiderMonkey JavaScript engine into Synchronet with an eye towards replacing the aging BAJA language which was used for most BBS customizations. While the BBS still requires BAJA scripts, much can be done with JavaScript. A socket object was added to the JavaScript engine and a "Services" server created which allowed simple TCP/IP services to be written easily. TCP/IP services written in JavaScript bundled with Synchronet include finger, gopher,
3102287
Linux Foundation


" JS Foundation (previously known as jQuery Foundation, and according to by-laws JSFoundation, Inc) aims to help development and adoption of important JavaScript technology. The foundation works to facilitate collaboration within the JavaScript development community to "foster JavaScript applications and server-side projects by providing best practices and policies." In 2016, the Dojo Foundation merged with jQuery Foundation and subsequently rebranded itself as JS Foundation and became a Linux Foundation project. Notable projects supported by the JS Foundation include Node-RED, Appium, jQuery,
7444719
Mojito (framework)


Mojito applications mainly consist of two components: In Mojito, both server and "client" side scripting is done in JavaScript, allowing it to run on both client and server thereby breaking the "front-end back-end barrier." It has both client and server runtimes. This block houses operations needed by server side components. Services include: Routing rules, HTTP Server, config loader and disk-based loader. This block houses operations called upon while running client sides components. Services include local storage/cache access
5632424
SignalR


's and server's best available transport. SignalR takes advantage of WebSocket, an HTML5 API that enables bi-directional communication between the browser and server. SignalR will use WebSockets under the covers when it's available, and gracefully fall back to other techniques and technologies when it isn't, while the application code remains the same. SignalR also provides a simple, high-level API for doing server-to-client RPC (call JavaScript functions in a client's browser from server-side .NET code) in an ASP.NET
4796344
QUnit


QUnit is a JavaScript unit testing framework. Originally developed for testing jQuery, jQuery UI and jQuery Mobile, it is a generic framework for testing any JavaScript code. It supports client-side environments in web browsers, and server-side (e.g. Node.js). QUnit's assertion methods follow the CommonJS unit testing specification, which itself was influenced to some degree by QUnit. QUnit was originally developed by John Resig as part of jQuery. In 2008 it was extracted from the jQuery unit test source code to form its own project
1303395
PureScript


PureScript is a strongly-typed, purely-functional programming language that compiles to JavaScript. It can be used to develop web applications, server side apps, and also desktop applications with use of Electron. Its syntax is mostly comparable to that of Haskell. In addition, it introduces row polymorphism and extensible records. Also, contrary to Haskell, PureScript adheres to a strict evaluation strategy. PureScript was initially designed by Phil Freeman in 2013. He started to work on PureScript as various attempts to compile Haskell to JavaScript while preserving
6655549
JSON


code is an example of a client using XMLHttpRequest to request data in JSON format from a server. (The server-side programming is omitted; it must be set up to service requests to the codice_15 containing a JSON-formatted string.) JSON is intended as a data serialization format. However, its design as a non-strict subset of JavaScript can lead to the misconception that it is safe to pass JSON strings to the JavaScript function. This is not safe, due to the fact that certain valid JSON strings
18304944
JScript.Encode


JScript.Encode is a method created by Microsoft used to encode both server and Client-side JavaScript or VB Script source code in order to protect the source code from copying. JavaScript code is used for creating dynamic web content on many websites, with the source code easily viewable, so this was meant to protect the code. The encoding is a simple polyalphabetic substitution using three alphabets. You can use a command line script encoder to encode your scripts. To encode a HTML web-page file called default.htm, use the
3116481
Single-page application


exact JavaScript code to bring the client page to the new state executing DOM methods. Developers can decide which page states must be crawlable by web spiders for SEO and be able to generate the required state at load time generating plain HTML instead of JavaScript. In the case of the ItsNat framework, this is automatic because ItsNat keeps the client DOM tree in the server as a Java W3C DOM tree; rendering of this DOM tree in the server generates plain HTML at load time and JavaScript DOM actions for Ajax requests. This duality
21008470
Qooxdoo


qooxdoo is an open-source Ajax web application framework. It is an LGPL- and/or EPL-licensed client-side and server-agnostic solution, and includes support for professional JavaScript development, a graphical user interface (GUI) toolkit and high-level client-server communication. qooxdoo is entirely class-based, tries to leverage the features of object-oriented JavaScript and is based on namespaces. Most modern browsers are supported, including Gecko (Firefox, Mozilla, SeaMonkey), Presto (Opera), Trident (Internet
20169087
Pagination


be used, in which Javascript is used to request the subsequent page which is loaded and inserted into the Document Object Model via AJAX. Server-side pagination is appropriate for large data sets providing faster initial page load, accessibility for those not running Javascript, and complex view business logic. Correctly implementing pagination can be difficult. There are many different usability questions such as should "previous" and "next" links be included, how many links to pages should be displayed, and should there be a link to the first
9518724
JavaScript


in the ECMA-262 editions. The following table of explicitly versioned JavaScript versions is based on information from multiple sources. As JavaScript is the most widely supported client-side language that can run within a Web browser, it has become an intermediate language for other languages (also called "transpilers") to target. This has included both newly created languages and ports of existing languages. Some of these include: As JavaScript has unusual limitations – such as no explicit integer type, only double-precision binary floating point – languages that
9748157
Opa (programming language)


and the source code was released on GitHub in June 2011, under a GNU Affero General Public License. Later, the license changed to the MIT license for the framework part (library) and AGPL for the compiler so that applications written in Opa can be released under any license, proprietary or open source. Opa consists of a web server, a database and distributed execution engine. Code written in Opa is compiled to JavaScript using Node.js on the server side and to JavaScript using jQuery for cross-browser compatibility on the client
11948650
Enonic XP


server by default. A developer can for instance insert his own modules and code straight into the system while it is running. JavaScript unifies all the technical elements, and Enonic XP features a MVC framework where everything on the back-end can be coded with server-side JavaScript. The Enonic platform can use any template engine. The most used one, Thymeleaf, allows users to create a plain HTML5 document and use it as a view, allowing a designer to work on the HTML file, while a developer can make
17784345
Adobe ColdFusion


CFML). CFML compares to the scripting components of ASP, JSP, and PHP in purpose and features, but its tag syntax more closely resembles HTML, while its script syntax resembles JavaScript. "ColdFusion" is often used synonymously with "CFML", but there are additional CFML application servers besides ColdFusion, and ColdFusion supports programming languages other than CFML, such as server-side Actionscript and embedded scripts that can be written in a JavaScript-like language known as CFScript. Originally a product of Allaire and released on July
8449142
JsonML


, JsonML and innerHTML are quite different. InnerHTML requires all the markup in an exact form, meaning that either the server is rendering the markup, or the programmer is performing expensive string concatenations in JavaScript. JsonML uses client-side templating through JBST, which means that HTML is converted into a JavaScript template at build time. At run time, the data is supplied and DOM elements are the result. The resulting DOM elements can be inserted or replace an existing element, which innerHTML cannot easily do without creating excess DOM
9210908
Firebase


The service provides application developers an API that allows application data to be synchronized across clients and stored on Firebase's cloud. The company provides client libraries that enable integration with Android, iOS, JavaScript, Java, Objective-C, Swift and Node.js applications. The database is also accessible through a REST API and bindings for several JavaScript frameworks such as AngularJS, React, Ember.js and Backbone.js. The REST API uses the Server-Sent Events protocol, which is an API for creating HTTP connections for receiving push notifications from a server
4990270
JsRender/JsViews


JsRender/JsViews is an open-source JavaScript library for writing single-page web applications using templates and the MVVM design pattern. It is developed and maintained by Microsoft employee Boris Moore and consists of three libraries in two source files: The library evolved out of the discontinued jQuery Templates. It can also be used in server-side Javascript development using e.g. node.js, Python's Django framework or Ruby on Rails. JsRender/JsViews is hosted on GitHub and as of October 2018 a release candidate for version 1.0 is available.
10284223
Enonic XP


official Enonic Market. There are no third-party databases in Enonic XP. Instead the developers have built a distributed storage repository on top of the search engine Elasticsearch, avoiding the need to index content. The system brings together capabilities from Filesystem, NoSQL, document stores, and search in the storage technology, which automatically indexes everything put into the storage. Enonic XP supports deployment of server side JavaScript and Java applications, using the framework PurpleJS, which includes code build by Enonic. PurpleJS melds Java and JavaScript, and is
17784343
Meta refresh


both uses of meta refresh. An alternative is to send an HTTP redirection status code, such as HTTP 301 or 302. It is the preferred way to redirect a user agent to a different page. This can be achieved by a special rule in the Web server or by means of a simple script on the Web server. JavaScript is another alternative, but not recommended, because users might have disabled JavaScript in their browsers. The simplest way of JavaScript redirect using the codice_12 property of the codice_13 tag: An alternative method
18034085
Dynamic web page


The first widespread use of JavaScript was in 1997, when the language was standardized as ECMAScript and implemented in Netscape 3. The client-side content is generated on the client's computer. The web browser retrieves a page from the server, then processes the code embedded in the page (typically written in JavaScript) and displays the retrieved page's content to the user. The codice_1 property (or write command) can illustrate the client-side dynamic page generation: two distinct pages, A and B, can be regenerated
12072503
Tor Mail


.onion sites. In September 2013, the FBI admitted in a court filing in Dublin that it had taken down Freedom Hosting. The following month, details emerged of a zero-day JavaScript attack, which was injected into the Tor Browser Bundle based on Firefox 17 if JavaScript was enabled as it was by default. JavaScript was turned off by default in updated versions of Tor Browser Bundle. However, this was used during the takedown, which was exploited to send users' IP addresses and Windows computer names to a server in
21865880
ZeroNet


source Project Maelstrom. Another application, Beaker Browser, uses the P2P DAT files protocol to allow the creation, hosting and serving of websites without need of a server. Sites on ZeroNet are known as "zites" by its users. ZeroNet supports HTML, CSS and JavaScript. Site developers can also write sites in CoffeeScript instead of write in JavaScript, but they need to compile the .coffee files. ZeroNet can compile to JavaScript in development mode, so all .coffee files are compiled and saved to all.js file. This also supports
19400396
Content Security Policy


, which leverages server-wide CSP whitelisting to exploit old and vulnerable versions of JavaScript libraries hosted at the same server (frequent case with CDN servers). In May 2017 one more method was published to bypass CSP using web application frameworks code. If the codice_1 header is present in the server response, a compliant client enforces the declarative whitelist policy. One example goal of a policy is a stricter execution mode for JavaScript in order to prevent certain cross-site scripting attacks. In practice this means that a number of features
16226328
JavaScript templating


JavaScript templating refers to the client side data binding method implemented with the JavaScript language. This approach became popular thanks to JavaScript's increased use, its increase in client processing capabilities, and the trend to outsource computations to the client's web browser. Popular JavaScript templating libraries are AngularJS, Backbone.js, Ember.js, Handlebars.js, Vue.js and Mustache.js. A frequent practice is to use double curly brackets (i.e. ) to call values of the given key from data files, often JSON objects. All examples use an external file codice_1 with following
14991328
Web service


user. Many organizations that provide data in formatted HTML pages will also provide that data on their server as XML or JSON, often through a Web service to allow syndication, for example, Wikipedia's . Another application offered to the end user may be a mashup, where a Web server consumes several Web services at different machines and compiles the content into one user interface. Asynchronous JavaScript And XML (AJAX) is a dominant technology for Web services. Developing from the combination of HTTP servers, JavaScript clients and Plain Old XML
9990527
Bindows


Bindows is a JavaScript based Software Development Kit (SDK) for writing Rich Internet Applications. Bindows applications are defined by XML documents called ADF's (Application Description File). The framework implementation is entirely client-side, but a JSF server side implementation is marketed by the same vendor. In Thailand, there is an operating system called "Bindows XD" which is not to be confused with this software. It is a fake Windows XP released early 2004 still in use as of 2009. Some highlight features of the Bindows
10527341
Dynamic web page


the user's local computer system. Such web pages use presentation technology called rich interfaced pages. Client-side scripting languages like JavaScript or ActionScript, used for Dynamic HTML (DHTML) and Flash technologies respectively, are frequently used to orchestrate media types (sound, animations, changing text, etc.) of the presentation. Client-side scripting also allows the use of remote scripting, a technique by which the DHTML page requests additional information from a server, using a hidden frame, XMLHttpRequests, or a Web service.
12072502
MEAN (software bundle)


MEAN is a free and open-source JavaScript software stack for building dynamic web sites and web applications. The MEAN stack is MongoDB, Express.js, AngularJS (or Angular), and Node.js. Because all components of the MEAN stack support programs that are written in JavaScript, MEAN applications can be written in one language for both server-side and client-side execution environments. The acronym "MEAN" was coined by Valeri Karpov. He introduced the term in a 2013 blog post.. The logo concept, initially created by
8584374
Web framework


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. Applications which make heavy use of JavaScript are called single-page applications and typically make use of a client-side JavaScript web framework to organize the code. Examples include Backbone.js, AngularJS, Angular, EmberJS, ReactJS and Vue.js. Frameworks typically set the control flow of a program and allow the
7557086
Dynamic web page


. Such web pages are often created with the help of server-side languages such as ASP, ColdFusion, Go, JavaScript, Perl, PHP, Ruby, Python, WebDNA and other languages, by a Support server that can run on the same hardware as the web server. These server-side languages often use the Common Gateway Interface (CGI) to produce "dynamic web pages". Two notable exceptions are ASP.NET, and JSP, which reuse CGI concepts in their APIs but actually dispatch all web requests into a
12072500
Mojito (framework)


Mojito is an environment agnostic, Model-View-Controller (MVC) web application framework. It was designed by Ric Allinson. Mojito supports agile development of web applications. Mojito has built-in support for unit testing, Internationalization, syntax and coding convention checks. Both server and client components are written in JavaScript. Mojito allows developers designing web applications to leverage the utilities of both configuration and MVC framework. Mojito is capable of running on both JavaScript-enabled web browsers and servers using Node.js because they both utilize JavaScript.
5632423
JavaScript


victim's site that returns private information such as JSON or JavaScript. Possible solutions include: Developers of client-server applications must recognize that untrusted clients may be under the control of attackers. The application author cannot assume that their JavaScript code will run as intended (or at all) because any secret embedded in the code could be extracted by a determined adversary. Some implications are: Package management systems such as npm and Bower are popular with JavaScript developers. Such systems allow a developer to easily manage their program's dependencies
9748144
LabKey Server


or simple, file-based modules written in HTML, XML and JavaScript. The platform can also be extended using LabKey Server's Java, JavaScript, R, Python, Perl and SAS client libraries. LabKey Server, originally known as the Computational Proteomics Analysis System (CPAS), was developed at the Fred Hutchinson Cancer Research Center to manage high volumes of data generated at the Fred Hutch Computational Proteomics Lab. In 2005, a small team spun out of the Hutch and began operating independently as LabKey Software after contributors realized that
6007966
Online OS


basic framework, which was able to launch any JavaScript application using the reBOX library. The user interface was based on the behavior of the Windows desktop with a start menu, a task bar and a desktop background. All applications were running in this environment. At server side, there were Java based web services that ran to serve the client processes and to provide data from the relational database in the backend. oos.cc also provided an integrated development environment called Developer Suite, which allowed the community to build own applications for the desktop
3492641
CommonJS


CommonJS is a project with the goal to establish conventions on module ecosystem for JavaScript outside of the web browser. The primary reason of its creation was a major lack of commonly accepted form of JavaScript scripts module units which could be reusable in environments different from that provided by a conventional web browser e.g. web server or native desktop applications which run JavaScript scripts. The project was started by Mozilla engineer Kevin Dangoor in January 2009 and initially named ServerJS. In August 2009, the project was renamed "CommonJS" to show the broader applicability
4387944
Form grabbing


the attackers modifying one of the JavaScript files (Modernizr JavaScript library, version 2.6.2) to include a PII/credit card logging script that would grab the payment information and send the information to the server controlled by the attacker hosted on “baways[.]com” domain with an SSL certificate issued by “Comodo” Certificate Authority. The British Airways mobile application also loads a webpage built with the same CSS and JavaScript components as the main website, including the malicious script installed by Magecart. Thus, the payments made using the British Airways mobile
15345222
Java applet


codice_3 tag currently requires JavaScript (that recognizes the browser and adjusts the tag), usage of additional browser-specific tags or delivering adapted output from the server side. Deprecating codice_8 tag has been criticized. Oracle now provides a maintained JavaScript code to launch applets with cross platform workarounds. The Java browser plug-in relies on NPAPI, which many web browser vendors are deprecating due to its age and security issues. In January 2016, Oracle announced that Java runtime environments based on JDK 9 will discontinue the browser plug-in
13330469
Echo (framework)


web browser) and server. This was developed in tandem with a core JavaScript framework, providing the ability to define inheritance hierarchies in JavaScript in a way familiar to developers of object-oriented languages. Echo is often compared to frameworks such as Google Web Toolkit (GWT) as both Echo and GWT (among others) offer a programming model that completely abstracts users from the web tier. However Echo differs substantially from GWT in the way it interacts with JavaScript. GWT essentially implements a subset of the Java API in JavaScript,
21214127
Mobile web analytics


-term customer loyalty. Javascript-based Page tagging notifies a third-party server when a page is rendered by a web browser. This method assumes that the end user browser has JavaScript capabilities and that JavaScript is enabled, though it is possible that neither may be true. At this time, most mobile web browsers do not support JavaScript sufficiently for this to work. HTTP cookies are commonly used to mark and identify visitors. Cookies are a standard capability for all desktop web browsers. With the prevalence of iPhones and Androids
8496971
Dart (programming language)


code compiled to JavaScript with the dart2js compiler, stating that it now runs faster than handwritten JavaScript on Chrome's V8 JavaScript engine for the DeltaBlue benchmark. On November 18, 2011, Google released Dart Editor, an open-source program based on Eclipse components, for Mac OS X, Windows, and Linux-based operating systems. The editor supports syntax highlighting, code completion, JavaScript compiling, running web and server Dart applications, and debugging. On August 13, 2012, Google announced the release of an Eclipse plugin
12912376
WebRTC Gateway


extends the scope of WebRTC applications and enables much wider reach and usage scenarios. The usual process with WebRTC is that a user downloads a WebRTC JavaScript application. This application is then used to communicate with another user. A WebRTC gateway would usually contain the server from where a user would download the WebRTC JavaScript application. When receiving a call from the user, the WebRTC gateway needs to decide whether the callee is reachable over WebRTC. If not, then the call will have to be translated into SIP for example. To translate
913899
Web application


embedded in the page markup. However, "every" significant change to the web page required a round trip back to the server to refresh the entire page. In 1995, Netscape introduced a client-side scripting language called JavaScript allowing programmers to add some dynamic elements to the user interface that ran on the client side. So instead of sending data to the server in order to generate an entire web page, the embedded scripts of the downloaded page can perform various tasks such as input validation or showing/hiding parts of
4166253
JavaScript syntax


The syntax of JavaScript is the set of rules that define a correctly structured JavaScript program. The examples below make use of the log function of the console object present in most browsers for standard text output. The JavaScript standard library lacks an official standard text output function. Given that JavaScript is mainly used for client-side scripting within modern Web browsers, and that almost all Web browsers provide the alert function, alert can also be used, but is not commonly used. Brendan Eich summarized the ancestry of the syntax in the
903805
World Wide Web


document where such versions are available and the server is configured to do so. A "server-side dynamic web page" is a web page whose construction is controlled by an application server processing server-side scripts. In server-side scripting, parameters determine how the assembly of every new web page proceeds, including the setting up of more client-side processing. A "client-side dynamic web page" processes the web page using HTML scripting running in the browser as it loads. JavaScript and other scripting languages
14607562
ItsNat


nodes introduced by non-ItsNat JavaScript code, static zones in server can be managed by non-ItsNat JavaScript code, DOM subtrees removed only in server can be changed freely in client, and in some locations (between and at the end of head and body elements), "intrusive" nodes are tolerated. In stateless mode, introduced in version 1.3, the client page sends the necessary custom data of the current state to the server usually through AJAX requests, the server with this data is able to reconstruct partially or
9559898
WMLScript


WMLScript is a procedural programming language and dialect of JavaScript used for WML pages and is part of the Wireless Application Protocol (WAP). WMLScript is a client-side scripting language and is similar to JavaScript. Just like JavaScript WMLScript is used for tasks such as user input validation, generation of error message and other Dialog boxes etc. WMLScript is based on ECMAScript (European Computer Manufacturers Association Script), which is JavaScript's standardized version. Thus the syntax of WMLScript is similar to JavaScript but not fully compatible. Despite the
22077213
Gyroscope (software)


(LCHH) architecture instead of explicit Model-View-Controller (MVC). In the LCHH architecture, a Loader, or a "DIV" container with a unique identifier is populated with default Content. Visual affordances, also known as "triggers" that are included in the Content invoke client-side handlers. These JavaScript handlers then sends XmlHTTPRequestObject (or AJAX) requests to Server-side Handlers. The Server-side scripts then perform updating, insertion or deletion functions before piggybacking the updated View back to the original
12667304
Google APIs


use Google APIs from within their code, including Java, JavaScript, Ruby, .NET, Objective-C, PHP and Python. The Google Loader is a JavaScript library which allows web developers to easily load other JavaScript APIs provided by Google and other developers of popular libraries. Google Loader provides a JavaScript method for loading a specific API (also called module), in which additional settings can be specified such as API version, language, location, selected packages, load callback and other parameters specific to a particular API. Dynamic
9137548
Dojo Toolkit


toolkit. In 2016, the foundation merged with jQuery Foundation to become JS Foundation. Dojo is a JavaScript framework targeting the many needs of large-scale client-side web development. For example, Dojo abstracts the differences among diverse browsers to provide APIs that will work on all of them (it can even run on the server under Node.js); it establishes a framework for defining modules of code and managing their interdependencies; it provides build tools for optimizing JavaScript and CSS, generating documentation, and unit testing; it supports
14745086
Steve Yegge


Grab. In 2007, Yegge was a speaker at the UIUC 13th annual reflections❘projections Conference. In May 2008, Yegge presented a talk on dynamic languages at Stanford University. In July 2007, Yegge was a presenter at OSCON 2007, presenting a keynote speech on "How to Ignore Marketing and Become Irrelevant in Two Easy Steps". Yegge advocates server-side JavaScript for development. After failing to convince Google to adopt Ruby on Rails, he ported Rails to JavaScript, creating the "Rhino on Rails" project.
3463015
YUI Library


and sponsored internally by Yahoo! co-founder Jerry Yang; its principal architects have been Sha, Adam Moore, and Matt Sweeney. The library's developers maintain the YUIBlog; the YUI community discusses the library and implementations in its community forum. On August 29, 2014, it was announced that active development of YUI by Yahoo! would end, citing the evolution of the JavaScript standards, steadily decreasing interest in large JavaScript libraries by developers, and the proliferation of server-side solutions. Future development will be limited to
4971907
Document Object Model


, the first scripting languages to be widely implemented in the JavaScript engines of web browsers. JavaScript was released by Netscape Communications in 1995 within Netscape Navigator 2.0. Netscape's competitor, Microsoft, released Internet Explorer 3.0 the following year with a reimplementation of JavaScript called JScript. JavaScript and JScript let web developers create web pages with client-side interactivity. The limited facilities for detecting user-generated events and modifying the HTML document in the first generation of these languages eventually became known as "DOM Level 0" or "Legacy DOM
8831256
Unobtrusive JavaScript


separating JavaScript functionality from HTML markup. The use of client-side JavaScript libraries such as jQuery, MooTools or Prototype can simplify this process and help ensure that individual browser and browser version implementation details are hidden and catered for. Keeping most of the JavaScript out of the default namespace helps ensure that it is as unobtrusive as possible in that sense. A further criterion of unobtrusive JavaScript that is often cited is to ensure that added behavior degrades gracefully on those browsers with unexpected configurations, and those on which the user may have disabled
9795841
Server-side scripting


Server, first released in December, 1994 (soon after releasing JavaScript for browsers). Server-side scripting was later used in early 1995 by Fred DuFresne while developing the first web site for Boston, MA television station WCVB. The technology is described in US patent 5835712. The patent was issued in 1998 and is now owned by Open Invention Network (OIN). In 2010 OIN named Fred DuFresne a "Distinguished Inventor" for his work on server-side scripting. Today, a variety of services use server-
9947260