Key Characteristics

ActiveJS has many unique and many not so unique qualities, but each quality is cherry-picked and serves a well thought out purpose. Probably the strongest point of ActiveJS is that all these qualities come in a single package, which serves our goal of reducing the complexity by reducing the number of moving parts.

(in no particular order) ActiveJS is:

Intuitive

ActiveJS tries to not drift too far away from vanilla JavaScript and re-employs many well-established concepts, albeit in a slightly different way. We believe this enhances the developer experience and makes our lives a little bit easier.

Reactive

Every fundamental ActiveJS construct is an Observable and every built-in operation has a dedicated Observable event. In order to achieve full reactivity, every operation has a reaction, even if it's not equal.

Proactive

Instead of relying on implicit and sometimes confusing data-processing (i.e. reducers), ActiveJS promotes proactive processing of data using value-producers, so that you can write functional, easily testable code, without breaking the flow of code.

Less verbose

Less code isn't always a good thing, but neither is more code. We're firm believers in the "no code, no bugs" philosophy. ActiveJS is not necessarily the least verbose, but we built ActiveJS keeping verbosity in mind, and it was also one of the motivations behind building it.

Less obscure

We believe having independent storage Units helps reduce a lot of façades, which is otherwise essential for single store solutions. This allows us to keep the number of abstract utility concepts needed at a minimum. Also, we deliberately keep the abstraction at a minimum to avoid any unnecessary confusion.

Strongly-typed

ActiveJS is developed in TypeScript and it's strongly-typed, which brings all the benefits of a robust typings system, faster development, and fewer surprises to say the least.

Cache-enabled

Units can cache up to Infinite number of values, which makes operations like replay, undo, redo, or jumping to a specific point in the cache very easy; in other words TiMe-TrAvEL is possible. Other constructs like Cluster, Action, and AsyncSystem also cache one value, so you can replay it on demand.

Immutable

Units are responsible for holding the state, and making these Units immutable is as easy as setting a configuration flag. Units implement immutability in such a way that it doesn't become a bottleneck.

Persistent

Making a Unit persist it's value in the LocalStorage or SessionStorage is as easy as setting a configuration flag. Since the Units are independent, making a Unit persistent is very performant and efficient.

Efficient

Units only allow allocated type of value to get through, which avoids the need for many validity and sanity checks. All Units also have the built-in capability to ignore duplicate values, to avoid unnecessary overhead. There's no single store, independent Units hold the state, and changing the value of a Unit doesn't trigger change detection all over the place.

Configurable

ActiveJS gives you the opportunity to configure it in your own way. Although it's already configured with sensible defaults, the options are there so that you can fine-tune it according to the task at hand.

​

These are the most prominent characteristics of ActiveJS, but they won't amount to anything if the DX is not enhanced, because that's the end goal of ActiveJS. Hence, the Developer Experience is of utmost importance, and every decision is made keeping DX in mind. That's what ActiveJS is all about, being pragmatic rather than idealistic.