Blog.Project13.pl » netbeans

git-hacking: pre-commit hook and custom command

Ktoso — Sun, 21 Nov 2010 02:07:39 +0000

As my team is using a kinda weird source eclipse code formatter setup, that other IDEs can’t emulate in 100% I sometimes found myself committing in a file with only a few changed spaces. Of course, I could use “external-formatter” plugins etc but that’s no good. Running eclipse’s formatter each time I want to format my source (_very_ often) proved to be too slow and really getting on my nerves.

So… Since I’ve started using git-svn at work, I do have an possibility to make things better now! The answer lies in client-side-hooks and git aliases (“custom commands”). First let’s write this as an simple bash script, that we’ll locate in the .git/hooks/ folder:
It’s a fairly simple script, so I wont bore you explaining it in detail – if in doubt, feel free to ask. We only need to place this script as “.git/hooks/pre-commit” and make it executable and git will take care of the rest for us. Oh and in case you’re wondering where that org.eclipse.jdt.core.prefs came from. It’s created by eclipse into the .settings folder when you check some option to “use formatter per project” – that’s the only time I had to fire up and click around in eclipse to get it’s formatter running “headless”. Ok, let’s check if it works…

Yup, you can agree or not with the formatting rules – but what matters is that the whole team decided on it and that we keep it consistent throughout the whole project. This hook will definitely help with this. :-) Step two for me was changing this into a git command, so that I wouldn’t launch eclipse each time I just do some quick local commiting. The solution is to drop the hook idea (although it’s quite nice) and create an custom git command. We do this by doing an alias like that:

git config --global alias.eclipse-formatter '!~/git-hook-eclipse-formatter'

The !command alias support is with us in git since 1.5.0 and it enables us to launch any program/script as an git command. Great, just what I wanted! Let’s now see what this command really did:

As you can see, adding an alias is as simple as adding it to your ~/.gitconfig or, if you want to setup the alias “per project”, to .git/config – pretty cool, ay? Also, this command will be included in bash-autocompletition suggestions! :-)

That’s it for today… happy hacking!

NetBeans Platform Lookups as communication method

Ktoso — Sun, 23 May 2010 14:54:28 +0000

Helo again! Today’s post will be an super quick usage scenario for NetBeans Platform Lookups – the probably most essential part of the Platform. An super simple explanation of them is “an Map”. Sounds simple right? Well it is, and it’s quite powerful at the same time. It enables you to loosely couple parts of your app, create extension points etc. Another use case is passing some date around in the app, but you don’t know where the modules interested in this data are (because you’re loosely coupled, right?). In an app I’ve been writing for my Uni since some days, I’ve used the Lookup to do exactly this – pass data from an algorithm to an LineChartDrawer that then will update it’s chart each time the data is being updated.

This is going to be quite similar to an Observer Pattern implementation, but using the lookup as notification mechanism. Let’s start out with our Algorithm class (and module – note that this module is not dependent on the chart drawing module!)

package pl.edu.netbeans.algorithms;

import org.openide.util.Exceptions;
import org.openide.util.Lookup;
import org.openide.util.LookupListener;
import org.openide.util.lookup.AbstractLookup;
import org.openide.util.lookup.InstanceContent;
import org.openide.windows.TopComponent;
import org.openide.windows.WindowManager;
import pl.edu.netbeans.algorithms.genetic.Chromosom;
import pl.edu.netbeans.algorithms.genetic.Population;
import pl.edu.netbeans.toolbox.ChartDataDTO;
import prefuse.data.Graph;
/**
* The algorithm implementation, does some stuff and throws the data into an DTO which is packed into the lookup
* @author ktoso
*/
public class FirstTSSolverAction extends SolverAction implements TSSolverAction, Lookup.Provider {
private final Population population;
//just to get us some fancy names for this algorithm
private static int simcount = 1;
private final String SIMULATION_ID = "symulacja " + FirstTSSolverAction.simcount++;
/*
* Here we're setting up the Lookup, to work with dynamic content, thanks to this,
* we'll be able to modify it's contents and notify all listeners after some change has happened
*/
private InstanceContent dynamicContent = new InstanceContent();
private Lookup myLookup = new AbstractLookup(dynamicContent); //AbstractLookup is NOT an abstract class, it's an "general purpose lookup"
private Lookup.Result res; //this is only here because I want to use allItems down there bellow, otherwise it would be just a variable in the method bellow
public FirstTSSolverAction(Graph graph) {
super(graph);
//…
}
/**
* This is not an Runnable class but the run method will act quite the same as if it was,
* as our framework will call it in constant time delays. We do all the computing here.
*/
@Override
public void run(double frac) {
if (population.shouldStop()) {
//… stop the execution etc.
return;
}
population.nextGeneration();
Chromosom ch = population.getBestChromosom();
int numerGeneracji = population.getNumerGeneracji();
double avgFitness = population.getAvgFitness();
double maxFitness = population.getWorstFittness();
double minFitness = population.getBestFitness();
log("Generacja " + numerGeneracji + ": naj. chromosom: " + ch + " (" + avgFitness + ")");
/* Słuchający tego lookup zostaną powiadomieni o zmianie, przerysują wykres */
dynamicContent.add(new ChartDataDTO(SIMULATION_ID, numerGeneracji, avgFitness, maxFitness, minFitness));
res.allItems();//I found it quite helpful in order to be sure that the listeners will notice the change
}
//…
/**
* Since we're an Lookup.Provider, let's provide our lookup!
* It can be implemented in multiple ways, but let's just return our lookup this time.
*/
@Override
public Lookup getLookup() {
return myLookup;
}
/**
* Poszukuje oraz ustawia listenera implementującego LineChartDrawer
* aby ten reagował na każdorazową zmianę w naszym lookup – aktualizował wykres
*/
@SuppressWarnings("unchecked")
private void setupLineGraphDrawerListener() {
//a sucky but good enough implementation for our usecase
//Better solution: You could use another Lookup to find implementations of the "LineGrapghDrawer" interface and then use this instance here!
TopComponent drawer = WindowManager.getDefault().findTopComponent("FitnessGraphTopComponent");
if (drawer == null) {
//depending on if you need this or not, throw exceptions or just ignore this if you dont need it
//throw new RuntimeException("Nie znaleziono implementacji FitnessGraphTopComponent. Nikt mnie nie słucha!");
//or…
log("No FittnessGraphTopComponent found. That's OK, so I will continue without it…");
return;
}
//below is the actual settup of our "observer"
res = myLookup.lookup(new Lookup.Template(ChartDataDTO.class)); //setup the resultset to react to changes of ChartDataDTOs in it
res.allItems();//THIS IS IMPORTANT! Help out the lookup by "refreshing" its contents
res.addLookupListener((LookupListener) drawer);//setup the listener to the drawer we found
}
}

The code is well commented for this post so take a moment and read through it. It’s just some pieces of the actual class we’re using – so no actual computing stuff is shown here, let’s focus on the lookups. Note that I’m getting the TopComponent that I’ll add as an listener “by name”, it’s super simple but would you need to “find some implementation of some drawer interface” just use an lookup and get the instance, or even all the instances of such interface implementations. That said, this solution is not the most universal here (getting the instance) but it’s good enough for our app since it’s a very small application. No let’s look at the “Observer”, better named as “LookupListener”:

package pl.edu.netbeans.visualization;

import java.awt.BorderLayout;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Logger;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot;
import org.jfree.data.xy.XYDataset;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.openide.util.NbBundle;
import org.openide.windows.TopComponent;
import org.openide.windows.WindowManager;
import org.netbeans.api.settings.ConvertAsProperties;
import org.openide.util.Lookup;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import pl.edu.netbeans.toolbox.ChartDataDTO;
import pl.edu.netbeans.toolbox.LineChartDrawer;
import prefuse.Visualization;
/**
* Top component which will draw graphs for all the data it gets…
*/
@ConvertAsProperties(dtd = "-//pl.edu.netbeans.visualization//FitnessGraph//EN",
autostore = false)
public final class FitnessGraphTopComponent extends TopComponent implements LookupListener, LineChartDrawer {
private static FitnessGraphTopComponent instance;
private static final String PREFERRED_ID = "FitnessGraphTopComponent";
//… skipped all the computing/drawing stuff
public FitnessGraphTopComponent() {
initComponents();
setupChart();
setName(NbBundle.getMessage(FitnessGraphTopComponent.class, "CTL_FitnessGraphTopComponent"));
setToolTipText(NbBundle.getMessage(FitnessGraphTopComponent.class, "HINT_FitnessGraphTopComponent")); //note how easy it will be to internationalize this app :-)
// setIcon(ImageUtilities.loadImage(ICON_PATH, true));
putClientProperty(TopComponent.PROP_CLOSING_DISABLED, Boolean.TRUE);
putClientProperty(TopComponent.PROP_MAXIMIZATION_DISABLED, Boolean.FALSE);
putClientProperty(TopComponent.PROP_SLIDING_DISABLED, Boolean.TRUE);
}
//…
//skipped graph drawing/setup parts, this post is about lookups only ;-)
//…
@Override
protected String preferredID() {
return PREFERRED_ID;
}
/**
* This is our resultChanged listener. It will be called if the resultSet we're observing is changed.
* Note that "changed" means all CRUD operations on it.
*/
@Override
public void resultChanged(LookupEvent ev) {
Lookup.Result res = (Lookup.Result) ev.getSource(); //this is always an safe cast!
Collection instances = res.allInstances(); //we get all instances from the lookup
if (!instances.isEmpty()) {
Iterator it = instances.iterator();
while (it.hasNext()) {
Object o = it.next();
if(o instanceof ChartDataDTO){//you might wan to use this – better safe than sorry, check if you got what you expected!
ChartDataDTO o = (ChartDataDTO) it.next(); //If not sure if this will always be the case, use an if( instanceof ) here!
addDTO2Series(o);
}
}
}
}
private void addDTO2Series(ChartDataDTO chartDataDTO) {
//…add the stuff to the graphs…
}
//…
}

That’s about it. We simply have an resultChanged() method that will be called if the contents of the resultset are changed. We might also want to arr more lookups to be observed, so it’s better to check this instanceof I think than not, since there might be some unexpected stuff inside of it…

All in all, you write an Lookup.Provider and LookupListener, implement both’s methods and then at some place in your app hook them up. It doesn’t really matter “who looks for who” as long as it’s consistent and logical. In this case, the algorithm is looking for people interested in his data. Note that at any moment in time, we can add another listener, no problems here. Note that the Lookup.Provider and LookupListener are quite similar to the Observer and Observables mentioned before.And the good thing is, the algorithm does not know about any concrete drawer, and the drawer has no idea about some algorithm. They just have one shared API module – the toolbox, in which there is the DataTransferObject we’re using to pass the data from one to another – yay, an loosely coupled system. (yeah, I know our code is tightly coupled at some other places, but this part is quite ok :-))

If you have anything you’d like to comment on this code, feel free to do so. It’s just parts taken from http://github.com/ktoso/TravelingSalesman-NBP our implementation and visualization of the Traveling Salesman Problem being solved by Genetic Algorithms.

For more information about lookups goto: a nice post by Anton Epple on dzone.com or to Geertjan’s post with some good links or http://www.antonioshome.net/blog/2008/20081023-1.php

Update! Geertjan contacted me and suggested I’d post this on netbeans.dzone.com as it’s quite an interesting post – and so I did :-) You can read and comment it now on dzone.com. Hope to get some feedback if this is good or bad code, would be quite helpful :-)

After the NetBeans Certified Platform Training in Kraków (2010)

Ktoso — Fri, 30 Apr 2010 13:55:32 +0000

Amazing days and awesome people

It’s been some amazing days for me during (and before) the NBPTraining. As you probably know already – I’ve been the “one-man-army” behind the organization and basically everything around this training. I got lots of help from various people, such as Dr Jarosław Wąs (from KN Glider) – it wouldn’t have been possible to make this training such an success without his great and very active support. And of course – the PolishJUG, which I’m a proud member of! :-) But one thing I have to admit, Bureaucracy is a horrible thing and really made some things (needlessly…) difficult – thank goodness in the end, we had everything well organized – as Geertjan put it on dZone:

[...] There are also some illustrative pics to share, to give an impression of the group (really large), the trainers (really busy), and the organization (really good) [...]

Day 0: Welcome Dinner

What’s so worth mentioning about the guys just coming here anyway? Well it was a quite trip for some, especially Geertian, who had to come by train which took him about 27hours instead of just coming by car from Prague. All because of Eyjafjoell‘s eruption last week… And Toni and Geertjan were in Oslo at that time, doing a Training for an company (btw nice interview with Gunnar Reinseth) – so we were worried if they’ll be able to come to Poland due to all the flights being cancelled… Anton was lucky and but Geertjan’s original flight got cancelled… Well, he had quite an interesting journey as he called it himself :-) Later when Karol joined us and soon we all went to eat some pierogi and chat a little :-)

Days 1 & 2: The Training

Thanks to dr Wąs everything went smooth and without any problems… Even though some other students also wanted to use the room we had reserved – due to the chaos caused by the tragic plane accident and them wanting to make up for the classes they’ve lost last weekend due to the burial ceremonies… I’m really glad we managed to get the training rolling with absolutely no problems – we were really prepared for everything, along with backup projectors etc ;-)

If you’re not very familiar with the Java World – please note, that the training was NOT about NetBeans IDE. Yeah, we did use NetBeans IDE (there’s some nice little helpers/wizards), but that’s absolutely not a must – NBP is pure Java (just a bunch of jar’s) and XML – so you can use anything you want to code stuff based on NetBeans RCP. That said, the training was about real coding stuff such as patters used in the RCP, use-cases and “ how do I code such a feature to scale well?”.

The agenda was the basic NetBeans Platform Training as outlined on http://edu.netbeans.org/courses/nbplatform-certified-training/ that’s a good thing, as only a few students actually have used the NetBeans RCP (or even ANY RCP) in their lives. The level of participants was quite diverse, some saw loose coupling in action for the first time in their lives, and others were already planing some advanced use-cases foe the things we were learning. The sources and videos for most of the examples are also hosted on netbeans.edu.pl, so if you want to know what you’ve missed, feel free to download/watch them (if interested in FullHD versions, contact me per email). The Lookup and Nodes/Explorer Views were the most interesting features of the platform I guess. Of course having an full blown app with menus etc out of the box is also nice, but not a “life changer” if it weren’t for those mechanisms. Sadly we didn’t talk about the Lexer API (for parsing languages) but I personally talked with the guys a little about it – and why schielmann was dropped etc… A really fun and interesting insider talk :-) I simply love such conversations…

After the training Geertjan gave away a copy of his book (“Rich Client Programming”), to the person who asked the best, most interesting questions during the course. Of course it was then signed by all the trainers. Sadly I don’t have a picture of the books’ winner, nonetheless – congratulations! After the training I also asked the guys to sign my copy of the book, hurray for signature collectors ;-)

Anyone interested in some of the response I got concerning the training? After the training plenty of you mailed me and thanked via forums etc, here’s a few responses:

przyznaje, na prawde baaaardzo fajne szkolenie

Faktycznie – świetna robota. Wielkie dzięki ;)

Tru. Gj.

[...] nie udalo mi sie zjawic a slyszalem ze bylo super ;/

[...] bedzie problemem jesli przyjde jutro na to szkolenie NetBeans’a? Bo slyszalam ze duzo ciekawych i przydatnych dla mnie rzeczy jest wiec chcialabym sobie posluchac :)

Big big thanks to all of you, I’m happy you enjoined the training. You may want to check out Geertjan’s take on it on dZone.

See you next time!

I hope you all enjoined the training – we certainly did. I’ve got some opinions from happy participants, so I guess everyone liked it as much as those did.

If you have anything (opinions, sources or even complaints) feel free to contact me: kmalawski@project13.pl or just leave a comment here :-) Also, when you get your NetBeans Certified Engineer and would like some more promotion for your open source project – let me know and we’ll add a link to it at netbeans.edu.pl!

Some students have already have started their projects based on the NetBeans Platform – so what are you waiting for?! ;-)

What’s next for me?

Well, I’m going to GeeCON, to learn about Gradle, and tap into facts and myths about JSF and other things (the list of good topics is really long so I wont list them all here, just have a look on your own). The agenda mostly caught up my attecion and I’m really happy to be going there. What’s new for me + conferences is that I don’t have to go alone anymore. I’m going with a friend (some years older) and potentialy another girl – as she won the Google trip to GeeCON… ;-) I’m also really happy to be able to meet Adam Dudczak, thanks to whom the whole NBPT idea got ignited in me and the NetBeans Guys :-) Of course we’ll meet up with all the PolishJUG members, (Adrian Nowak, Radosław Holewa, Marcin Gadamer and Kuba Dżon) and Miroslav will be comming too – lot’s and lot’s of programming-friends :-) Seems like Toni and Geertjan will also be comming, yay! Yeah, so that’ll be 3 days in May… but that’s not the end of my Java related stuff in May:

Later in May I’ll be on an Spring Source Training. It’s only the “short introductory one”, and I’m well aware that it won’t make me an spring-guru, but an insider insight about Spring, Roo or Grails is also a good thing to have.

By the way, did you notice that the netbeans.edu.pl is running on Grails? I’ll release it’s sources when they’re polished enough~! Viva la free software.

Geertjan, Toni, Konrad (me), Karol

Oh, and for those asking: Sadly I didn’t own an PolishJUG T-Shirt at the time of the training, so I took the most Java related I had – from Java Developers Day. Also a quite nice conference… :-)

NetBeans Platform Certified Training Kraków 2010

Ktoso — Thu, 08 Apr 2010 20:53:56 +0000

NetBeans.edu.pl

Since Poznań JUG’s NetBeans Platform Training in January (yeah, the one where there was no place left for me ;-)), I’ve been in contact with Poznań JUG‘s Adam Dudczak, Polish JUG‘s Adrian Nowak, Sun’s Geertjan Wielenga and Eppleton’s Anton Epple and many more… And a little later Karol Harezlak joined the training team. We’ve been planing to organize an NetBeans Platform Training in Cracow – since there was really an gigantic response to the training. Now it’s April… and just around two weeks to the NetBeans Platform Certified Training Kraków 2010 ;-) All this could not have been possible if not the great help and support from both JUGs and an amazing amount of help we got from Glider from my University. Also I’d like to give a big thanks to everyone I’ve met during this long process of organizing such an meeting – you’ve all been a great help! :-)

Allright, so what’s this NetBeans Platform all about? To put it simply, it’s “something” (a platform ;-)) that allows you to use all the stuff you see when you do your daily coding in the NetBeans IDE and code up your own application really quickly. While WebFrameworks are really popular and there’s a ton of them, there is not much (worth mentioning) “Desktop App Frameworks” as one might call them. Such apps are then called Rich Client Applications (just a fancy name for “Desktop Apps” ;-)), which makes NBP an Rich Client Platform… You may have heard about “Eclipse RCP” or “SWT” or “Spring RCP” – they’re in the same legue as NBP. But why is NetBeans RCP more interesting than the rest? Well here’s a cupple of reasons I personally find important:

It’s all swing based, and as Java programmers – we know swing, not necesarrily some “SWT” or “Swing RPC” – right? Less totaly new stuff = better learning curve.
Your app gets an windowing system abstraction, file system abstraction, lots of GUI elements out of the box – Tree’s etc
You can just extend NetBeans IDE or build your own app that looks like an IDE… or doesn’t look like one ;-)
It’s 100% modular – that means you can use just the stuff you want, or can easily exchange or “lookup” (important word in the NetBeans world) stuff in order to develop apps that can handle plugins and are easily extendible.
There are quite some inteligent and interesting opinions about NetBeans RCP vs Eclipse RCP on Adam Bien’s blog – (found this blogpost thanks to @timoreilly)

I find the Lexer Api quite interesting but didn’t have the time to really dive into it yet – basically it allows you to write programming language parsing, support into your app or netbeans IDE.
The most amazing… Hmm let’s say “the most visually amazing” app based on the NBP I’ve seen is Gephi (video below). There are lot’s of very complicated apps for biology or airlines and stuff) based on NBP, but let’s face it such apps don’t create an “WOW” effect, unless you totaly understand what’s going on inside of it.

Take a deep breath, and enjoy
NetBeans Platform + Gephi = Graph Awesomeness

All that said… I hope that the Training in Cracow will be a nice experience for every participant
see you there – 24+25 April 2010.
netbeans.edu.pl

NetBeans Platform Training 2010

Ktoso — Wed, 06 Jan 2010 01:16:40 +0000

Yeah! It’s time for another great JUG meeting. I’ll have to go quite far this time, as it’ll be in Poznań and that’s about 7h by train from Cracow… but at the very moment I saw who was going to be there, that is: Geertjan Wielenga (whose blog I’ve been reading for a long long time and also Romuen Strobl’s pal from the Netbeans team) and Tony Epple, I just knew I can’t miss such a 2-day crash course about NetBeans Platform. I’m mostly interested in EE stuff and didn’t really look all so much into SE apps (just the few while I was very fresh to Java) and this’ll be a great opportunity to see the NBP in action and explained by the pr0s!

It would seem that I’m not the only person who’s excited about this JUG Meeting as during only one day, already 42 out of 45 possible attendands got registered! I already got my Hotel booked and tommorow I’ll buy the train tickets. Oh, and one more great thing this trip. My girlfriend will some with me so after I code some stuff we’ll check out Poznań – some people told ma that it’s a really nice city. :-)

More information can be found here: (in polish) http://www.jug.poznan.pl/2010/01/bezplatne-szkolenie-netbeans-platform/ or here: http://www.jug.poznan.pl/materialy-ze-spotkan/netbeans-platform-training-2010/ (in english)

—EDIT—

Sadly I wasn’t able to go to this meeting since there were no free places left for students from outside Poznan. I guess thats understandable since they are Poznań JUG, so they want to teach Poznań students more than Cracows students ;-) As sad as that has been for me, something even better came out of it! What? Well, just wait a month or two and I’ll let you know JavaGeeks!