Every developer who uses Java knows that Java bytecode runs in a JRE. The most important element of the JRE is Java Virtual Machine (JVM), which analyzes and executes Java byte code. In this article the author explains how JVM works, its structure, how it executes Java bytecode, the order of execution, examples of common mistakes and their solutions, as well as the new features in Java SE 7 Edition. The article, written by a senior software engineer at NHN Corporation, is very detailed and oriented for advanced Java developers.

This is not an introduction to Scala; we assume the reader is familiar with the language. This is a living document that will change to reflect our current “best practices,” but its core ideas are unlikely to change: Always favor readability; write generic code but not at the expensive of clarity; take advantage of simple language features that afford great power but avoid the esoteric ones (especially in the type system). Above all, be always aware of the trade offs you make. A sophisticated language requires a complex implementation, and complexity begets complexity: of reasoning, of semantics, of interaction between features, and of the understanding of your collaborators. Thus complexity is the tax of sophistication — you must always ensure that its utility exceeds its cost.

The Internet is full of interview questions for Java developers. The main problem of those questions is that they only prove that the candidate has a good memory, remmembering all that syntax, structures, constants, etc. There is not real evaluation of his/her logical reasoning.

This has been a classic java interview question, here are few reasons which make sense to me on why wait and notify method is in object class and not in Thread class alongwith Sleep().

Over the last few months we have been tracking the change in usage between Java 6 and the lastest version, Java 7. Since you have the ability to choose within Jelastic the version of Java that you want, we thought you might want to know what other developers out there are choosing. We’ve had about four months to track these changes, so here are the numbers.

STOMP is an asynchronous messaging protocol with design roots are based on HTTP protocol. It’s simplicity has made the protocol tremendously popular since it reduces the complexity of integrating different platforms and languages. There are a multitude of client libraries for your language of choice to interface with STOMP servers. The benchmark focuses on finding the maximum producer and consumer throughput for a variety of messaging scenarios. I’ve recently run STOMP benchmarks against the lastest releases of the 4 most feature packed STOMP servers: Apache ActiveMQ 5.5.1, Apache ActiveMQ Apollo 1.0, HornetQ 2.2.5, RabbitMQ 2.7.0 [ * ] Apollo looking impressive http://hiramchirino.com/blog/2011/01/activemq-apollo-looking-impressive/

JSR 292 introduces a new bytecode instruction invokedynamic but also several new kind of constant pool constants. Which means that most of the tools that parse bytecodes like ASM, BCEL, findbugs or EMMA will need to be updated to be java 7 compatible. EMMA is a code coverage tool, a tool that helps developers to know if their tests cover all the code of the application. While it's not the only code coverage tool available in Java, it's the most popular from my personal experience. In this blog entry, I would like to show how to write a simple code coverage tool indycov that use JSR 292 API to have a runtime overhead close to zero.

Sindi is lightweight IoC container for the Scala programming language. A new version was just released and a website is available with a User Guide and complete API documentation!

This page provides a Developer Preview of OpenJDK with Lambda (JSR 335) support. The Lambda project aims to support programming in a multicore environment by adding closures and related features to the Java language

HeapAudit is not a monitoring tool, but rather an engineering tool that collects actionable data – information sufficient for directly making code change improvements. It is created for the real world, applicable to live running production servers.

This small talk guides you through how you can adopt Spring framework as an application infrastructure and work it with ZK 6's new MVVM pattern to manage objects including ViewModel, validator etc.

There’s still a lot of confusion over the difference types of managed beans provided in Java EE 6 with EJBs, CDI beans and JSF managed beans all being available. This article aims to clear up some of the differences between the them and define when to use them.

Juzu is a web framework based on MVC principles and standardized dependency injection for JSR-286 based portals such as GateIn or Liferay. Juzu relies on the Annotation Processing Tools to extend the Java compiler in a portable manner. The 0.4.3 release brings the support for the HttpContent and SecurityContext API for obtaining such information from the request, multivalued parameter support has also been added for the controller, allowing a better support of multivalued request parameters. Other features are available such as a dev mode which allow to live develop the application.

The Apache JMeter [ http://jmeter.apache.org/index.html ] desktop application is open source software, a 100% pure Java application designed to load test functional behavior and measure performance. It was originally designed for testing Web Applications but has since expanded to other test functions. Apache JMeter may be used to test performance both on static and dynamic resources (files, Servlets, Perl scripts, Java Objects, Data Bases and Queries, FTP Servers and more). It can be used to simulate a heavy load on a server, network or object to test its strength or to analyze overall performance under different load types. You can use it to make a graphical analysis of performance or to test your server/script/object behavior under heavy concurrent load.

Here are some of the links that drew Java Code Geeks attention during the week that passed.

Let’s face it, there are two kinds of developers: those that favor Spring autowiring because it alleviates them from writing XML (even though you can do autowiring with XML) and those that see autowiring as something risky.

PrimeFaces is a lightweight open source component suite for Java Server Faces 2.0 featuring 100+ rich set of JSF components. Additional PrimeFaces Mobile module features a UI kit for developing mobile web applications. [ * ] demo http://www.primefaces.org/showcase/ui/home.jsf

The last time AppFuse had an update done to its look and feel was in way back in 2006. I've done a lot of consulting since then, which has included a fair bit of page speed optimization, HTML5 development and integrating smarter CSS. It was way back in '05 when we first started looking at adding a CSS Framework to AppFuse. It was Mike Stenhouse's CSS Framework that provided the inspiration and my CSS Framework Design Contest that provided its current themes (puzzlewithstyle, andreas01 and simplicity).

In the last few years Dependency Injection has has evolved from being an obscure and little understood term, to become part of every programmer’s toolchest. In this article we'll see how easy is to integrate Guice, a very handy library from Google, into a Play framework application. Moreover, we will also cover how to customize it’s behavior for a better development experience.

Interesting additional blog entry that shows the usage of plumbr a new and (currently) free runtime memory analysis tool.

A tutorial on how to authenticate and authorize users using Servlets/JSPs and Hibernate

Article describing the use of the new MongoDB Aggregation Framework for calculating chemical compound similarities

A proof of concept for cross compiling Scala to JavaScript http://www.j2js.com/scala-demo/index.html

Once published, Android applications—and their developers—face numerous threats to success in the real world. One Android developer advocate at Google recently referred to these pesky perpetrators as pirates (outright thieves) and vampires (those hangers-on sucking the life out of your product). A paid application might be stolen, illegally copied, and made available for download in alternative locations. A free application might be exploited, causing damage to a brand and leveraging valuable product resources like server bandwidth. All apps are vulnerable to hacking, resulting in rogue downloads with embedded malware, or using knowledge learned to hack a server or other underlying service. Unfortunately, this malicious behavior happens all the time. Protecting your applications is an ongoing battle, one that cannot ever truly be “won” because the opposition is constantly improving its nefarious methods of attack. You’ll never have a truly invulnerable app, but you can make your app a hard target. The good news is that, as Android developers, you have numerous ways to help protect your Android applications from exploitation. Today you will learn how to: Obfuscate your binary code using ProGuard Use the License Verification Library to verify Android Market purchased applications Protect your network communications with SSL

Shows how to use the Scala Cake pattern to compose functionality in a Spring Framework-based application