Working my ass off lately to get NYX (Not Yet Xulux) into a representable state for the autside world. At the company I work for we are already doing a lot of cool stuff with NYX and it reduced our development time tremendously. Atm we just write some simple xml, feed the parts (or forms, whatever you prefer) a bean and everything just works and keeps on working.
My target is to cut a release by the end of the year, so I can easily have my month in february without programming, since I need to move and put the new house in a better state than it is now.
Before the release and before anyone wants to use it : please wait for nyx to migrate to XULUX, since all package names will be refactored for that move to org.xulux instead of org.xulux.nyx.
Still on my todo list are :
- More widgets (still some basic widgets are missing if you want a complete application written in nyx)
- Make widgets completely gui independend. In rules you request widgets and sometimes cast to eg the Button widget, which is atm swing related.
- Make widgets creation configurable (eg a propertyhandler,etc)
- Create the dataprovider API, which will drive the data / gui / data interface (now only has some advanced bean support)
- Start developing on SWT widgets.
- Finish refactor of rule engine
- Optimize code and improve test coverage.
The release will be seperated in a core package and different jars for eg swing, swt, rule engines and extensions to the default swing / swt packages. This way I can keep nyx pretty small and have people choose which options they need.
I'll try to have some kind of update to the site today, so there are more recent docs on there (which are pretty much out of date).
You can find nyx at http://nyx.xulux.org and xulux at http://xulux.org
I do not always nicely check for nulls (forgetting that or something). When I was debugging when something was null anyway (which should never happen in this case), I stumbled on something that I didn't know about java..
If you have this code snippet :
Test test = null;
test.setValue(new Test().getValue());
It will actually run the net Test().getValue() first and then throw a npe, because test is null.
This means : allways for nulls to save some useless time (if the parameter is conquer the world, it can take some time :) and even in some cases you want to have npe's thrown, check for null and if null throw a npe yourself.. At least no useless code is executed anymore.
This is probably known by everyone who read the java specs, but I am not much of a reader :) (I tend to fall asleep when reading too much :)