When running a Maven build with many plugins (e.g. the jOOQ or Flyway plugins), you may want to have a closer look under the hood to see what’s going on internally in those plugins, or in your extensions of those plugins. This may not appear obvious when you’re running Maven from the command line, e.g. via:
C:\Users\jOOQ\workspace>mvn clean install
Luckily, it is rather easy to debug Maven. In order to do so, just create the following batch file on Windows:
@ECHO OFF
IF "%1" == "off" (
SET MAVEN_OPTS=
) ELSE (
SET MAVEN_OPTS=-Xdebug -Xnoagent -Djava.compile=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005
)
Of course, you can do the same also on a MacOS X or Linux box, by using export intead of SET.
Now, run the above batch file and proceed again with building:
C:\Users\jOOQ\workspace>mvn_debug
C:\Users\jOOQ\workspace>mvn clean install
Listening for transport dt_socket at address: 5005
Your Maven build will now wait for a debugger client to connect to your JVM on port 5005 (change to any other suitable port). We’ll do that now with Eclipse. Just add a new Remote Java Application that connects on a socket, and hit “Debug”:
That’s it. We can now set breakpoints and debug through our Maven process like through any other similar kind of server process. Of course, things work exactly the same way with IntelliJ or NetBeans.
Once you’re done debugging your Maven process, simply call the batch again with parameter off:
C:\Users\jOOQ\workspace>mvn_debug off
C:\Users\jOOQ\workspace>mvn clean install
Who doesn’t know them. The good old JFace dialogs in Eclipse that give you a visual representation of what is really a rather simple XML or properties file. In the case of m2e, it looks like this:
Unfortunately, this screen is a bit slow to load, and it doesn’t offer much value beyond checking version numbers and some other stuff that you’ll never change again. If you’re deep into using Maven, you’ll put plugins all over the place, and there is no way to visually manage the plugins in this screen. There can’t be, because plugins may contain “schemaless” XML, for which it would be impossible to design a non-XML editor.
So, most Eclipse/Maven/m2e users will immediately jump to the pom.xml representation, i.e. the tab on the far right, to edit the XML sources of their pom.xml files.
Luckily, you can change your workspace settings and make opening the XML tab the default for your pom.xml files:
You wouldn’t believe it until you try it yourself. I’ve been using the Eclipse Mars developer milestones lately, and I’ve been having some issues with slow compilation. I always thought it was because of the m2e integration, which has never been famous for working perfectly. But then, it dawned upon me when I added a JPA persistence.xml file to run some jOOQ + Hibernate tests… I ran into this issue, and googled it to learn that many people are complaining about JPA validation running forever in their Eclipses.
So I searched for how to deactivate that, and boom!
All of my Eclipse got much much faster
In fact, I didn’t just deactivate JPA validation, but all validation:
I don’t remember the last time I ever needed validation, or thought that it was a useful feature in the first place. If you want to help your whole team, you can also check in the following file in each of your projects’ .settings/org.eclipse.wst.validation.prefs files:
class TestException extends Exception {
}
interface Task<E extends Exception> {
void call() throws E;
}
public class TaskPerformer {
private <E extends Exception> void perform(Task<E> task) throws E {
task.call();
}
public static void main(String[] args) {
// compilation error
new TaskPerformer().perform(() -> {
try {
throw new TestException();
} catch (TestException e) {
return;
}
});
}
}
The false positive compilation error has probably been fixed with issue 429430. In any case, it is not reproducible with Eclipse 4.5.0 M5, available as a developer build
With Java 8, compiling Java code hasn’t really become any easier than before. The above bug has been produced by a very subtle combination of:
Checked vs. unchecked exceptions
Generics (and exceptions)
Lambda expressions
Type inference
Flow analysis
If you’ve ever had a look at compiler source code, you cannot help but be glad that someone else is doing that job for you (the same is true when you look at jOOQ’s or Hibernate’s sources, by the way).
Where are we at with our compilers?
We’re getting there. My personal feeling is that early access releases of javac work best. For instance, I’m using
build 1.8.0_40-ea-b23
(disclaimer: this article was written before it was published. many problems are now gone with 1.8.0_40)
… although, you probably don’t want to go to production with such an early access release. IDEs building with javac, and Maven, of course, work equally well. Eclipse is lagging a little bit – which can be annoying at times.
Some of you non-Eclipse users might smirk and get your Eclipse vs. IntelliJ rants ready, and you know… there’s a saying about that:
A vegan, an IntelliJ user, a Mac user, and a Linux user walked into a bar.
How do I know?
AFTER 2 MINUTES, THE WHOLE DARN BAR KNEW!
(We actually have a whole article on that topic)
The fact is, all of the compiler teams are working hard to fix loads of bugs. IntelliJ, even while using javac to compile, may still display some false positives, visually in your IDE. Geertjan from NetBeans has just recently fixed a whole pile of bugs that we’ve reported. And Eclipse, well, Eclipse ships with their own very sophisticated incremental Java compiler. It’s a great compiler for rapid prototyping, but the drawback is that it compiles stuff slightly differently from others.
While developing jOOQ and also jOOλ, we’ve discovered quite a few bugs in Eclipse – many of them having been fixed already in Eclipse Mars. For instance:
We’re getting there. If you can, make use of lambdas and streams, and apply as much type inference in your code as possible. And please, if you do discover a bug, report it. We’re probably all using one of those three IDEs. Every bug that you report, is one less obstacle towards Java 8 adoption.
Here are the links to start registering bugs:
Some things are just very very very VERY very important. Such as John Cleese.
The same is true for Whitespace:
Whitespace-Shedding
Yes. 1080 Reddit Karma points (so urgently needed!) in only 23 hours. That’s several orders of magnitudes better than any of our – what we wrongfully thought to be – very deep and interesting technical insight about Java and SQL has ever produced.
The topic of interest was a humourous treatise about whether this:
for (int i=0; i<LENGTH; i++)
… or this:
for (int i = 0; i < LENGTH; i++)
… should be preferred. Obviously both options are completely wrong. The right answer is:
for
( int i = 0
; i < LENGTH
; i++
)
Read the full treatise here.
But at some point, the whitespace discussion is getting stale. We need new very very very important topics to discuss instead of fixing them bugs. After all, the weekend is imminent, and we don’t know what else to talk about.
This is why we are now publishing…
In case you haven’t heard of this highly interesting discussion, there are some people who believe that ORMs are outdated, because ORMs don’t work as promised. And they’re totally right. And the best thing is, all the others are totally right as well.
Why is that great? Because that means we get to discuss it. Endlessly!
While everyone keeps talking about ORMs like that, no one cares what Gavin King (creator of Hibernate) had said from the beginning:
Gavin King on Hibernate – No one had listened to the poor man
Why should we care about his opinion? We have our own, far superior opinion! Let’s have another discussion about why ORMs are evil!
2. Case-sensitivity
Unfortunately, us Java folks cannot have any of those very very very very very important discussions about casing, because unfortunately, Java is a case-sensitive language.
But take SQL (or PL/SQL, T-SQL for that sake). When writing SQL, we can have awesome discussions about whether we should
-- Upper case it all
SELECT TAB.COL1, TAB.COL2 FROM TAB
-- Upper case keywords, lower case identifiers
SELECT tab.col1, tab.col2 FROM tab
-- Lower case keywords, upper case identifiers
select TAB.COL1, TAB.COL2 from TAB
-- Lower case it all
select tab.col1, tab.col2 from tab
-- Add some PascalCase (awesome SQL Server!)
SELECT Tab.Col1, Tab.Col2 FROM Tab
-- Mix case-sensitivity with case-insensitivity
-- (Protip to piss off your coworkers: Name your
-- table "FROM" or "INTO" and let them figure out
-- how to query that table)
SELECT TAB."COL1", TAB."col2" FROM "FROM"
-- PascalCase keywords (wow, MS Access)
Select TAB.COL1, TAB.COL2 From TAB
Now that is really incredibly interesting. And because this is so interesting and important, you can only imagine the number of interesting discussions we’ve had on the jOOQ User Group, for instance, about how to best generate meta data from the database. With jOOQ, we promise that you can extend these enticing discussions from the SQL area to the Java area by overriding the code generator’s default behaviour:
Should classes be PascalCased and literals be UPPER_CASED?
Should everything be PascalCased and camelCased as in Java?
Should everything be generated as named in the database?
Endless interesting discussions!
We have so many options to SQL casing, which brings us to
3. SQL formatting
Unlike C-style general-purpose languages such as C, Java, Scala, C#, or even keyword-heavy ones Delphi, Pascal, Ada, SQL has one more awesome grounds for numerous discussions. It is not only keyword-heavy, but it also has a very complex and highly irregular syntax. So we’re lucky enough to get to choose (after long discussions and settlements) between:
-- All on one line. Don't tell me about print margins,
-- Or I'll telefax you my SQL!
SELECT table1.col1, table1.col2 FROM table1 JOIN table2 ON table1.id = table2.id WHERE id IN (SELECT x FROM other_table)
-- "Main" keywords on new line
SELECT table1.col1, table1.col2
FROM table1 JOIN table2 ON table1.id = table2.id
WHERE id IN (SELECT x FROM other_table)
-- (almost) all keywords on new line
SELECT table1.col1, table1.col2
FROM table1
JOIN table2
ON table1.id = table2.id
WHERE id IN (SELECT x FROM other_table)
-- "Main" keywords on new line, others indented
SELECT table1.col1, table1.col2
FROM table1
JOIN table2
ON table1.id = table2.id
WHERE id IN (
SELECT x
FROM other_table
)
-- "Main" keywords on new line, others heavily indented
SELECT table1.col1, table1.col2
FROM table1 JOIN table2
ON table1.id = table2.id
WHERE id IN (SELECT x
FROM other_table)
-- Doge formatting
SUCH table1.col1,
table1.col2
MUCH table1
JOIN table2 WOW table1.id
= table2.id
WHICH id IN
(SUCH x
WOW other_table
)
Doge SQL Formatting
And so on and so forth. Now any project manager should reserve at least 10 man-weeks in every project to agree on rules about SQL formatting.
4. The end of the DBA
Now THAT is a very interesting topic that is not only interesting for developers who are so knowledgeable about productive systems, no it’s also very interesting for operations teams. Because as we all know, the DBA is dead (again).
For those of you who have been missing out on this highly interesting topic, do know that all of this started (again) when the great NoSQL vs. SQL debate was initiated by brilliant minds and vendors of truly alternative systems. Which are now starting to implement SQL, because apparently, well… SQL isn’t all that bad:
// If this
if (something) {
...
}
// Else something else
else {
...
}
Exactly. Because this allows comments to be written where they belong: Next to the appropriate keyword, and always aligned at the same column. This leads us to the next very interesting question: Should we put comments in code at all? Or is clean code self-documenting?
And we say, why yes, of course we should comment. How on earth will anyone ever remember the rationale behind something like this??
// [#2744] DB2 knows the SELECT .. FROM FINAL
// TABLE (INSERT ..) syntax
case DB2:
// Firebird and Postgres can execute the INSERT
// .. RETURNING clause like a select clause. JDBC
// support is not implemented in the Postgres JDBC
// driver
case FIREBIRD:
case POSTGRES: {
try {
listener.executeStart(ctx);
rs = ctx.statement().executeQuery();
listener.executeEnd(ctx);
}
finally {
consumeWarnings(ctx, listener);
}
break;
}
Dayum.
You’re saying, JSON and XML are the SAME THING!?
But MongoDB and PostgreSQL allow me to store JSON. Oh wait. They tried to store XML in databases, back in the 90s, too!? And it failed? Well, of course it failed, because XML sucks, right? (which is essentially another way of saying that I’ve never understood XSLT or XQuery or XPath or didn’t even hear about XProc, and I’m just ranting about angle brackets and namespaces)
Let’s further discuss this matter. I feel that we’re close to the very ultimate solution on that topic.
Speaking of JSON…
7. Curly braces
OMG! This is the most interesting of all topics. Should we put the opening brace:
On the same line?
On a NEW line??
NO BRACE AT ALL???
The right answers are 1) and 3). 1) only if we absolutely have to, as in try or switch statements. We’re not paid by the number of lines of code, so we don’t add meaningless lines with only opening braces. And if we can omit the braces entirely, fine. Here’s an awesome statement, if you ask me:
if (something)
outer:
for (String thing : list)
inner:
do
if (somethingElse)
break inner;
else
continue outer;
while (true);
That ought to teach them juniors not to touch my code. Which brings us to:
8. Labels
Nothing wrong with them. I’ll break out of my loops any time I want. Don’t tell me labels are Java’s way of saying GOTO, they’re much more sophisticated than that. (Besides, goto is a reserved word in Java, and it is an actual bytecode instruction). So I’ll happily do my jumping forward:
label: {
// do stuff
if (check) break label;
// do more stuff
}
Or my jumping backward:
label: do {
// do stuff
if (check) continue label;
// do more stuff
break label;
} while(true);
(observe how the above example used two spaces for indentation instead of four (or tabs). Another great topic for further discussion)
9. emacs vs. vim vs. vi vs. Eclipse vs. IntelliJ vs. Netbeans
Can we please, PLEASE, have another very interesting discussion about which one of these is better? Please!
10. Last but not Least: Is Haskell better than [your language]?
According to TIOBE, Haskell ranks 38.
And as we all know, the actual market share (absolutely none in the case of Haskell) of any programming language is inversely proportional to the amount of time spent on reddit discussing the importance of said language, and how said language is totally superior to the one ranking 1-2 above on TIOBE, for instance. Which would be Lua.
So, I would love to invite you to join our blogging friends below to a very very interesting discussion about…
The great thing about these social networks like Reddit, Hackernews, and all the others is the fact that we can finally spend all day to discuss really really intersting topics instead of fixing them boring bugs our boss wants us to fix. After all, this is IMPORTANT.
Or as Randall Munroe would say: “Duty calls!”
Further reading
If you’re now all hot and ready to discuss things, please consider also reading these very interesting and insightful articles on how to best format and style code:
This is the list we’ve all been waiting for. The top 10 productivity booster techs for programmers that – once you’ve started using them – you can never do without them any longer.
Here it is:
1. Git
Before, there were various version control systems. Better ones, worse ones. But somehow they all felt wrong in one way or another.
Came along Git (and GitHub, EGit). Once you’re using this miraculous tool, it’s hard to imagine that you’ll ever meet a better VCS again.
No kidding. Have you ever googled for anything tech-related back in 2005? Or altavista’d something back in 2000? Or went to FidoNet in search for answers in 1995? It was horrible. The top results always consisted in boring forum discussions with lots of un-experts and script kiddies claiming wrong things.
These forums still exist, but they don’t turn up on page 1 of Google search results.
Today, any time you search for something, you’ll have 2-3 hits per top 10 from Stack Overflow. And chances are, you’ll look no further because those answers are 80% wonderful! That’s partially because of Stack Overflow’s cunning reputation system, but also partially because of Stack Overflow’s even more cunning SEO rewarding system. (I already got 98 announcer, 19 booster, and 5 publicist badges. Yay).
While Stack Overflow allows its more active user to pursue their vanity (see above ;-) ), all the other users without any accounts will continue to flock in, finding perfect answers and clicking on very relevant ads.
Thumbs up for Stack Overflow and their awesome business model.
In other words, we get enterprise-quality office software for the price of what students used to pay, before.
And do note, Office 2013 is better than any other Microsoft (or Libre) Office suite before. While not a 100% Programmer thing, it’s still an awesome tool chain for a very competitive price.
4. IntelliJ
While Eclipse is great (and free), IntelliJ IDEA, and also phpStorm for those unfortunate enough to write PHP are just subtly better in almost every aspect of an IDE. You can try their free community edition any time, but beware, you probably won’t switch back. And then you probably won’t be able to evade the Ultimate edition for long ;-)
PostgreSQL claims to be the world’s most advanced Open Source database, and we think it’s also one of the most elegant, easy, standards-compliant databases. It is really the one database that makes working with SQL fun.
We believe that within a couple of years, there’s a real chance of PostgreSQL not only beating commercial databases in terms of syntax but also in terms of performance.
Any time you need a data storage system with a slight preference for SQL-based ones, just make PostgreSQL your default choice. You won’t be missing any feature in that database.
Let’s hear it for PostgreSQL.
6. Java
Java is almost 20 years old, but it’s still the #1 or #2 language on the TIOBE index (sharing ranks with C), for very good reasons:
It’s robust
It’s mature
It works everywhere (almost, really too bad it has never succeeded in the browser)
It runs on the best platform ever, the JVM
It is Open Source
It has millions of tools, libraries, extensions, and applications
While some languages may seem a bit more modern or sexy or geeky, Java has and will always rule them all in terms of popularity. It is a first choice and with Java 8, things have improved even more.
7. jOOQ
Now, learning this from the jOOQ blog is really unexpected and a shocker, but we think that jOOQ fits right into this programmer’s must-have top-10 tool chain. Most jOOQ users out there have never returned back to pre-jOOQ tools, as they’ve found writing SQL in Java as simple as never before.
Given that we’ve had Java and PostgreSQL before, there’s only this one missing piece gluing the two together in the most sophisticated way.
When you try Less CSS for the first time, you’ll think that
Why isn’t CSS itself like this!?
And you’re right. It feels just like CSS the way it should have always been. All the things that you have always hated about CSS (repetitiveness, verbosity, complexity) are gone. And if you’re using phpStorm or some other JetBrains product (see above), you don’t even have to worry about compiling it to CSS.
As an old HTML-table lover who doesn’t care too much about HTML5, layout, and all that, using Less CSS makes me wonder if I should finally dare creating more fancy websites!
Never again without Less CSS.
9. jQuery
What Less CSS is for CSS, jQuery is for JavaScript. Heck, so many junior developers on Stack Overflow don’t even realise that jQuery is just a JavaScript library. They think it is the language, because we’ve grown to use it all over the place.
Yes, sometimes, jQuery can be overkill as is indicated by this slightly cynical website: http://vanilla-js.com
But it helps so much abstracting all the DOM manipulation in a very fluent way. If only all libraries were written this way.
We’re certainly not the only ones believing that there is such a thing as a programmer-productivity-booster. Enjoy this alternative list by Troy Topnik here for more insight:
Eclipse is a beast. A device whose mystery is only exceeded by its power. Some would call it a continuum transfunctioner. Others would call it a transmogrifier. Yes, it is so huge, it takes years to master. And then, your manager shows up and tells you: We’re using NetBeans now.
Just kidding. No one uses NetBeans, except for Adam Bien. So let’s have a look at 5 very useful, but hidden Eclipse features.
1: My favourite feature: Favourites
Everyone uses libraries with static methods. Since Java 5, we can static import them, so we no longer have to write things like
SomeVeryImportantUtility.split(string1, string2);
But who is going to static-import all those methods manually in every class referencing them? No one. Because you can define your favourite types and members in the preferences:
Preferences > Favorites
And then, just start typing and look for auto-completion:
Auto-completion
The auto-completion will also generate the necessary static import. Very useful when using DSLs with many functions, for instance. Obviously, you will want to make a careful decision, which ones are really your favourite libraries and within those libraries, which are your favourite types. As you’re on the jOOQ blog (or a syndication thereof), let me give you a hint. Always favourite org.jooq.impl.DSL.
2: The awesome block selection mode
I’ve recently blogged about it here. This is so awesome, it merits being mentioned one more time.
Block selection
Notice the highlighted button, the sixth from the left. That’s the awesome “Block Selection Mode” (Alt-Shift-A on Windows, or Ctrl+3 and then typing block selection). It lets you write opening quotes on each selected line at the same position. This is so useful when you have to edit large amounts of almost identical lines.
3: The EGit staging view
Aparently, not every EGit user is aware of this view. As a matter of fact, to me, this view is the most important reason why I’m NOT using the shell commands. Check out this beauty:
Staging view
OK, not really a beauty. Reminds me of this comic strip by Eric Burke. But we’re in transmogrifier land and the staging view is filled with changes waiting to be added / committed / pushed once you synchronize a repository with its origin. I can now decide on a line-per-line basis, which changes I want to be added to the index (note I haven’t added the main method). This leads to there being staged (added) changes and unstaged (not yet added) changes. As always in EGit, I can now either directly commit, commit+push, amend+commit, amend+commit+push in one go. Try doing that on the command line.
Now after this first commit, I can now again stage/add the main method in a separate commit. I guess, behind the scenes, this might be implemented using stashing or some other sort of local cache. I don’t care, this is beautiful!
I can probably do much more with this beauty, but that would fill an entire book (I’m waiting for such a book, @niborst, if you’re reading this)
If you didn’t understand any of the above Git talk, try this popular guide, or join me with…
4: Type filters
Yes, because Eclipse’s out-of-the-box autocompletion is nonsense. Yes, it is! No one really wants to call hashCode() or wait() or notifyAll() on an API. Ever. Actually, nowadays, hardly anyone even wants to call wait() or notify() even on a lock object, except if they’re writing the JDK’s concurrency libraries. But luckily someone else is doing that for free, and they’re certainly using vi or emacs or a hex editor, so they don’t mind Object methods.
So then, why is my autocompletion popup filled with this nonsense? Let’s create a class…
So many options? Really?
Wow. I thought I had only one method? I don’t mind equals(), although the few times I actually type equals() I can type it out. So let’s remove that stuff:
Preferences > Type filters
Thanks Eclipse for mentioning awt, too. I wish there was an option to remove awt from the JDK and from our collective memory, entirely. But at least, adding awt to the type filters stops you from having to choose between importing java.util.List (99.9%) and java.awt.List (8.3%). The rounding error is due to the amount of times you had previously chosen the wrong list, accidentally, and wondered why you couldn’t assign an ArrayList. Thanks again, awt. Do also note how my chameleon Windows 8 has changed window colours while taking screenshots. Tiles, what’s next? Anyway back to Eclipse, let’s try auto-completing again…
There can be only one
Better? Better!
Now…
5: Formatter tags
After having spent all that time with block selection, carefully formatting our SQL… bam comes the intern and/or styleguide-nazi and auto-formats all your beautiful source files to a huge one-liner. But not for much longer. Protect your code with easy to type formatter tags:
Preferences > Formatting Options > Off/On Tags
Remember to use something concise to protect your carefully crafted SQL, as you might have to type these tags once or twice:
Now protected
No one touches that code again. Except the intern who forgot to and/or styleguide-nazi who refuses to apply your formatting settings. And the other intern, who uses NetBeans. Just kidding. No one uses NetBeans.
Again, these tags work wonderfully with DSLs, which are hard to auto-format.
More to come
Eclipes is an awesome beast. Every year, new versions are stacked with new features that we Java developers get for free! You can give back to Eclipse. While I think that the foundation (backed by IBM) might not heavily rely on donations, your best option is to report bugs and feature requests, here:
https://bugs.eclipse.org/bugs
… or if you’re brave, to sign the CLA and start contributing.
There is always room for improvement to this awesome developer device, adding more material and candidates for my next top 5 list.
This post is about an awesome Eclipse feature, that is completely underestimated and hidden in the menu. Yet, it is so useful in so many situations. The awesome “Block Selection Mode” which can be toggled through Alt-Shift-A on Windows. Here’s an example challenge for the Block Selection Mode:
Paste your formatted SQL statement verbatim into your Java file
Step 2: Write opening quotes
Notice the highlighted button, the sixth from the left. That’s the awesome “Block Selection Mode” (Alt-Shift-A on Windows). It lets you write opening quotes on each selected line at the same position
Step 3: Write closing quotes and concatenation
Apply the same technique for the closing quotes and the concatenation sign (`+`)
When blogging about DSLs, I’m mostly blogging about internal domain-specific languages, because jOOQ is a good example for internal DSLs. But external domain-specific languages are an interesting topic as well. As an external DSL does not depend on any host language (e.g. Java), it can be much richer in syntax and expressivity. On the other hand, you need tools to parse, compile and maybe even interpret / run them.
Here’s a very interesting blog post showing how to create an external DSL with Xtext, Eclipse’s DSL tool chain. It creates a simple DSL to describe video game control flows and shows how Eclipse Xtext immediately provides an editor with all sorts of IDE features for that custom DSL:
I have recently discovered this new, must-have Eclipse plugin, which is very useful for those third-party libraries whose source-code you can’t easily find or link into your Eclipse: JDEclipse.
It doesn’t only decompile byte code into Java code, it does so extremely well, keeping line numbers at the correct place, such that you can actually debug through the decompiled source code and set breakpoints that actually work.
