Mojito

Mojito is a model-view-controller (MVC) JavaScript web application framework based on YUI 3 that empowers agile development of Web applications. Mojito permits developers to utilize a combination of configurations and an MVC architecture to make HTML5 applications. Because is uses JavaScript for both client-side and server-side, Mojito is a full-stack frame work running from the can browser to the Node.js server.

It has built-in support for testing, internationalization and growing documentation. Yahoo was the one who develop the new JavaScript application framework named Mojito. Mojito is authorized under a BSD license. The Mojito project is a meritocratic, agreement-based community project that permits anyone to contribute and take on responsibilities.

Mojito offers great features, such as:

• Local development environment and tools
• Library for streamlining internationalization and localization
• Coordinated unit testing
• Device particular presentation

The Mojito framework offers a broad API with modules for executing code, making REST calls, taking care of handling cookies and assets, getting to parameters and configuration, and more. The framework can recognize the kind of calling devices and serve the appropriate HTML markup.

By open-sourcing Mojito, which is an MVC (Model View Controller) structure, Yahoo wants to assemble a group of developers and advance selection. Applications that have been developed with Mojito include for example, Yahoo's Livestand, a magazine application for the iPad, and the Fantasy Premier League Football game application. Through open-sourcing, Yahoo likewise needs to grow better measures for high-performance Web applications and relieve incomplete availability issues.

What is Mojito framework good for?

The most ideal approach to illustrate why you ought to use Mojito for making Web applications is that the Mojito framework permits developers to keep and maintain a single JavaScript codebase for both customer front-end and server back-end which is very useful for the redundancy of codes in building applications. Another reason is that the expectation to absorb information is so high compared with different frameworks. Just simply check the documentation and take time to read it.

The following are the advantages in using Mojito framework in your application:

• Server stacks and making a framework  in JavaScript on top of Node.js
• Offering the well-understood paradigm of Model-View-Controller, or MVC
• Rectangular areas of the page that are meant to be fairly independent.
• Mojito is intended to be brilliant about devices
• YUI on the server
• Controlling the Back-End UI Layer
• Creating on an Existing HTTP-Based Service

Mojito is also being used by many distributors for daily papers and magazines, and for interactive ads.

Examples and code snippets

Before starting to create a simple application using this framework, the system must be running under Unix-based system since it is one of the requirements for this framework and also Software: Node.js (>= 0.8.0 0.11), npm (> 1.0.0). After completing the said requirements, let's assume that your system is running smoothly, you're familiar or have a background in JavaScript. If not, then you should build a solid foundation in JavaScript first in order to understand this framework.

Moving forward, the first thing to do is to start installation process. The steps are posted below; just follow what is being stated.

1. Install the Mojito CLI bundle v0.2.x (mojito-cli) from the npm registry so you can run Mojito commands. You may need to utilize sudo in the event that you keep running into permission errors.

$ npm install mojito-cli@~0.2.0 -g

2. Likewise, do the same for the Mojito CLI utility for making applications and mojits (mojito-cli-create):

$ npm install mojito-cli-create@0~0.1.1 -g

3. To confirm that Mojito has been installed by running the help command.

$ mojito help

Moving forward. If all the steps above are installed and running smoothly then let's start making a mojito application. Follow steps stated below

$ mojito create app hello_world
$ cd hello_world
$ mojito create mojit myMojit

To make the application return a string we need to replace the code in mojits/myMojit/controller.server.js with the following: 

YUI.add('mymojit', function(Y, NAME) {
 Y.namespace('mojito.controllers')[NAME] = {
     index: function(ac) {
         ac.done('Hello, world. This is my first application using mojito on ' + (new Date()) + '.');
     }
 };
});

From the hello_world application directory, start Mojito by running:

$ node app.js

Go to this URL to see your running application. 

When you want stop your application just press Ctrl-C.

As you can see, the example given above is a simple hello-word using this JavaScript framework.

Conclusion

Since the beginning of the Web, innovative technologists have pushed the web beyond what was consider as possible. Presently,  the Web has formed into a completely highlighted application platform and fast JavaScript runtimes and HTML5 principles have enabled developers to make applications that before were only possible on local platforms. There are bunches of JavaScript frameworks accessible on the web or even in the business sector, yet in the event that interested in giving mojito a try, don't hesitate to do so—they have a solid community that can help you and clear documentation to comprehend the framework.