All historical release notes are included below in descending order, beginning with the current release. GPG signatures for each of the releases and the corresponding notes can be found in their respective tags in the Git repository.
0.2.9: GNU ease.js 0.2.9 released
This release succeeds v0.2.8, which was released 15 July, 2016. There are
no backwards-incompatible changes, but certain default behaviors have
changed (see changes below). Support continues for ECMAScript 3+.
About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include
simple and intuitive class definitions; classical inheritance;
abstract classes and methods; traits as mixins; interfaces; public,
protected, and private access modifiers; static and constant members;
and more. Please see the comprehensive documentation at
<https://www.gnu.org/s/easejs/manual.html> for more information,
examples, and implementation details.
Changes between 0.2.8 and 0.2.9
-------------------------------
* Class constructors are now virtual by default. The manual has been
updated with information about this change.
* Method overrides are now implicitly virtual. This is consistent
with other object-oriented languages and solves the problem with
breaking stackable traits if the author forgets to supply `virtual'
to an overridden (intended-to-be-stackable) method. The manual has
been updated.
* New methods `Class.assertInstanceOf' and its alias `Class.assertIsA' have
been added to eliminate boilerplate of enforcing polymorphism. They are
like `Cass.isInstanceOf' and `Class.isA' respectively, but will fail by
throwing a TypeError. The manual has been updated to include these two
methods, along with some rewording of the containing section.
* `Class.extend(Base)', where `Base' is a class, will now assume that you
forgot the class definition and throw an error rather than trying to use
`Base' as the definition object.
* [bugfix] Using `#constructor' (alias of `#__construct') in Error subtypes
will no longer complain about an attempt to redefined `#__construct'.
* `Constructors' section of manual has been reworded and references to
poor practices (static classes, Singletons) have been removed.
* Manual (and website) examples modernized to use ECMAScript 6 syntax.
Users must still write ES3 syntax if they want to use ease.js in ES3
environments, of course.
* INSTALL file added to repository (removed from .gitignore). This
was previously (and unintentionally) only available in the
distribution archives.
* Copyright years updated on combined and minified distributions.
This release contains a number of bugfixes for traits, which is stable but
still under development:
* [bugfix] Methods of trait class supertypes now apply with the
correct context. (Feature added in 0.2.7)
* [bugfix] Traits extending classes may now be named using the
`Trait('Name').extend(C, dfn)' notation. (Feature added in 0.2.7)
* [bugfix] Can now mix in traits with class supertypes that define
constructors. (Feature added in 0.2.7)
* [bugfix] `this.__inst' in traits now correctly references the object
mixed into; previously, this was `undefined'.
I apologize for the (extreme) delay in this release: the process was stalled
for many months while waiting for certain legal documents after my employer
was purchased by another company.
Release notes for past releases are available at:
https://www.gnu.org/software/easejs/release-notes.html
More information, including an online manual, can be found on GNU's
website:
https://gnu.org/software/easejs
Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
https://ftp.gnu.org/gnu/easejs/easejs-0.2.9.tar.gz
https://ftp.gnu.org/gnu/easejs/easejs-0.2.9.tar.gz.sig
Alternative download options are available at:
http://www.gnu.org/software/easejs/download.html
[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact. First, be sure to download both the .sig file
and the corresponding tarball. Then, run a command like this:
gpg --verify easejs-0.2.9.tar.gz.sig
If that command fails because you don't have the required public key,
then run this command to import it:
gpg --keyserver keys.gnupg.net --recv-keys D6E9B930028A6C38F43B2388FEF635745E6F6D05
and rerun the 'gpg --verify' command.
Free Your JavaScript!
---------------------
http://www.gnu.org/software/easejs/whyfreejs.html
Explore why online freedoms are of practical importance with
my LibrePlanet 2016 talk:
https://media.libreplanet.org/u/libreplanet/collection/restore-online-freedom/
0.2.8: GNU ease.js 0.2.8 released
This is a minor release introducing transparent Error subtyping.
This release succeeds v0.2.7, which was released 26 October, 2015. There
are no backwards-incompatible changes; support continues for ECMAScript 3+.
Changes between 0.2.7 and 0.2.8:
* Transparent Error subtyping
- Extending an ECMAScript Error constructor will transparently produce a
Error subtype that performs all necessary boilerplate and strips
itself from the stack trace. See manual for more information.
- Manual changes:
- Added "Error Subtyping" section.
- Removed recommendation to always use `public' keyword when defining
public methods (which is the default), and warning that it might be
required in the future. Omitting is fine (and preferred by some).
- Added "Class Caveats" section; documented `this.__inst'.
Release notes for past releases are available at:
https://www.gnu.org/software/easejs/release-notes.html
More information, including an online manual, can be found on GNU's website:
https://gnu.org/software/easejs
Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
https://ftpmirror.gnu.org/easejs/easejs-0.2.8.tar.gz
https://ftpmirror.gnu.org/easejs/easejs-0.2.8.tar.gz.sig
Alternative download options are available at:
http://www.gnu.org/software/easejs/download.html
[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact. First, be sure to download both the .sig file
and the corresponding tarball. Then, run a command like this:
gpg --verify easejs-0.2.8.tar.gz.sig
If that command fails because you don't have the required public key,
then run this command to import it:
gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB
and rerun the 'gpg --verify' command.
Free Your JavaScript!
---------------------
<http://www.gnu.org/software/easejs/whyfreejs.html>
See the FSF's Free JavaScript Campaign at
<https://fsf.org/campaigns/freejs>.
Are you a JavaScript developer? Consider joining the campaign's JavaScript
Developers Task Force mailing list at
<https://lists.gnu.org/mailman/listinfo/js-devs-task-force>.
About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at <https://www.gnu.org/s/easejs/manual.html>
for more information, examples, and implementation details.
0.2.7: GNU ease.js 0.2.7 released [stable]
This is a minor release introducing additional features for classes and
traits.
This release succeeds v0.2.6, which was released 14 August, 2015. There are
no backwards-incompatible changes; support continues for ECMAScript 3+.
Changes between 0.2.6 and 0.2.7:
* ES6-style constructor method supported.
- Directly invoking the easejs object with a constructor will now perform
the equivalent of a Class.extend( ctor, {} ).
- Documentation now compiles with Texinfo 5.2.
Trait support is currently under development and will be undocumented
until v0.3.0; it is included here as a preview. The implementation is
stable and comprehensively tested, but is incomplete (see TODO).
* [preview] Traits can now override public and protected methods of class
supertypes.
- [preview] Error now provided when attempting to declare a mixin that is
not a trait.
Release notes for past releases are available at:
https://www.gnu.org/software/easejs/release-notes.html
More information, including an online manual, can be found on GNU's website:
https://gnu.org/software/easejs
Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
https://ftp.gnu.org/gnu/easejs/easejs-0.2.7.tar.gz
https://ftp.gnu.org/gnu/easejs/easejs-0.2.7.tar.gz.sig
Alternative download options are available at:
http://www.gnu.org/software/easejs/download.html
[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact. First, be sure to download both the .sig file
and the corresponding tarball. Then, run a command like this:
gpg --verify easejs-0.2.7.tar.gz.sig
If that command fails because you don't have the required public key,
then run this command to import it:
gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB
and rerun the 'gpg --verify' command.
Free Your JavaScript!
---------------------
<http://www.gnu.org/software/easejs/whyfreejs.html>
See the FSF's Free JavaScript Campaign at
<https://fsf.org/campaigns/freejs>.
Are you a JavaScript developer? Consider joining the campaign's JavaScript
Developers Task Force mailing list at
<https://lists.gnu.org/mailman/listinfo/js-devs-task-force>.
About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at <https://www.gnu.org/s/easejs/manual.html>
for more information, examples, and implementation details.
0.2.6: GNU ease.js 0.2.6 released [stable]
This is a minor release, focusing on a single compatibility issue.
This release succeeds v0.2.5, which was released 28 May, 2015. There are no
backwards-incompatible changes; support continues for ECMAScript 3+.
Changes between 0.2.5 and 0.2.6:
* `require` paths in index.js changed to be compatible with Browserify
- Browserify will now properly recognize all require'd modules;
previously, it was halting after processing only index.js.
Historical release notes are available at:
https://www.gnu.org/software/easejs/release-notes.html
Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
https://ftp.gnu.org/gnu/easejs/easejs-0.2.6.tar.gz
https://ftp.gnu.org/gnu/easejs/easejs-0.2.6.tar.gz.sig
Alternative download options are available at:
http://www.gnu.org/software/easejs/download.html
[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact. First, be sure to download both the .sig file
and the corresponding tarball. Then, run a command like this:
gpg --verify easejs-0.2.6.tar.gz.sig
If that command fails because you don't have the required public key,
then run this command to import it:
gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB
and rerun the 'gpg --verify' command.
Free Your JavaScript!
---------------------
<http://www.gnu.org/software/easejs/whyfreejs.html>
See the FSF's Free JavaScript Campaign at
<https://fsf.org/campaigns/freejs>.
Are you a JavaScript developer? Consider joining the campaign's JavaScript
Developers Task Force mailing list at
<https://lists.gnu.org/mailman/listinfo/js-devs-task-force>.
About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at
<https://www.gnu.org/software/easejs/manual.html> for more information,
examples, and implementation details.
0.2.5: GNU ease.js 0.2.5 released [stable]
This is a feature release, focused primarily on the continued development of
traits.
This release succeeds v0.2.4, which was released 07 Aug, 2014. There are no
backwards-incompatible changes; support continues for ECMAScript 3+.
Changes between 0.2.4 and 0.2.5:
- [doc] Manual has been updated to reflect an implementation detail that
causes `this.__super` to remain in scope after a call to a private
method.
- This is not a bug, but is undefined behavior.
Trait support is currently under development and will be undocumented
until v0.3.0; it is included currently as a preview and is functional and
comprehensively tested, but is incomplete. For a list of outstanding
tasks, see `README.traits`.
* [preview] Traits may now "extend" classes.
- Extending a class C denotes compatibility with C's interface: the
trait may then only be mixed into C or its subtypes.
- Extending traits is not yet supported, but will be in the next
release.
- Releated test cases:
- test/Trait/{Abstract,ClassExtend}Test.js
- [preview] Staging object returned by `#use` calls---representing an
eventual mixin---now statisfy the `Class.isClass` predicate.
Examples of Trait use can be found in the extensive test cases (test/Trait)
and in the resources found on the ease.js homepage:
https://www.gnu.org/software/easejs/#traits
Historical release notes are available at:
https://www.gnu.org/software/easejs/release-notes.html
Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
https://ftp.gnu.org/gnu/easejs/easejs-0.2.5.tar.gz
https://ftp.gnu.org/gnu/easejs/easejs-0.2.5.tar.gz.sig
Alternative download options are available at:
http://www.gnu.org/software/easejs/download.html
[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact. First, be sure to download both the .sig file
and the corresponding tarball. Then, run a command like this:
gpg --verify easejs-0.2.5.tar.gz.sig
If that command fails because you don't have the required public key,
then run this command to import it:
gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB
and rerun the 'gpg --verify' command.
Free Your JavaScript!
---------------------
<http://www.gnu.org/software/easejs/whyfreejs.html>
See the FSF's Free JavaScript Campaign at
<https://fsf.org/campaigns/freejs>.
Are you a JavaScript developer? Consider joining the campaign's JavaScript
Developers Task Force mailing list at
<https://lists.gnu.org/mailman/listinfo/js-devs-task-force>.
About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at
<https://www.gnu.org/software/easejs/manual.html> for more information,
examples, and implementation details.
0.2.4: GNU ease.js 0.2.4 released [stable]
This is a maintenance release correcting a number of bugs---most of which
were introduced in v0.2.3---addressing primarily ECMAScript 3
incompatibilities. Users needing to support ES3 environments (notably,
IE<=8) should consider v0.2.3 to be broken.
v0.2.3 was released last week on Jul 28.
Changes between 0.2.3 and 0.2.4:
* [bugfix] method.super references in ease.js and test cases are now
ES3-compatible
* [bugfix] The Global prototype introduced in v0.2.3 used an
implementation that IE<=8 did not support; now using an alternative
- [bugfix] Interface.isInstanceOf now correctly operates as documented in
the interoperability section of the manual
- When passed an object whose constructor is not an ease.js class, it
now falls back to Interface.isCompatible (as it should have).
- [bugfix] Corrected test broken by Node.js 0.10.27
- See commit cef45cd0 for details on what changed within Node.js.
Trait support is currently under development and will be undocumented
until v0.3.0; it is included currently as a preview and is functional and
comprehensively tested, but incomplete.
* [preview] [bugfix] Non-argument traits now apply an empty array to
`__mixin` instead of `undefined`, which is unsupported by ES3
Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
https://ftp.gnu.org/gnu/easejs/easejs-0.2.4.tar.gz
https://ftp.gnu.org/gnu/easejs/easejs-0.2.4.tar.gz.sig
Alternative download options are available at:
http://www.gnu.org/software/easejs/download.html
[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact. First, be sure to download both the .sig file
and the corresponding tarball. Then, run a command like this:
gpg --verify easejs-0.2.4.tar.gz.sig
If that command fails because you don't have the required public key,
then run this command to import it:
gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB
and rerun the 'gpg --verify' command.
Free Your JavaScript!
---------------------
<http://www.gnu.org/software/easejs/whyfreejs.html>
See the FSF's Free JavaScript Campaign at
<https://fsf.org/campaigns/freejs>.
Are you a JavaScript developer? Consider joining the campaign's JavaScript
Developers Task Force mailing list at
<https://lists.gnu.org/mailman/listinfo/js-devs-task-force>.
About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at
<https://www.gnu.org/software/easejs/manual.html> for more information,
examples, and implementation details.
0.2.3: GNU ease.js 0.2.3 released [stable]
This is the fourth release of the 0.2 series as part of the GNU project; it
is primarily a maintenance release, but does introduce a significant
(preview and undocumented) feature---parameterized traits. A generic
`super` method has also been added to satisfy more sophisticated subtyping
that `__super` alone cannot handle.
Changes between 0.2.2 and 0.2.3:
* `super` method now provided by method override wrapper
- Allows invoking arbitrary method on supertype to handle cases where
`__super` is not sufficient
- Documentation added to manual under the heading of ``Arbitrary
Supertype Method Invocation''
- Anyone relying on undocumented internal properties to achieve this
effect should now use this method instead.
- ease.js and its test cases now conform to ES5 strict mode
- Began ease.js metadata storage refactoring; those relying on
undocumented properties (e.g. ___$$*$$) should take note
- Please do not rely on undocumented behavior
- Test runner now passes option arguments to Node.js
- e.g. --debug and --debug-brk
- [bugfix] Subtypes of prototype subtypes no longer clobber ease.js
metadata
Trait support is currently under development and will be undocumented
until v0.3.0; it is included currently as a preview and is functional and
comprehensively tested, but incomplete.
* [preview] Parameterized traits
- C' = C.use( T( ...params ) ); ...params passed to T#__mixin by
reference upon instantiation of C'
- See NEWS (or website blog) and test cases for rationale and examples
- [preview bugfix] Corrected __length metadata on trait virtual proxies
- [preview bugfix] Corrected virtual non-overridden trait methods
Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
https://ftp.gnu.org/gnu/easejs/easejs-0.2.3.tar.gz
https://ftp.gnu.org/gnu/easejs/easejs-0.2.3.tar.gz.sig
Alternative download options are available at:
http://www.gnu.org/software/easejs/download.html
[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact. First, be sure to download both the .sig file
and the corresponding tarball. Then, run a command like this:
gpg --verify easejs-0.2.3.tar.gz.sig
If that command fails because you don't have the required public key,
then run this command to import it:
gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB
and rerun the 'gpg --verify' command.
Free Your JavaScript!
---------------------
<http://www.gnu.org/software/easejs/whyfreejs.html>
See the FSF's Free JavaScript Campaign at
<https://fsf.org/campaigns/freejs>.
Are you a JavaScript developer? Consider joining the campaign's JavaScript
Developers Task Force mailing list at
<https://lists.gnu.org/mailman/listinfo/js-devs-task-force>.
About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at
<https://www.gnu.org/software/easejs/manual.html> for more information,
examples, and implementation details.
0.2.2: GNU ease.js 0.2.2 released [stable]
This is the third release of the 0.2 series with a focus on interoperability
with vanilla ECMAScript/JavaScript. Three bugfixes address potential issues
when dealing with native prototypes. Additionally, GNU ease.js now considers
non-ease.js objects to adhere to an interface (without having to implement
it) so long as the object implements all methods and the proper number of
arguments, which allows users to integrate with ease.js classes without
having to use ease.js themselves. It further allows defining interfaces for
existing objects to ensure API conformance. Finally, to make definitions
more concise and more natural to prototypal developers, underscore-prefixed
members are now implicitly private; this can be overridden with an explicit
access modifier.
Changes between 0.2.1 and 0.2.2:
* [doc] Added interoperability chapter to manual.
* Members with an underscore prefix (e.g. _foo) are now implicitly
private.
- This can be overridden by explicitly specifying an access modifier.
- Follows common conventions in modern object-oriented languages and
permits concise definitions that are more natural to users of
JavaScript's native prototype model.
* This is backwards-incompatible if there is code that accesses
underscore-prefixed members as public or protected without explicitly
providing the visibility keyword in the member definition.
* Interfaces are now interoperable with vanilla ECMAScript objects
(including prototypes).
- This allows for runtime polymorphism within ease.js methods without
having to use ease.js.
- Also allows creating interfaces for pre-existing objects (e.g. W3C DOM
objects) to ensure adherence to an API.
* Generated classes now have an `asPrototype` method for use as a
constructor prototype.
- Defers execution of class constructor, allowing prototypal subclassing
(for those preferring not to use ease.js, but wish to extend a class
generated from it).
* [bugfix] Classes inheriting from prototypes will now properly proxy
assignments to properties on the prototype.
- Note that ease.js can only detect properties that are initialized in
the prototype's constructor; otherwise, you must manually declare it
public within the class definition to ensure proper proxying.
- [bugfix] Classes inheriting from prototypes will now properly handle
method overrides.
- Parent prototype methods are implicitly virtual, unlike ease.js
methods; see test/Class/InteropTest.js for rationale.
- [bugfix] Class.isInstanceOf once again attempts blind native instanceof
without preemptive function check.
- v0.2.1 first checked to see if the argument was a function to prevent
use of a try/catch; unfortunately, the proprietary browser IE9+ seems
to treat certain DOM constructors (e.g. HTMLElement) as objects rather
than functions, yet the `instanceof` keyword works with them. This
reverts that change.
Trait support is currently under development and will be undocumented
until v0.3.0; it is included currently as a preview and is functional and
comprehensively tested.
- [preview] Named trait staging of the form Trait("Foo") implemented
(analogous to Class("Foo")) and will no longer throw an obscure error.
- [preview] Trait API now exposed in combined source file.
- The v0.2.0 release exposed Trait via index.js, but the combined file
(intended for use client-side) was overlooked.
Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
https://ftp.gnu.org/gnu/easejs/easejs-0.2.2.tar.gz
https://ftp.gnu.org/gnu/easejs/easejs-0.2.2.tar.gz.sig
Alternative download options are available at:
http://www.gnu.org/software/easejs/download.html
[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact. First, be sure to download both the .sig file
and the corresponding tarball. Then, run a command like this:
gpg --verify easejs-0.2.2.tar.gz.sig
If that command fails because you don't have the required public key,
then run this command to import it:
gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB
and rerun the 'gpg --verify' command.
Free Your JavaScript!
---------------------
<http://www.gnu.org/software/easejs/whyfreejs.html>
See the FSF's Free JavaScript Campaign at
<https://fsf.org/campaigns/freejs>.
Are you a JavaScript developer? Consider joining the campaign's JavaScript
Developers Task Force mailing list at
<https://lists.gnu.org/mailman/listinfo/js-devs-task-force>.
About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at
<https://www.gnu.org/software/easejs/manual.html> for more information,
examples, and implementation details.
0.2.1: GNU ease.js 0.2.1 released [stable]
This is a maintenance release for the 0.2.0 series, including performance
enhancements and copyright assignment to the FSF. The copyright assignment
will allow the Free Software Foundation to enforce the project licenses and
ensures that GNU ease.js will always remain free (as in freedom).
Changes between 0.2.0 and 0.2.1:
* [copyright] Copyright assigned to the Free Software Foundation
* Private methods are no longer wrapped by ease.js
- There is no longer a small performance hit for using private methods;
they act as normal function calls on the prototype chain.
- Will not thwart tail call optimization attempts (when implemented by
engines).
- Various v8 optimizations to resolve instances of unoptimized code in JIT
engine
- Removal of unnecessary proxy fallback code for a buggy proprietary web
browser
- Performance test cases now output data in a generic format
- Began HTML report generation; nothing special yet.
Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
https://ftp.gnu.org/gnu/easejs/easejs-0.2.1.tar.gz
https://ftp.gnu.org/gnu/easejs/easejs-0.2.1.tar.gz.sig
Alternative download options are available at:
http://www.gnu.org/software/easejs/download.html
[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact. First, be sure to download both the .sig file
and the corresponding tarball. Then, run a command like this:
gpg --verify easejs-0.2.1.tar.gz.sig
If that command fails because you don't have the required public key,
then run this command to import it:
gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB
and rerun the 'gpg --verify' command.
About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at
<https://www.gnu.org/software/easejs/manual.html> for more information,
examples, and implementation details.
Thank GNUs
----------
Thanks to Donald Robertson III for his help and guidance during the
copyright assignment process.
0.2.0: Announcing GNU ease.js v0.2.0 and the Importance of Free JavaScript
I am pleased to announce version 0.2.0 of GNU ease.js, the first of many
releases as part of the GNU project. This release contains exciting new
features, a couple bug fixes, and extensive test case cleanup. The project
has also been relicensed under the GNU GPLv3+ to help in the fight against
non-free JavaScript (detailed below).
Changes between 0.1.1 and 0.2.0:
* [license] Relicensed under the GPLv3+ (previously LGPLv3+)
* [bug fix] this.__super now mirrors stack rather than being clobbered
after return from an ease.js method call
* [bug fix] Protected member overrides of super-supertypes are now
properly handled
* [preview] Support for traits as mixins
- This is an initial development preview of trait/mixin support
(motivated heavily by Scala) and is currently undocumented in the
manual.
- Complete documentation will be available once remaining trait TODOs
are addressed; until that time, see test/Trait/*Test.js for
comprehensive examples and rationale. Performance tests are available
in the test/perf directory for comparison with non-trait usage.
- The implementation is stable, but not yet complete; see README.traits
for more information.
- Proxy methods and the associated `proxy' keyword are now documented
(proxies were introduced in v0.1.1)
+ All older non-performance JS test cases are now part of the new suite
- Extensive test cleanup and consistent formatting
- All tests now contain rationale (as part of preceding comment block)
- Now uses autotools; see README for instructions
* v0.1 (LGPL'd) series is now unmaintained; users are encouraged to
upgrade to 0.2.0 and be mindful of the terms of the new license
The project's new home is now at <https://www.gnu.org/software/easejs>;
easejs.org now redirects to the appropriate page, and so you should not need
to update your bookmarks.
Getting GNU ease.js
-------------------
Here are the compressed sources and a GPG detached signature[*]:
https://ftp.gnu.org/gnu/easejs/easejs-0.2.0.tar.gz
https://ftp.gnu.org/gnu/easejs/easejs-0.2.0.tar.gz.sig
Alternative download options are available at:
http://www.gnu.org/software/easejs/download.html
[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact. First, be sure to download both the .sig file
and the corresponding tarball. Then, run a command like this:
gpg --verify easejs-0.2.0.tar.gz.sig
If that command fails because you don't have the required public key,
then run this command to import it:
gpg --keyserver keys.gnupg.net --recv-keys 8EE30EAB
and rerun the 'gpg --verify' command.
About GNU ease.js
-----------------
GNU ease.js is a classical object-oriented framework for JavaScript,
intended to eliminate boilerplate code and "ease" the transition into
JavaScript from other object-oriented languages. Features include simple and
intuitive class definitions; classical inheritance; abstract classes and
methods; traits as mixins; interfaces; public, protected, and private access
modifiers; static and constant members; and more. Please see the
comprehensive documentation at
<https://www.gnu.org/software/easejs/manual.html> for more information,
examples, and implementation details.
The Importance of Making JavaScript Code Free
---------------------------------------------
[For more information on the FSF's Free JavaScript campaign, please see
<http://www.gnu.org/philosophy/javascript-trap.html>.]
Web pages increasingly include JavaScript code, which raises the same
ethical concerns as software written in any other language: Non-free
JavaScript can rob you of your right to study, modify, and share the
software that you are running. Unlike traditional software, JavaScript
usually enters your machine without prompting and often without your
knowledge---the simple act of visiting a web page may install and execute
a non-free program within your web browser.
JavaScript provides an often frictionless cross-platform distribution
mechanism that can be exploited without your permission; this amplifies
the effects of some of the most insidious anti-features, such as spying
on your activities and tracking your movements. If a web page executes
non-free code, how are you able to audit it (or have someone else do so
on your behalf) to ensure that it is not malicious? Further, how are
you or others able to modify the software to remove the malicious code?
(Unfortunately, the latter can be complicated even with free JavaScript,
but it can be done.)
But non-malicious programs sometimes need changes too. You deserve
control over all software that runs on your computer; why should you
sacrifice this freedom simply because JavaScript creates the illusion
of remote execution?
How many web sites have you visited today that download JavaScript
onto your computer? How many of them respect your freedoms? I chose
to license ease.js under the GPLv3+ because I believe that non-free
JavaScript should be eliminated, not enabled. Please help to spread
the word and join me in writing free JavaScript; without it, we will
have an Internet that is locked away from free software users; this is
not the spirit in which the Internet was created.
More information on the JavaScript trap is available here:
<http://www.gnu.org/philosophy/javascript-trap.html>.
To join in on the FSF's Free JavaScript campaign:
<https://fsf.org/campaigns/freejs>
More information on free software and its freedoms:
<http://www.gnu.org/philosophy/free-sw.html>
Thank GNUs
----------
Special thanks to Brandon Invergo for his help during the GNU submission
process and for his auto{conf,make} advice and patches; RMS for extensive
proofreading and advice on "The Importance of Making JavaScript Code Free";
and the many others at the FSF and GNU Project that were involved in this
process.
0.1.1: Version 0.1.1 release
This release primarily addresses a fix (partial implementation) for
ES5 getter/setter 'this' bindings, but does sneak in a couple other things.
- [bugfix] Getter/setter 'this' binding now properly binds to the private
visibility object (just as methosd do)
- [bugfix] Documentation typo correction regarding class dfn keywords
- [bugfix] Corrected warning console output (invocation was incorrect)
- [bugfix] Corrected exception handling in XUnit-style tests
- Project is now hosted on Savannah; copyright notices, etc have been
added/corrected in order to comply with the project hosting guidelines.
- Preliminary 'proxy' keyword support. Incomplete and undocumented; see commit
d84b86 for more details.
- Added chk-linelen tool
- Added doc-html target
- It is an ongoing effort to convert old test cases over to the new style
As mentioned in 79cbc7, the getter/setter implementation will be completed with
regards to overrides, the abstract keyword, proxies and method hiding at a later
(hopefully soon) date; this bug fix should be sufficient for the majority of
uses and corrects a major flaw. (Please note that the bug only affected ES5
getters/setters.)
Please see the commit messages between this tag and the last for more detailed
information.
0.1.0: 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.
