First release
Happy holidays and happy new year from ease.js
This project has been a wonderfully rewarding experience. It has allowed me to
explore (in agonizing detail) the depths of JavaScript's prototype model and
gain a much greater understanding of the language itself. ease.js evolved from a
simple script to make the life of myself and my coworkers simpler ("ease" us
into Classical OO in JS) into a full-scale project that is now just over a year
old. While the initial design was fairly simple, I now find that I'm left with
more implementation ideas than I am actual implemented features.
ease.js is still very young. v0.1.0 represents an initial step in the life of
the project - getting it out there for people to use and observe; allowing
others to test the waters. There is a long road ahead and many exciting features
planned for the project. Thus far, it has far exceeded my goals and expectations,
but there is much work to be done.
I hope that this project is well-received among developers in the JavaScript
community. It touches upon what many consider to be a sensitive subject. Some
firmly believe that Classical OOP should be left out of JavaScript and that one
should instead stick to its prototypal model. While I fully respect the model,
and it does certainly have powerful applications, there are also situations
where the Classical OOP paradigm is also appropriate (some would argue more
appropriate). I have found ease.js to be invaluable during the development of
the project for which it was designed (software for my current employer). It has
allowed both myself and my coworkers to continue using a development model we
are familiar with, while exploring and making use of other paradigms where they
are appropriate. We have been able to do so without having to explore other
languages that support Classical OOP (for example, GWT, which compiles Java into
JavaScript).
It is important to understand that ease.js simply opens up, with greater
flexibility and simplicity, another paradigm which is closely related to the
Prototypal model (they are both Object-Oriented). One does not have to make use
of it should they prefer a different paradigm, even if the libraries they use
are written using ease.js. Ultimately, ease.js has to work with the restrictions
provided by the language. As such, one can think of ease.js as a prototype
builder. Each "class" created with ease.js is simply a prototype and can be used
in conjunction with any other JavaScript code. The reverse is also true - you
can use your existing code with ease.js and ease.js is capable of extending from
existing prototypes as if they were classes. Think of ease.js like a tool, /not/
a restriction. In fact, it would be bad practice to limit yourself to what
ease.js provides. JavaScript provides powerful features of its own. Therefore,
if you are using ease.js to aid in transition to JavaScript, be sure that you
continue to explore JavaScript itself.
One should also keep in mind that ease.js, while trying to maintain a Classical
Object-Oriented model that developers from common languages like Java, PHP, C++,
etc will be used to, did have to make certain design decisions that make sense
when working with JavaScript. Certain additional decisions were also made, after
great research (the majority of the time spent on this project was on paper, not
at the keyboard), that may set ease.js aside from other languages when getting
into finer details. While any Classical Object-Oriented developer should be able
to jump in with little effort and even little understanding of JavaScript, you
are still encouraged to take a look at the manual (http://easejs.org) and ensure
that you have a firm understanding of both what ease.js is doing and what it is
capable of doing. It also helps to take a look at the developer portion of the
documentation (Appendix B - Implementation Details / Rationale) to get a better
grasp on what ease.js is doing behind the scenes to better structure and
optimize your code. Even better, feel free to browse through ease.js's source
code and maybe even hack at ease.js yourself. See README.hacking for more
information on contributing to the project.
As was already mentioned, ease.js is under active development. Feel free to
check out the bugs/issues/feature requests on the website (http://easejs.org) to
see what is outstanding. If you find that you want a feature that isn't listed,
feel free to request it (it will, of course, have to be given careful
consideration to ensure it fits in line with the goals of the project). Since
the project will be changing so rapidly, I encourage you to keep checking back,
or keep a local copy of the Git repository to pull on occasion. Keep your eye
out for a mailing list as well.
As one can see by reading over this tag message, the Git repository itself is
used in place of a blog (perhaps some script will be developed in the future to
put all important commit/tag messages conveniently online much like a blog). One
can easily see long commit messages (shorter messages are unlikely to be
entries) by using `git log --log-size`. Tag messages can be shown with `git tag
-nN`, where N is the number of lines to be displayed.
One final mention is in order as to why this is the first release of the
project, over a year after it began. An inspection of the git repository will
yield, at this point, but one tag - this one. Although the repository has been
public during the entire course of its development (ease.js can be considered to
follow the Bazaar development model), ease.js has not been advertised to anyone.
I wished for the project to remain mostly under wraps until the first release.
This was for a very important reason - I did not want sudden API changes and any
potential incomplete features or bugs to stifle adoption or perception of the
project. With the release of v0.1.0, I can confidently say that the API has been
solidified and that backwards compatibility will be maintained throughout all
future releases, unless slowly deprecated over a number of major or minor
releases.
With that said, more information can be found in the manual, which has become a
project of its own. If you've read this far, thank you for your interest in the
project. I hope you find it useful in bringing the benefits of Classical OOP to
JavaScript.