jOOPL 2.2.0

In less than a month - mostly weeks - it will be released a new version of jOOPL, the 2.2.0 version.

jOOPL 2.2.0 will come with a lot of improvements and new features!

- Insanely-increased object instantiation performance.
- Instantiate classes using the standard new operator.
- Properties are now declared using the ECMA-Script 5.x/6 property syntax.
- Built-in syntax for creating events and triggering them.
- A lot of bug fixes.
- Now jOOPL has a test suite.
- Now the source code is fully-commented.

Easy learning curve. Yet powerful.

jOOPL implements the well-known object-oriented programming features:
  • Inheritance!
  • True polymorphism!
  • Encapsulation!

jOOPL (JavaScript Object Oriented Programming Library, pronounced | λu 'pel |) is here to offer object-oriented programming and no more: it is just a tiny, simple and effective library supporting your JavaScript developments in the Web and anywhere.

For example, see how easy becomes defining a namespace and a class (check the code comments for further explanation):
(function () {
    "use strict";

    // #1 Declare a namespace and the function creates an scope 
    // where "this" is the child namespace "Samples"
    $namespace.register("Joopl.Samples", function () {

        // #2 Declare a class "ClassA" inside the registered namespace. 
        // The "this" keyword contains the "Samples" namespace!
        // The ClassA has a method "someMethod()" which adds a text 
        // to the document.
        this.ClassA = $def({
            // A default constructor. This parameter is optional but it has 
            // been included to this example in order to be more explicit!
            $constructor: function () {
            },

            $members: {
                // Adds the whole text to the document
                helloWorld: function () {
                    document.body.appendChild(
                          document.createTextNode("Hello world from my class!")
                    );
                }
            }
        });
    });

    // #4 Create a namespace scope in order to have access to 
    // the declared class in the registered namespace.
    $namespace.using(["Joopl.Samples"], function () {
        var a = new this.ClassA();

        // As expected, ClassA instance has "someMethod()" and 
        // this will print the expected text to the document.
        a.helloWorld();
    });
})();

Why jOOPL?

In the new internet of applications, Web 2.0 and 3.0, JavaScript has evolved as a powerful multi-platform paradigm.

In addition, there are many platforms using Web standards like HTML5, CSS and the JavaScript language to develop full-featured cutting-edge applications for mobile devices, tablets and/or computers:

- PhoneGap.
- Windows 8 Modern UI HTML5 apps.
- Firefox OS.
- Chrome OS.
- ... and many more!

jOOPL works flawlessly on top of these and other platforms because it is pure and standard JavaScript!

Current and future developments are not static Web pages with scripting anymore, but full applications with graphical user interfaces on top of the well-known solid W3C standards like DOM, XML, HTML, CSS or AJAX.

JavaScript is a prototype-oriented language, meaning that it has some of object-oriented programming features out-of-the-box. jOOPL builds on top of current ECMAScript for JavaScript standards (ECMAScript 5 and above) and introduces powerful state-of-the-art features and it is just an open source library that weights no more than 8KB!

Why jOOPL? Why not? ;)

jOOPL is not a transpiler

jOOPL is a regular JavaScript library and it may be deployed in any environment supporting JavaScript implementing ECMA-Script 5 and above.

Unlike other solutions like Microsoft TypeScript or Google Dart, jOOPL enhances actual JavaScript.

Last edited Apr 21, 2013 at 7:18 AM by MFidemraizer, version 52