XRebel for standalone apps with embedded Jetty

XRebel was designed to work specifically with Java web applications. Currently, it relies on Servlet API to serve its UI. It has been tested with a range of application servers (Apache Tomcat, WildFly, WebSphere, and others) and some full stack frameworks as well, including Spring Boot and JavaSpark.

Sometimes however, you might want to use XRebel with a standalone Java process that is not using Servlet API. Hence, XRebel cannot display its embedded UI to render the data it collected from the application. What can we do about this? Well, XRebel is tested on Jetty and it works quite well there. Jetty is also often used as an embedded HTTP server. So why don’t we use this trick and embed Jetty into our standalone app to serve XRebel UI.

Here’s our example application:



Just for the demonstration purposes, it executes an HTTP request every 3 seconds and reads the response. Quick and dirty.

To embed Jetty server we need is to add a dependency to Jetty container and initialize the server when the application starts. The required dependencies are jetty-server and jetty-servlet:



Then we can start Jetty by adding the following code snippet into the static initializer of the class:



To enable XRebel agent, you need to start the application with -javaagent VM argument pointing to the location of xrebel.jar. For instance:

-javaagent:/Users/anton/tools/xrebel/xrebel.jar -Dxrebel.traces.all=true

I also added -Dxrebel.traces.all=true VM property to enable tracing of non-HTTP activities by XRebel. Tracing of non-HTTP activities in XRebel is disabled by default, hence I need to add this parameter in order to see profiling data for the periodic tasks (if I wish).

Once I launch the application, it will boot up the embedded Jetty instance on port 8080. The standalone XRebel UI is deployed by the agent to /xrebel context. Hence, if we open http://localhost:8080/xrebel in the browser we will see the following:

As you can see, it is quite easy to use XRebel with the standalone apps with this little trick. Just start an embedded Jetty instance on some port and you will be able to see what is your application doing. Perhaps, you can spot a sneaky bug with it before it gets to production! :)

If you want to play with the example application, I have it at GitHub. Download XRebel and start the application with the appropriate VM arguments to enable the agent. It will be fun! :)

Hello World with JBoss Modules

JBoss Modules is quite an interesting project that powers JBoss application server and some other projects in JBoss ecosystem. However, I was surprised to find out that there isn't much you can find about Modules on the webs. Documentation is... bad half-done, not that many tutorials, no good examples of how you could use this awesome library in your project. The best you can find is the description on how to apply JBoss Modules within the application server. (sad panda)

I was looking for the simplest "Hello World" example and couldn't find it. Well, why not create one myself then? 

Downloading JBoss Modules

A surprising fact is that you won't find JBoss Modules in the list of upstream projects at jboss.org. The first option is to download the jboss-modules.jar from Bintray or Maven Central. And the second option is to build it from sources. 

Oh, ok, one more option (not the best one) is to download the application server that includes jboss-modules.jar, e.g. WildFly.

Hello World

Ahh, the good old "Hello World" :) The main application class is as follows:

public class Main {

  public static void main(String[] args) {

     new Hello().say();

  }

}

So we have a dependency, the Hello class, that will reside in a different module:

public class Hello {

  public void say(){

    System.out.println("Hello!");

  }

}

So to mimic the modules we first have to compile both classes and assemble corresponding JARs. Plus, a proper directory layout is expected by JBoss Modules to resolve the artefacts.

Main class belongs to 'app' module, and Hello class belongs to 'hello' module. Each module requires module.xml descriptor. This part is somewhat documented actually. Also the 'main' directory that you see within each module's directory structure is actually a version (!). 

A version slot identifier is an arbitrary string; thus one can use just about any system they wish for organization.  If not otherwise specified, the version slot identifier defaults to "main".

Here's the module.xml for the app module:

<?xml version="1.0" encoding="UTF-8"?>

<module xmlns="urn:jboss:module:1.5" name="app">

  <main-class name="Main"/>

  <resources>

    <resource-root path="main.jar"/>

  </resources>

  <dependencies>

        <module name="hello"/>

  </dependencies>

</module>

It specifies the main class (i.e. Main), the reference to the actual JAR that will be used in this module's classpath, and a dependency - the 'hello' module.

Same module.xml for the 'hello' module:

<?xml version="1.0" encoding="UTF-8"?>

<module xmlns="urn:jboss:module:1.5" name="hello">

  <resources>

    <resource-root path="hello.jar"/>

  </resources>

</module>

Voila! Now we can execute our brand new modular "Hello World" app:

> java -jar jboss-modules-1.5.1.Final.jar -mp mods app

Hello! 

The format for the command is as follows. First, java -jar jboss-modules.jar is used to bootstrap the environment; -mp mods, and the 'app' parameter is the name of the application module that should be executed.

This example isn't really practical, but at least it gives a hint on how to get started with JBoss Modules. Hopefully, one day, the documentation for this awesome project will be complete and there will be a bit more tutorials for different the use cases.

HotSwap vs hot deploy

It is the year 2016 and one still has to explain that HotSwap and hot deploy in Java IDEs is not the same thing.

Stackoverflow is full of questions about avoiding restarts of Java applications. So of the answers suggests that “Eclipse can update code without restarting the application” or “IntelliJ IDEA can hot update running applications” or “NetBeans automatically updates running code in debugger”. But the ultimate solution for this problem is JRebel, of course.

UPD: You can also read about various solutions to the redeployment problem in my Stackoverflow answer.

One fundamental thing that people don’t understand is that it is not even the capability of an IDE to be able to update applications. The IDE is just a medium -- it only triggers the update, and then the runtime environment is the one responsible for updating the code.

Repeat after me: 

HotSwap and Hot deploy is not the same thing!

What is HotSwap?

HotSwap (тм) is the technology in HotSpot JVM that is tailored at updating class definitions at runtime. Most importantly, "HotSwap adds functionality to the Java Platform Debugger Architecture (JPDA) to allow a class to be updated while under the control of a debugger”.

So when it comes to IDEs, once an application is started in a debug mode, the IDE can trigger class redefinition in a running JVM by utilizing JPDA.

If you are interested in the intimate details of HotSwap, read the “Safe class and data evolution in large and long-lived java applications” paper by M. Dmitriev.

It is important to understand the limitations of HotSwap: it is limited only to updating statements of code inside methods. Can’t change method signatures, can’t add new methods, fields, etc. Some JVM implementations are able to do a bit more. For instance, with IBM J9 JVM it is possible to add new methods to an existing class. Nevertheless, HotSwap capabilities are minimal. A JEP for enhanced class redefinition has been submitted long ago, and even a research project was sponsored by Oracle, but no further progress was made.

The bottom line here is that HotSwap is not a feature of an IDE, it is the ability of a JVM that you use.

What is hot deploy?

Hot deploy is the ability of application container to automatically deploy (web) applications at the startup. Obviously, the same feature can be applied to re-deploy the applications without restarting the JVM process.

Hot deploy is not a feature in any of the IDEs either. IDEs can only trigger (re)deployment of an application by either copying the artefacts to a correct location, or by using hooks if provided by the application server. So this is totally application server specific - this is what server adapters are for! It requires the IDE to be aware of the application server specifics, hence some people affiliate this functionality to their IDE.

Redeploying the application drops its state. Sometimes, application server can serialize/deserialize HTTP session state, but that's about it, not more. It can't preserve the state of the structures inside the application; internal caches have to be warmed up; framework internals have to be reinitialized, etc. The process is time consuming.

Application servers rely on class loader magic to redeploy applications. You can read about it in details in ZeroTurnaround’s blog.

Summary

Make sure you use the terms correctly -- 'HotSwap' and 'hot deploy' is not the same thing! You may other terms, like 'hot update' -- then make sure to ask, what does the person actually means by this, because the devil is in the details.

Another great Java interview question: Singleton

I'm not a big fan to ask to write code at the interviews. But I still find it useful to do some coding exercises at the whiteboard. One of my favourites is the Singleton pattern. Because Singleton is so simple, you can use it as a starter for so many interesting discussions.

it often comes down to the discussions about the Singleton being lazy or eager. And while it leads to the discussion about Java Memory Model, it's not the most interesting one. No one understands Java Memory Model anyway :)

BTW, did you know that a single-element enum type is the best way to implement a Singleton?

Yes! And you can't imagine how many people do fail with this. If you deploy 2 web applications with the same Singleton class, will there be two instances of the same Singleton or one? Of course, there isn't one true answer for this question - you have to ask the details. The the answer depends much on how the class is loaded. If the class is packaged within the WARs, then you get 2 instances of the Singleton.

This is why Singleton is such a great interview question - it opens a lot of topics for further discussion!

final/finally/finalize

I have been interviewing candidates for Java developer jobs for a full decade at this point. I have tried various approaches for the interviews: various tests about language and the APIs, whiteboard programming, bug hunting, homework assessments, etc. There is no best approach for the interviews - it merely depends on the expectations, candidate background, position, day of the week, weather, whatever else.

Despite all the details, I’ve found one interview question that works like a charm. It is almost the best question to start with. And it is quite efficient in filtering the candidates early enough if have to screen a lot of candidates.

Here’ it is:

What is the different between final, finally & finalize?

How is this even a question, you would ask? Asking about the difference of the things that cannot be compared!? Well, apparently, a lot of developers can't make a clear difference. Those who don’t - you just don’t have to interview them further :)

OK, you asked this and candidate answered this brilliantly, now what? Well, I did tell you that it is a very good question to start with, didn’t I? Next, you can take it to any direction of your choice:

• final - you may take the discussion to Reflection API, for instance. Or you can discuss how the final keyword helps with concurrent programming in Java.
• finally - talk more about the exceptions in Java and discuss some puzzles. Like the one below. What does it print?
• finalize - the discussion about finalize() method is only useful to validate the nerd level of the candidate. Usually you’d check why one shouldn't use finalize() in first place. Maybe some rare candidate can tell about legitimate uses of finalize(). This most likely shows that he or she remembers what is written in Item 7 from Effective Java.

I hope you get my point now, why this strange question is a very good one for the Java interviews. Have fun!

I will be speaking at JavaOne 2015

I'll be speaking at JavaOne this year again! This time I have 2 talks accepted:

CON3597 - Having Fun with Javassist. This is merely a live coding session where I demonstrate various uses of the Javassist library for Java bytecode manipulation. I've delivered this talk multiple times and every time it is different as it turns out quite interactive and attendees usually ask questions right in the middle of the talk so I have to adjust the content as I go. Usually it's quite fun, so I enjoy presenting this talk.

CON6699 - What's the Best IDE for Java EE? I'm not sure how this one turns out - it's so much to talk about and so little time. I'll be presenting this talk along with Max Rydahl Andersen and Adam Bien. This time we're focusing solely on Java EE. Basically - it's and overview of what's available for Java EE users in Eclipse, NetBeans IDE, and IntelliJ IDEA.

Both the talks can be found in the content catalogue for JavaOne.

GeekOut 2015: CompletableFuture

The talk by Tomasz Nurkiewicz about CompletableFuture was rated the highest at GeekOut this year. This is really interesting API that appeared in Java 8

A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage, supporting dependent functions and actions that trigger upon its completion.

Tomasz Nurkiewicz - CompletableFuture in Java 8, asynchronous processing done right. from Official ZeroTurnaround Account on Vimeo.

Some time ago Tomasz published a really nice series of articles at his blog - worth reading!

Java 8: Definitive guide to CompletableFuture
Java 8: CompletableFuture in action

And there's more!

GeekOut 2015 recordings are available

All the videos from GeekOut 2015 are available: http://2015.geekout.ee/videos/

Here are the two talks that seemed the most interesting to me:

Martin Thompson - Practicing at the Cutting Edge from Official ZeroTurnaround Account on Vimeo.

Nitsan Wakart - Lock Free Queues from Official ZeroTurnaround Account on Vimeo.

XRebel 2.0 with Application Profiling

From the very start, our users requested profiler capabilities in XRebel. As of 2.0, it is possible to get the performance overview for every request and identify the slowest methods.

The profiler view shows the time distribution in the call tree by assigning the percentages to the individual nodes that represent method invocations. The slowest methods are also accompanied with an extra percentage figure that indicates the method own contribution time.

JSP tag mapping is one neat little feature, new in XRebel 2.0. Instead of a cryptic runtime name XRebel displays the real JSP tag.

In 2.0, there are some more notable improvements to the existing features. The session component is now able to handle very large HTTP session snapshots. And of course, there's a ton of little UI improvements -- all to make the profiler more pleasant to use.

Links for XRebel:

• Download
• Features
• Documentation

Grails 3 Released. Setting up -javaagent

Grails 3 was released just recently and with all the new stuff it looks really-really-really awesome release! (Really hope that Grails will find the new home now). The two key changes for me are 1) moving to Gradle instead of Gant, and 2) building on top of Spring Boot. NOw it looks like it's basically the Gradle project with custom conventions that are derived from Grails 2.x.

For the first time, it feels like Grails is not a toy framework any more :)

What's not that cool (my own very subjective opinion), is the introduction of application.yml. It's almost impossible to modify it without reading the documentation. Even XML version of it (yes!) would have been more practical.

There are many other nice things added - go look for yourself.

Setting up a -javaagent argument for Grails 3

My personal interest with any new framework or server is usually related to the projects I'm working with. Thus, the first thing I wanted to check is how could I set up a -javaagent for Grails 3 application. Turns out, it's not as simple as you would expect.

Thanks to @bsideup, here's the snippet that you'd have to add to build.gradle file to setup a -javaagent argument, given that the agent JAR is located somewhere in file system:

In the example above, xrebel.jar is the agent package that is located somewhere in my file system. One can use the absolute path just fine in there.

Here's the another snippet, with DSL-style:

With this, I can confirm, that XRebel works with Grails 3 :)

Packaging Java applications for Mac OS, javapackager

Stumbled upon an issue with installing muCommander on Mac. The native installer did not work, saying that the launcher is corrupted, but the portable version worked just fine via the command line:

java -jar mucommander.jar

Launching a GUI app from the command line is not convenient at all. One option is to assemble the *.app package using Launch4j. However, I didn't have enough patience to do apply the tool. So I tried looking for an alternative solution.
So I found this guide: Packaging a Java App for Distribution on a Mac. And the instructions worked just fine! Here's what I did:
1. Downloaded the appbundler utility from https://java.net/downloads/appbundler/
2. Create a build.xml file. For instance:
3. Run "bundle" task: ant bundle
Profit! :)
This is all cool and works, but the process is a bit clumsy. One has to download some strange utility and use a legacy build tool to assemble the final artifact. We should do better! So I found another documentation page: Java Platform, Standard Edition Deployment Guide: Self-Contained Application Packaging. Apparently, there's a javapackager utility included in JDK distribution that you can use to create native packages.
By running the following command in the same folder where mucommander.jar is located, it created the desired artefacts:

$JAVA_HOME/bin/javapackager -deploy -native -outdir .  -outfile mu.app \

-srcfiles mucommander.jar -appclass com.mucommander.Launcher -name "muCommander" \

-title "muCommander"

Voila!

muCommander-0_9_0 anton$ ls -l bundles/
total 269904
-rw-r--r--@ 1 anton  staff  75110066 Mar 10 23:53 muCommander-1.0.dmg
-rw-r--r--  1 anton  staff  63076596 Mar 10 23:53 muCommander-1.0.pkg
drwxr-xr-x  3 anton  staff       102 Mar 10 23:53 muCommander.app

The only missing bit there is a proper icon, which I was too lazy to bother about :)

GeekOut 2015 Registration is Open!

As of today, the registration to GeekOut Java conference in Tallinn is open!

The focus of the conference is on all-Java but not only. For instance, this year we have talks on Dart and Go programming languages. Other talks cover developer tooling, solution architecture, programming methodologies. There will be a few talks on Java concurrency that you shouldn't miss in case you're into writing multithreaded applications in Java.

And here's what the conference is in numbers:

• 2 days
• 400 attendees
• 18 excellent talks
• and 1 kick-ass party!

We're also expecting Stephen Chin to visit us with his awesome Nighthacking sessions, so one should expect a lot of fun from the event!

BTW, If you haven't been to Tallinn yet, this is a great reason to consider visiting and June is just perfect month for this travel!

Technology predictions for 2015

It is popular to announce predictions for the upcoming year. I though it would be fun to try predicting some stuff too :)

Disclaimer: my predictions are very subjective and are based on my not-so-huge awareness of the IT industry. Feel free to leave your opinions in the comments. So here it comes:

Big Data.

"How big is big?"- one would ask? I leave this question unanswered. But the term "big data" always reminds me of some data set that should be queried/calculated/analyzed etc. The thing is - enterprises are becoming data hungry. Even a small company internally generates huge amounts of data - website visits, emails, sale events, product releases, commits to version control - anything that comes up to your mind. This is all valuable data that can be analysed.

And it is a huge data lake that could be generated by data-intensive companies. Trying to keep the information structured was common just a few years ago - with data warehouse approach. Now we have technology that enables us to process so much data that the retail banking data warehouse would seem a child's play compared to the amounts of data processed today.

Now, where was I? Ah, yes... I you are an engineer and you still haven't learned about Hadoop, Spark, Storm, Kafka, Samza, Typesafe stack, or R, do yourself a favour pic one and start learning it! The demand in the skills for building data processing system backends will be huge in the upcoming year(s).

Want examples? How about Hortonwork's IPO? Startups being created to support Kafka? Or look at the awesome services being created for analytics!

It is just all about data now (it has always been). Business depends on it.

JavaScript and front end.

Business as usual. Every day a new batch of JS frameworks will be appearing. Nothing special. The efforts to make JavaScript better are definitely welcomed, but doesn't it bring some uncertainty - which JS framework would you pick for the new project? Angular? What do you think about Angular 2.0 then? What about Atscript? Dart?

Crazy stuff.. Don't get me wrong - the improvements and the progress are amazing in front-end tech. Compared to the time when I had to do JS coding the current work of front-end engineer is just pure pleasure! The problem that I see here: it is just never stable. Almost any front-end technology that is popular today might easily turn into unmaintainable in a few months. And it doesn't seem to get better, at least from my impressions. And this trend will continue.

JVM languages

Scala continues to grow, Java continues to decline. We will probably see more reports on Kotlin and Ceylon being used in real commercial projects. Despite all the recent efforts that have been done in Nashorn, I have lost my belief into dynamic languages, although Groovy remains my GTD programming language for JVM.

Microservices

Blah, blah, microservices, blah, blah, blah... The ESB of our time :P

The reality is, there are just a few companies, like Netflix, who would really benefit of microservices approach at a big scale. Others - just use the fancy term - microservice - and isolate some functions of the silo application into a dedicated service. That's it - "so micro, much service". So it's just a SOA reinvented. The community will realize it this year, I hope.

Docker

Docker is probably the biggest hype of 2014. Even bigger than 'microservices'. Well, now there's a competing effort - Rocket. I'm almost sure that in 2015 we would see some more challengers in this space - other competitors to Docker. Given the support of big vendors, however, Docker will continue the hype in 2015. I'm still not convinced by the technology though.

Technology marketing

Haha! You didn't see that coming, did you? :) Why technology marketing? Oh, because the most effective sales are not happening during a golf match any more. Even big vendors are now more developer-oriented. Hence marketing. The problem here - developers hate marketing.

But have no fear! Marketing guys are crafty as well - the new ways to deliver the message to developers about some new cool and shiny thing are being invented every day. How? Content. A huge effort is being put into creating content for software developers. Look, Voxxed have just been launched. Why? Answer - marketing.

So in 2015 you can expect even more content being pushed by the vendors related to the technologies I've mentioned above.

Done

OK, I think this is enough of predictions, it was a fun exercise :) Let's see how it turns out in a year.

XRebel 1.2

Just released XRebel 1.2. It is amazing, astonishing, splendid, beautiful, awesome, beautiful, beautiful, beautiful! :) I'm most pleased with its ability to show the relation between ORM-level events/queries and the generated SQL queries that are executed via JDBC. Like this:

Or even like this:

The cool part is that even with no special requirements to filtering, the call tree scales very well - the user could see the compact call stack with relevant branching points starting from the incoming HTTP request towards the JDBC calls, or NoSQL... or outgoing HTTP invocations.. even RMI!

/me happy! :)

Java EE meets Kotlin

Here's an idea - what if one tries implementing Java EE application with Kotlin programming language? So I though a simple example, a servlet with an injected CDI bean, would be sufficient for a start.

Start with a build script:

And the project structure is as follows:

Here comes the servlet:

What's cool about it?

First, it is Kotlin, and it works with the Java EE APIs - that is nice! Second, I kind of like the ability to set aliases for the imported classes: import javax.servlet.annotation.WebServlet as web, in the example.

What's ugly about it?

Safe calls everywhere. As we're working with Java APIs, we're forced to use safe calls in Kotlin code. This is ugly.

Next, in Kotlin, the field has to be initialized. So initializing the 'service' field with the null reference creates a "nullable" type. This also forces us to use either the safe call, or the !! operator later in the code. The attempt to "fix" this by using the constructor parameter instead of the field failed for me, the CDI container could not satisfy the dependency on startup.

Alternatively, we could initialize the field with the instance of HelloService. Then, the container would re-initialize the field with the real CDI proxy and the safe call would not be required.

Conclusions

It is probably too early to say anything for sure, as the demo application is so small. One would definitely need to write much more code to uncover the corner cases. However, some of the outcomes are quite obvious:

• Using Kotlin in Java web application appears to be quite seamless.
• The use of Java APIs creates the need for safe calls in Kotlin, which doesn't look very nice.

Deploying Spring Petclinic demo application to JBoss/WildFly

Spring Petclinic is a very good demo application to experiment with - it is simple enough, yet demonstrates quite a good number of features. Usually I deploy it to Tomcat and obviously don't have any issues with it - it just deploys, runs, and works as expected.

Recently, however, for demonstration purposes, I needed to deploy this application to JBoss (or WildFly). And this is not as straightforward as one might expect.

First I tried with JBossAS 7.1.1.Final. The deployment fails with the following exception:

11:42:38,247 ERROR [org.apache.catalina.core.ContainerBase.[jboss.web].[default-host].[/petclinic]] (MSC service thread 1-3) Exception sending context initialized event to listener instance of class org.springframework.web.context.ContextLoaderListener: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'entityManagerFactory' defined in class path resource [spring/business-config.xml]: Invocation of init method failed; nested exception is java.lang.NoSuchMethodError: javax.persistence.JoinColumn.foreignKey()Ljavax/persistence/ForeignKey;

  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1568) [spring-beans-4.1.1.RELEASE.jar:4.1.1.RELEASE]

  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:540) [spring-beans-4.1.1.RELEASE.jar:4.1.1.RELEASE]
...

The latest Petclinic application (as of October 2014) uses JPA 2.1 and JBoss 7.1.1 bundles JPA 2.0 APIs. So I decided that it should probably work out of the box on WildFly since it comes with JPA 2.1 jars. And it did - the application deployed just fine, but then there's another library that prevents the application from operating properly - Dandelion:

Exception starting filter dandelionFilter: com.github.dandelion.core.DandelionException: The protocol vfs is not supported. 
        at com.github.dandelion.core.utils.ResourceScanner.scanForResourcePaths(ResourceScanner.java:204) [classes:] 
        at com.github.dandelion.core.utils.ResourceScanner.findResourcePaths(ResourceScanner.java:138) [classes:] 
        at com.github.dandelion.core.bundle.loader.spi.AbstractBundleLoader.loadBundles(AbstractBundleLoader.java:89) [dandelion-core-0.10.0.jar:] 

The issue was reported but at the time of writing this post the fix wasn't published yet. So hopefully Dandelion v0.11.0 will be capable to be deployed on WildFly.

So to overcome this and deploy Spring Petclinic (at the state of October 2014) to WildFly 8.1 one would have to get rid of the dependency on Dandelion, and rewrite some of the JSPs not to use Dandelion taglibs. Then the application deploys and works just fine.

So after making all the fixes I got Spring Petclinic running deployed to WildFly and could monitor it with XRebel:

MVC in Java EE

Java EE is getting MVC. And the crowd is going wild! :)

I'm actually quite positive about this move, although this came a little too late, in my opinion. Java EE has been criticised for not having MVC support, but it stayed opinionated and sticked with JSF. Apparently, MVC is actually a part of JAX-RS, so to speak. Not in the same spec though, it it will have integration points with JAX-RS. And there's also some sort of MVC support in Jersey already.

It is actually cool that it happened, just surprising that it took so long.

IntelliJ IDEA: Have you tried Search Everywhere yet?

The Search Everywhere action, invoked with double Shift key press, was added in IntelliJ IDEA version 13. I guess, most of the IDEA users/fans know about this feature and are enjoying it. At first glance, it just provides the means for search. You can search "everything": classes, files, symbols, actions, settings, etc. However, Search Everywhere widget is full of easter eggs.

Try using to jump between the search result groups. Or try left arrow to navigate in the history of search entries. But also, depending on the nature of the item that was found, the widget can provide some extra actions, like in the screenshot below: the "Show Navigation Bar" entry has an extra switch - on/off - showing that you can actually invoke this action.

Search Everywhere is a little gem in IntelliJ IDEA and all its features are yet to be discovered ;)

XRebel 1.0

XRebel 1.0 is out! Looking forward for the new versions of this nice tool!

RebelLabs: Java Tools and Technologies Landscape for 2014

A great report on Java Tools and Technologies, aka JavaTnT :), was published just recently. As usual, one may say that those is a "biased" numbers. Well, the numbers might be biased. But it is not really clear, the bias agains/towards what?

There are discussions at Reddit and Hackernews about the report. Some would say that the numbers are legit. Some would say that the numbers do not make sense. Of course, the numbers do not make sense if you don't like them ;)

In any case, the results present the JavaTnT landscape pretty well. It would be nice if more people would care to enter their data during the survey instead of arguing about the numbers afterwards. Oh well.. first world problems :)

Java Tools and Technologies Landscape for 2014 (image gallery) from ZeroTurnaround