Nalu is released!

[Frank Hossfeld]

After finishing the work on the 'plugin'-feature and a lot of testing, Nalu v1.0.0 is released and the artifacts are deployed to Maven Central.

Nalu is a framework that helps you to create GWT applications similar to GWT Activities & Places - with less code - and offers the following features:

* Route based navigation

* Supports HTML links and programmatically routing thanks to a router.

* Full support of the browser's back- forward- and reload-button.

* An optional loader that will be executed at application start to load data from the server.

* A client side context, router and event bus which will be automatically injected in every controller, filter, loader and handler. (Handler have only access to the context and the event bus)

* Filters to intercept routing.

* Separation of views into a controller and a component with framework sided instantiation.

* A controller life-cycle using `start`-, `mayStop`- and `stop`- similar to GWT Activities.

* Controller based handler manager, that will remove all handlers from the event bus in case the controller is stopped to prevent memory leaks (handler registrations must be added to the manager).

* Support for UiBinder (nalu-plugin-gwt)

* Nalu composites to support smaller units

* Controller & component caching

* Component creation inside a controller to support GWT replacement rules and static factory methods

* Multi Shell Support

* works with nearly every widget lib (tested with: GWT, GXT, Domino-UI, Elemento, Elemental2, GWT-Meterial) 

* Supports Maven multi module projects to separate an application in smaller parts (plugin feature)

More informations about Nalu can be found here:

https://github.com/NaluKit/nalu

There are already several examples available that shows the implementation of Nalu's features and how to create an application using Nalu:

https://github.com/nalukit/nalu-examples

To start playing around, you can use the Nalu Project generator located here:

http://www.mvp4g.org/gwt-boot-starter-nalu/GwtBootStarterNalu.html

(The project generator is based on Nalu and uses Domino-UI (https://github.com/DominoKit/domino-ui) Thanks @vegegoku for creating the UI)

To get in touch with the developers, use the Nalu Gitter room: https://gitter.im/Nalukit42/Lobby 

Last but not least, I would like to thank everybody who helped getting Nalu done.

[Alain Ekambi]

Dope !

--
You received this message because you are subscribed to the Google Groups "GWT Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email to google-web-tool...@googlegroups.com.
To post to this group, send email to google-we...@googlegroups.com.
Visit this group at https://groups.google.com/group/google-web-toolkit.
For more options, visit https://groups.google.com/d/optout.

[Pavlo Iatsiuk]

Hi Frank, 

I see that you are an owner of Nalu and MVP4G projects. 

Could you please give a small description and advices which one is better for which cases?

[Frank Hossfeld]

Hi Pavlo,

yes, you are right. I am the Owner of the Nalu & Mvp4g project.

First, looking at mvp4g, I would say, that mvp4g is an awesome framework. I used it successfully in many projects in the past. But today, I would not start a new project with mvp4g. Mvp4g (which was origanally created by Pierre-Laurent Coirier) uses heavily GWT generators. So, with J2CL going public it is not the best voice. 

Let's look at mvp4g2. I have rewritten mvp4g and replaced the GWT generators with annotation processors. mvp4g2 is tested with J2CL and will be no show stopper switching from GWT 2.x to J2CL / GWT 3! My intention to create mvp4g2 is to give the mvp4g users an easy upgrade path for the future. As you can see on this page, most of the features of mvp4g has been implemented in mvp4g2: https://github.com/mvp4g/mvp4g2/wiki/Comparision:-Mvp4g-vs.-Mvp4g2, so it might be easy to upgrade. There are only a few changes. (Of course, Nalu will work with J2CL, too!)

Last year I had a discussion with Ahmad and Colin, which - in the end - let me create Nalu. In my opinion, Nalu is a more modern and web-like framework than mvp4g/mvp4g2 is. So, let me compare mvp4g2 with Nalu (the big points):

* history:

In mvp4g2 you have to work with history converters, write them and manage everything. In Nalu, cause it uses the url to route, you have nothing to do for getting  history done. It works out of the box. (Starting with version 1.2.0 you can tell Nalu to avoid using a token in the url). Nalu can work with url or with a hash. It is just a annotation attribute to switch it. So, I would say, Nalu is more web like compared to mvp4g2.

* life cycle:

In mvp4g2, once a presenter view, is created, it will be reused all the time (except for the case you mark the presenter with multiple=true, but in this case you have to create it). In Nalu, a controller (it is the same like a presenter in mvp4g2) has a life cycle: start - activate - mayStop - deactivate - stop. If case it is needed, a controller can be cached (which will reuse the instance of the controller & component). The life cycle thing was one of the points many mvp4g users have missed. Nalu works here like many other GWT frameworks!

* confirmation:

This is a big deal! In mvp4g2, the confirmation is asynchron. I tis possible to do a server call, before to decide to leave the page. In Nalu the mayStop method is synchron! Nalu works here like many other GWT frameworks!

* visible components:

In mvp4g2, you have to deal by yourself where to add views. In Nalu, the framework will do the replacement of the widgets. All you have to do, is to make sure, that a node with the selector id exists. And, with Nalu it is quite easy to work with different application layouts, because the shell is part of the route. I personally prefer the Nalu way to manage the views.

* logging

During development, Nalu logs a lot on the browser console which makes it easier to understand, what the framework does. 

* context

Nalu supports an application wide context (to store application infos) and injects it into every filter, handler and controller.

Nalu and also mvp4g2 have both an event bus, provide features like filters, handlers (controller/presenter without views) and inject instances of the eventbus, the view/component, the context and the router into every controller / presenter.

But, in my opinion Nalu does it with less code and a little bit more elegant, is more like a web application framework than mvp4g2 and I am pretty sure, Nalu will also work on the server side (if there is a plugin). If you would ask me, which one I choose, I would go with Nalu.

If you have any questions, feel free to contact me here: https://gitter.im/Nalukit42/Lobby

If you want to play around with both frameworks, you can generate 

* mvp4g2 projects here: http://www.mvp4g.org/gwt-boot-starter-mvp4g2/GwtBootStarterMvp4g2.html

* Nalu projects here: http://www.mvp4g.org/gwt-boot-starter-nalu/GwtBootStarterNalu.html

More informations about mvp4g2 can be found here: https://github.com/mvp4g/mvp4g2

More informations about Nalu can be found here: https://github.com/NaluKit/nalu

There are many examples projects:

* for mvp4g2: https://github.com/mvp4g/mvp4g2-examples

* and even more for Nalu: https://github.com/nalukit/nalu-examples

Last but not least, I would say, regarding the last month, Nalu is more popular than mvp4g2.

Hope that helps!