# Use your Ajax, HTML, JavaScript and DOM skills server-side
# Integrate with databases, file systems, networks and more
# Just tag your JavaScript code to run on the server, the client, or both
# Easily deploy your Jaxer apps to Aptana Cloud from within Studio
It's well overdue, but I've finally managed to get this stuff up. Here are the slides from my presentation on Server-Side JavaScript, as well as the source code for the Jaxer REST API provider and consumers that I wrote.
freedom to use the
same JavaScript routines on both servers and clients. In addition, the
techniques presented throughout this series will allow you to maintain a
single code base for both Ajax and non-Ajax clients
This
double-coding issue can be avoided by using JavaScript combined with Java
code on the server side, getting full support of scripting languages through the javax.script API. In addition, the Java SE Development Kit
(JDK) 6 already includes Mozilla's Rhino
JavaScript engine, which means no setup is required.
the toSource() method, which all JavaScript objects
must have.
all data exchange between the Java code and
the executed script should be done through primitive variables, strings, and Java
objects (for example, beans) whose properties and methods can be accessed very easily in the
JavaScript code. Simply said, don't try to access native JavaScript objects in your
Java code. Use Java objects in the JavaScript code instead.
Note
that javax.script.Invocable is an optional interface,
which some script engines may not implement. The JavaScript engine that comes with
JDK 6 does support this interface.
you
can significantly reduce the execution time by compiling the scripts, using the
methods provided by another optional interface named javax.script.Compilable, which is supported by the JavaScript engine of
JDK 6.
The Persevere project is an open source set of tools for persistence and distributed computing using intuitive standards-based JSON interfaces of HTTP REST, JSON-RPC, JSONPath, and HTTP Channels. The core of the Persevere project is the Persevere Server. The Persevere Server includes a Persevere JavaScript client, but the standards-based interface is intended to be used with any framework or client.
Narwhal is a server-side JavaScript standard library conforming to the serverJS standard. It is designed to work with multiple JavaScript interpreters, and to be easy to add support for new interpreters. Wherever possible, it is implemented in pure JavaScript to maximize reuse of code between platforms.
pi.comet an advanced javascript class to create cross browser Comet(Reverse Ajax) applications easily.It provides realtime data transfers between client and server.
A fast, highly interactive, fun chat application using a javascript, comet (real time push communication), ajax (async posting of information) modern web interface, and a custom PHP based backend daemon that interfaces between the (web) frontend and the IRC backend server.
One host that we've been playing around with is AppJet. Using AppJet as your host for your Pipes webservice module is easy to make, fast and effective. AppJet uses JavaScript as the server side language making it even easier to use for web developers.
Wouldn't it be cool if you could work with MySQL within your JavaScript code? Think about it, you wouldn't have to spend extra time writing extra server-side code for connecting to, querying, and parsing results, you could just write a little bit more code in your JavaScript and be done with it. Of course, we wouldn't want any of this SQL exposed to the end-user, as that would be a major security issue, but what if that problem was solved as well? You might also raise the point that you'd still need the ability to prepare your SQL statements that take dynamic input to prevent SQL injection attacks, but if that weren't an issue, wouldn't that be awesome as well?
Marquee tool is a DHTML application that can save you time and help you in your future projects. It is the first web based Javascript tool that allows you to select rectangular areas on or elements, calculate selection coordinates, display them or send them to the server.
you soon realise that every file and directory is uniquely addressable by its fully qualified path (either absolute or relative) and you can refer to each file and directory by its path. You are also aware that a valid path will uniquely resolve to only one directory or file.
the server allows you to retrieve the list of subdirectories and files within your current directory. It always shows you the current state of that directory.
following elements
A shared understanding of where the files will be uploaded, how they will be uniquely named, their specific file extensions (optionally) and the specific format of the file eg.
daemon process on the central office computer (the FTP server) which regularly scans the directory, parses each file as it comes it, does the relevant processing on it, and generates the appropriate result files and places them in the appropriate directories using the shared understanding of the directory structure and the file naming convention to communicate back the results of the processing.
RPC allowed you to invoke remote procedures by supporting an ability to pass messages which included the message name and the values for all the parameters necessary to be supplied to the message. Unlike FTP which was meant to do data transfer across a network, RPC was geared to do things remotely.
FTP required understanding of very few basic verbs (ls, cd, get, put). Thus the training required to understand FTP semantics was far less than that for RPC. This was partially due to the fact that RPC had a programmatic interface.
Moreover each time, new procedures were added or parameters added, these required programmatic changes
HTTP protoco
Unlike FTP and email, this required the authors to understand a new language, but used a simple markup syntax to keep the learning curve to the minimum
get/view/download/save a document
Along with RPC, these were essentially different technical manifestations of Service Oriented Architecture (SOA) principles.
Many services were usually expected to “do something” though quite often some services would simply return the requested data. Usually but not necessarily the services were identified by using ‘verbs’.
allow us to use the web to ‘do something’
Resource and media types as the basic units
Unique resource identifiers
Each resource has often one default manually readable representation
Each resource representation optionally includes contextually relevant hyperlinks to other resources
REST encourages a uniform interface
GET, PUT, POST and DELETE
Default Rendering
a default HTML rendering capability
Aspects such as non maintenance of conversational state, greatly increase the scalability of REST applications even if they do incur a minor cost in efficiency (which can be due to repeated redundant communication of data elements, or additional processing requirements due to preclusion of conversation state).
is much easier to understand from a data perspective than an invoice processor API.
However the simpler, cleaner and minimalistic abstractions often are far more important than feature richness. A point I would want to make in favour of REST even as I admit that conventional SOA technologies are far more feature rich than REST.
REST encourages you to view and model your architecture as a set of resources rather than services.
Reflection.js works well with logos, icons and dynamic image content such as forum avatars.
Reflection.js comes into it's own with forum avatars; you can apply a reflection effect to every avatar on your forum or blog without any additional server work.
Passpack Host-Proof Hosting is a package who's aim is to give Ajax programmers the libraries they need to build a Host-Proof Hosting application.
A number of pre-existing libraries have been modified and grouped together under the Passpack namespace in order to facilitate use.
JNEXT is an open source (triple MPL, GPL, LGPL license), small footprint, cross platform and cross browser framework for extending Web browser Javascript
(for more background and motivation check this blog entry).
With JNEXT it is possible to utilize existing Web browsers to host full and self contained applications that do not depend on external Web servers for the application logic (although they are free to make use of them).
This is acheived by enabling Javascript controlled access to the full range of native operating system
resources (such as TCP/UDP sockets, files, databases, threads etc).
Closure Compiler is a JavaScript optimizer that compiles web apps down into compact, high-performance JavaScript code.
Closure Library is a broad, well-tested, modular, and cross-browser JavaScript library. Web developers can pull just what they need from a wide set of reusable UI widgets and controls, as well as lower-level utilities for the DOM, server communication, animation, data structures, unit testing, rich-text editing, and much, much more. (Seriously. Check the docs.)
Closure Templates grew out of a desire for web templates that are precompiled to efficient JavaScript. Closure Templates have a simple syntax that is natural for programmers.