Nalu 1.0.0 is released!

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#application/setUp

(The project generator is based on Nalu and uses Domino-UI (https://github.com/DominoKit/domino-ui) Thanks Ahmad 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.

J2CL is public!

Today, Google made J2CL public. The repo can be found here: https://github.com/google/j2cl.

Now, developers can test application and frameworks against J2CL Check, how Nalu (https://github.com/NaluKit/nalu) and MVP4G2 (https://github.com/mvp4g/mvp4g2) will work with J2CL.

A good point to start is using the project generators of MVP4G2 and Nalu:

* Nalu: http://www.mvp4g.org/gwt-boot-starter-nalu/GwtBootStarterNalu.html#application/setUp

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

Enjoy!

Nalu - A New Framework

Mvp4g is awesome and with the new version ready for J2CL. No doubt, a great framework. But it takes some time to understand it and it behaves different than other GWT frameworks we know (f.e.: GWT Activities & Places),

Based on a discussion with Colin Alworth and Ignacio Baca Moreno-Torres, the framework developer team started to rethinking the approaches of MVP4G and defined a list of goals, that a new framework should provide:

• Fully 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. (Handler have only access to the context and the event bus)
• Filters to intercept routing.
• Full history support.
• 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.
• Supports HTML links and programmatically routing thanks to a router.
• 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 classes
• Controller & component caching
• Component creation inside a controller to support GWT replacement rules and static factory methods
• Ready to use with J2CL

Based on that list we started implementing a new framework. The main idea is to use hashes for routing, with less coding and no worry about history.

Today, we are very close to release version 1.0.0 of this new framework!

The new framework is called Nalu.

You will find more informations about Nalu here: https://github.com/NaluKit/nalu

There are a few examples that shows how to use Nalu: https://github.com/nalukit/nalu-examples

And to start creating you own experiences, there is a boot starter project, that generates a ready to import Nalu Maven project:

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

The Project generator uses Domino-UI, a new awesome widget lib ready for J2CL!

If you have questions about Nalu, please use the Gitter Room.

MVP4G2 is released!

A few days ago we have released version 1.0.1 of MVP4G2.  

This version contains all features to build application using history and event handling. Most of the features of MVP4G are implemented (except those, which depends on GWT class or those which are not be able to implement because of the using APT). 

To start working with MVP4G2 you can:

* read the documentation: GitHub MVP4G2 Wiki 

* take look at the examples: GitHub MVP4G2 examples

* generate a project with the MVP4G2 project generator: MVP4G2 Initializer . The documentation of the MVP4G2 Initializer can be found here. 

MVP4G2 has no dependencies to GWT and does not use generators. 

MVP4G2 is tested against J2CL (thanks to Colin Alworth) and works!

Of course MVP4G2 also works with GWT 2.8.2 and any current available widget library (f. e.: native GWT widgets, GXT, widgets based on Elemento, Elemental 2, etc.)

MVP4G2 RC 2 is out!

MVP4G2 RC 2 is out!

This version fixes some issues related to the recompile and should be nearly ready to use with J2CL one it is available!

There is one known issue, which will be fixed with the next release candidate: The debug option will print debug informations in prod mode on the console. This problem will be fixed with release candidate 3.

Maven Central is updated!

MVP4G2 Beta 2

I just have updated mvp4g2.  

One of the major change is, that the historyOnStart-attribute has been remove from the @Event-annotation and been added to the @Application annotation.

Besides that a new feature is implemented that changes the way events and event handlers are defined. Now, it is no longer necessary to use the handler- or broadCast-attirbue inside the Event annotation to bind a presenter to an event. All you have to do now, is to define an event inside the event bus and annotate a method with @Event.

An event definition will look like this: 

@Event
void gotoDetail(long id);

Add this code to a mvp4g2 based  presenter or handler:

@EventHandler
public void onGotoDetail(long id) {
  ...
}

That’s all. Mvp4g2 will wire up the event with the handler method.

Of course the handler-attrnute as most of the other attributes from the mvp4g Event-annotation are still supported. 

You will find a list of features currently  implemented in mvp4g2 here: https://github.com/mvp4g/mvp4g2/wiki/Comparision:-Mvp4g-vs.-Mvp4g2

All examples have been updated.   

Next thing will be the implementation of the multi module feature.

Future of Mvp4g

At GWTCon 2017 in Florence Colin Alworth announced that Google has given access to J2CL for a small group of people outside Google and the work on GWT 3 has been started.

J2CL and GWT 3 will bring major changes to the GWT development.

As far as we know today, we will miss a lot of things we have in GWT 2.x:

• JSNI will be replaced by JsInterop
• Generators will be replaced by APT
• the widget system will be gone
• modules like editor, rcp, place management, events, etc. have to be updated 

(The people from vertispan are working on it. If you like to support them, get in contact with Colin!)

Looking at mvp4g 1.x we can say, that it will not work with J2Cl without a major reengineering. mvp4g 1.x is based on a generator and has dependencies to several third party libs. Generators will be gone in J2CL / GWT 3 and some of the third party libs will not work (f.e.: GIN).

A few month ago, the work on mvp4g version 2 started. The goal is to implement a new version of mvp4g, which will work with J2CL and GWT 3. In December 2017 I made the beta of the new version public.

You will find mvp4g2 here: mvp4g2

A lot of the mvp4g features are already implemented, some feature have changed, some features will be dropped and new features have been added.
For example a loader at application start feature is added and a new way to add a presenter/handler to the event bus. 

A list of currently implemented, changed or dropped features can be found here:  Comparsion: Mvp4g vs. Mvp4g2. We will work on mvp4g2 so that it will be final once GWT 3 is available.

There are a few examples already implemented, that use mvp4g2 and different view implementations. The examples can be found here: mvp4g2 examples 

The example called 'Mvp4g2SimpleApplicationUsingElementoAndEventHandlerAnnotation' uses the new way of event handling registrations and Elemento to create the views.

During the next months I will follow up with more posts describing the changes of mvp4g2 more detailed.

Feedbacks are welcome.  

(Please, keep in mind, that mvp4g2 is still beta. The validation and error messages needs to be improved and the documentation is not up to date.)