Enterprise grade Java.
You'll read about Conferences, Java User Groups, Java, Integration, Reactive, Microservices and other technologies.

Tuesday, December 24, 2013

Another year is nearly over...

09:26 Tuesday, December 24, 2013 Posted by Test No comments:
, ,
... and it is time to sit back and relax a bit. It has been exhausting for me on many levels and I tried not to leave any opportunity slip through. It is time to say thanks. I'm thankful for the many people seeing me sessions on conferences around the world. Thankful for the readers on this blog, for the feedback I receive on Twitter or even in person. Thankful for a steadily growing and strong Java community and even thankful for Oracle taking the steward job serious and not having burnt too many bridges this year.

There are plenty of things upcoming next year. All starts with the IOUC meeting in January, a great Jfokus conference in Stockholm in February, the JavaLand conference in March followed by the OUGN Vårseminar and the newly created DevNation conference in April. There are plenty of opportunities to meet and talk. I'm looking forward to this new year. And some silent days.
Wishing you a prosperous and happy new year

“We will open the book.
Its pages are blank.
We are going to put words on them ourselves.
The book is called Opportunity
and its first chapter is New Year's Day.”
― Edith Lovejoy Pierce

Monday, December 23, 2013

See me at DevNation, 13 - 17 April 2014, San Francisco, CA

13:24 Monday, December 23, 2013 Posted by Test No comments:
, ,
I'm pretty proud to announce that I'll be speaking at the new open source, polyglot conference for application developers and maintainers DevNation 2014. It will be co-located with Red Hat Summit and will offer sessions, labs, and panels geared for those who build with open source.

As of today the official call for papers starts. Now it's on you to join the early announced speakers among myself, Mike Milinkovich (Eclipse), Chris Aniszczyk (Twitter), Arun Gupta (Red Hat).

While there will not be formal tracks you can send in proposals among the following topics that will likely fit into overall vibe including:

  • Enterprise Application Development (e.g. concurrent, multi-user applications with data stores, security, transactions, etc)
  • Front-end Development (e.g. display technologies, client-side scripting and layout, templating engines)
  • Mobile Development (e.g. Android, iOS, Cordova, HTML5 for mobile)
  • Big Data (e.g. RDBMS and NoSQL, persistent storage and associated computational problems with large data stores)
  • Application Integration (Service-Oriented Architecture)
  • DevOps and Continuous Delivery (e.g. build and deployment environments, administration and management)
  • Performance and Tuning (e.g. Analysis and techniques to get the best out of your applications)
  • Platform Development (ie. C++ and *nix applications)
  • Cool Stuff (Any helpful bits you'd love to share with your peers)

You can hook up with this awesome new conference by joining the twitter discussion @DevNationConf or tweet with the official #DevNation14 tag and don't forget to check back with the conference website frequently for new announcements.

Open registration begins in January 2014. Come to hack, come to learn. Join the Nation.

Thursday, December 12, 2013

Project Avatar - What's in it for Java EE 8?

08:00 Thursday, December 12, 2013 Posted by Test No comments:
, ,
With Java EE 7 out the door since a while it is already time to start planning for the next revision of the platform which will most likely be called Java EE 8. Oracle set up a community survey with which they would like to get input from the community on the relative importance of some of the features they intend to add. First of all this should encourage the interested reader to participate and take the survey. One particular point in it is all about support for HTML 5 based, dynamic applications. While WebSocket and JSON Processing already made it into Java EE 7 there is another feature particularly in GlassFish and WebLogic (via Jersey) at the moment which has some potential to be standardized. The Server Sent Events (SSE). It already is part of the HTML5 spec and would be a very good candidate for standardization. But Oracle is thinking even further and is asking if there would be enough support and interest to actually standardize the use of JavaScript on  Java EE servers. When this kind of question started to appear at JavaOne 2012 it was basically referred to as Node.jar on Nashorn. Since this September we know the real name: Project Avatar.

Avatar At A Glance
Project Avatar provides a JavaScript services layer zeroed in on supporting REST, WebSockets and Server-Sent Events, and a rich client side framework that assumes very minor JavaScript knowledge. The services side is focused on building data services using JavaScript, while the optional client side is entirely focused on supporting HTML5 and TSA (Thin Server Architecture).

Project Avatar (Source: avatar.java.net)

Thin Server Architecture
With the introduction of HTML5, CSS3 and fast JavaScript engines, modern browsers have become a powerful platform. In the advent of the so called single-page application (SPA), also known as single-page interface (SPI) the design of modern user interfaces shifted away from server side generation to web applications or web sites that fits on a single web page with the goal of providing a more fluid user experience akin to a desktop application. An SPA moves logic from the server to the client. This results in the role of the web server evolving into a pure data API or web service. This architectural approach has been coined "Thin Server Architecture" to indicate that complexity moved from the server to the client while reducing overall system complexity.

What is really in Avatar?
But Avatar is far more than just a TSA approach. It basically consists of three parts. The foundation is build by the upcoming Java 8 and its included JavaScript implementation called Nashorn. On top of it is the Avatar Runtime including an additional compiler layer and a Servlet API based server. Those abstractions  enable it to be hosted on various runtimes. Avatar applications are comprised of either client side ‘views’, server side ‘services’ or both. Importantly, there is no inherent coupling between them which enables views to communicate with existing services and for services to be consumed by any type of client. An application ‘archive’ is deployed on the server and is compiled to generate JavaScript tailored to the application. Generated JavaScript for views handles data-binding with the DOM/UI as well as data-management to remote services and local storage. The Avatar archives are somewhat similar to Java EE web-archives. They consist of a WEB-INF folder, an avatar.properties file in the root and either a views directory and/or a service directory. Both file-system directories or .zip (.war) files are supported by Avatar.

All that is left on the Server - Services
A service extends either a REST, WebSocket or Push (SSE) abstraction and it's life-cycle is completely handled by the framework. Service implementations can leverage built-in Node modules as well as most third-party modules. Thanks to Nashorn's support for direct invocation of Java code you can also use most Java libraries directly.

The Client Side - Views
A view is the HTML required by the browser. It also contains custom 'data-' HTML extensions and simple JavaScript models. Those views get translated by a (server-side) compiler before sending the complete SPA HTML file including the custom generated JavaScript to the browser.

Putting it all together. A Simple Example.
Oracle provides a decent set of examples and documentation for Avatar which basically is enough to get you started. First thing to try it out yourself is a JDK 8 Early Access Build for your OS. At the time of writing I tried it with the latest Developer Preview b118. After installing you need to get the latest GlassFish Open Source Edition 4.0 server and unzip it into a suitable location. Make sure it runs with the installed JDK 8 by either putting <jdk8>/bin to your PATH environment variable or adding the following entry to the <gf4>/glassfish/config asenv.bat/conf

set AS_JAVA=<jdk8>

Now go ahead to download latest avatar-1.0-ea.zip and expand it to the <gf4>/glassfish/ directory. After that you need to set a AVATAR_HOME environment variable and point it to the <gf4> install directory. And make sure to add %AVATAR_HOME%\glassfish\bin to your PATH environment variable.
If all of that is done you can switch to your workspace folder and issue the following command to have Avatar creating a simple example app for you:

avatar new --example=hello

It creates a basic "hello" application which only consists of a view. It is a good place to start exploring and you can directly start your Glassfish instance afterwards and deploy the application as you would with every typical Java EE application:

asadmin start-domain
asadmin deploy hello

The "hello-example" app.
Pointing your browser to http://localhost:8080/hello will display the application. You can start editing the view located at <workspace>/hello/view/src/hello.html directly. While the server is running Avatar takes care of re-compiling it directly for the next request. This ensures a rapid development. This behavior is controlled by the "debug=true" property in the avatar.properties file and can be altered for productive systems. Further on, setting it to false causes all .js and .css files to be minimized before delivery.
At least if you first download and add the required YUI Compressor (jar download) to Avatar first. Due to license restrictions it hasn't been bundled. Simply put it into <gf4>/glassfish/modules/avatar-ext/lib. You might need to create that directory first.

Beside this very simple example without any service at all there are more complex ones available with the distribution at %AVATAR_HOME%/Project-Avatar-examples/. For convenience reasons there is a complete examples.ear available which can be directly deployed and tested. To access the samples simply prefix the example name with "demo-". So the "rest" example can be accessed via http://localhost:8080/demo-rest/.
TodoMVC - Example App with Avatar
You have to look out for different features to be showcased in the different examples. If you want to know how Avatar handles persistence you can exactly look into the rest example which uses a FileDataProvider to save the items. Another interesting example is the TodoMVC based app (http://localhost:8080/demo-todo/). It showcases a more complex view which also has been styled.

What is next?
As of today nobody knows what is going to happen with Avatar. The community feedback hasn't been tremendously loud or excited in general. I guess the reason for it is that nobody really knows what to do with it. The biggest drawback as of today is, that it only runs with GlassFish which will further limit adoption and community interest. Given the fact, that SSE isn't part of the Java EE specification it might make it even more difficult to port it to other app-server. Even if the license (GPL2 with Classpath Exception) should allow it. Back to the initial survey and the thought about specifying a server side JavaScript integration with Java EE, you know at least have a brief idea about what Oracle is talking if they are talking about Avatar. Go ahead and take that survey and tell them what you are thinking about having that kind of stuff in Java EE.

Meta: this post is part of the Java Advent Calendar and is licensed under the Creative Commons 3.0 Attribution license. If you like it, please spread the word by sharing, tweeting, FB, G+ and so on!

Wednesday, December 4, 2013

My vJUG Session: Don’t Be That Guy! Developer Security Awareness

17:09 Wednesday, December 4, 2013 Posted by Test No comments:
I've been invited to talk at the vJUG which is the newest JUG around. A virtual JUG reaching out to interested Java Developers over all time zones and locations. The  aim is to get the greatest minds and speakers of the Java industry giving talks and presentations for this community, in the form of webinars and JUG session streaming from JUG f2f meetups.

"Don't be that guy! Developer Security Awareness" by Markus Eisele
Was a session already scheduled for JavaOne this year. Due to scheduling conflicts I actually had to cancel it and I was pretty excited to finally be able to deliver it to the many who signed up for the session in SF. With 174 registered attendees I count this as a success.

The session was given via Google Hangout (Thanks Google!) and recorded to Youtube for you to re-watch.

The slides are on speakerdeck.com:
Thanks everybody for attending! It was a pleasure!

Tuesday, November 5, 2013

R.I.P. GlassFish - Thanks for all the fish.

06:59 Tuesday, November 5, 2013 Posted by Test No comments:
We've all heard it coming probably. Yesterday the official roadmap update for JavaEE and GlassFish was updated and published. And beginning with the title the whole post was basically about one thing: GlassFish Server as we know it today is deprecated from a full blown product to a toy product.

The Long Road from Sun to Oracle
GlassFish was something to worry about right from the start. After the merger it took some time to silence the voices which insisted on "Oracle killing GlassFish". Oracle did a decent job in nurturing the community and keeping their stuff together. I've written a couple of blogs myself helping to get the word out. The 100-day releases 2.1.2 and 3.0.1 have somehow become the milestone to prove the will to improve. And we all have been fine with it after a while. Even back in January 2013 I compiled a list of open source application servers and which one to pick. The final criteria was vendor support. That kicked WAS CE out of the game. As of yesterday it would also removed GlassFish. The two remaining alternatives burned down to one: Which is JBoss AS7 / WildFly.

Customers Need Support for their Servers
But come on, what is the issue here? Who wants support anyway? And Oracle obviously did not make enough money out of the commercial licenses otherwise they wouldn't have killed the offering at all. It might not be a very obvious reason but I can offer some kind of explanation. First of all if a vendor is not only developing an open source alternative but also has a commercial offering this leads to different things that will be taken care of implicitly:
- Changes/Bugs discovered by customers go into the oss release
- Changes need to have a decent quality. Developers knowing about the need to support their solutions will be (at least a bit) more careful implementing stuff.
- Developers knowing that their stuff is run under decent load think differently implementing it. The complete list of non-functional criteria changes with that move.
- Customers demand more frequent releases and security patches which also end up in the oss version.
- Customers have different requirements than people using free and open source servers. One prominent example is clustering. Which is rarely used among oss projects.

Another factor is driven by experience. I would never try to develop project on a completely different setting than the production setting is at. Even that both WLS and GF understand at least a bit of each others deployment descriptors there is a high risk buried in here that such a setting is the road to trouble.

The bottom line of my argumentation basically is, that the need for providing a commercial distribution improves the overall quality and reliability by changing some relevant non functional requirements for the product. If those aren't there and nobody is consequently taking care of them ... they will not be in there.

Why will Java EE suffer from a dead GlassFish?
The quality of the Java EE TCK has been questioned a lot. And in the past many people used GF as a showcase for not working code. On top of that some production scenarios and errors lead to different implementations and last but not least specifications. All the practical field knowledge has been in the heads of the team. I don't know how Oracle is running WLS development internally but I expect it do be different from what the team did for GF, probably a bit heavier. Extracting specification edge-cases and removing product specific parts from WLS based customer cases will for sure be trickier and not happen very frequently. So I expect the spec to be a little less Oracle driven and a little less mature generally. Not the worst part in the story. But given the fact that some very bright minds are working in that area I expect that their passion and knowledge will be missed a lot. And there is nobody there to catch them falling.

Which Parts of GlassFish will die?
So GlassFish will stay the reference implementation for upcoming Java EE standards. Oracle needs it to be around just for that one reason. With the emerging JCP which is becoming more and more open it isn't a big surprise that they are not simply going to define WLS as the RI. But that will be the cut between things that will die and things that will be around. I DON'T have any insights here and I'm just speculating and I could make an educated guess about the first comment on this blog but .. bottom line for me is, that everything that isn't covered by the Java EE spec is going to age very fast. This could include clustering and for sure some of the admin features and security also is a good candidate (PAM realm and others). And frankly I can't confirm any of them. It is pure speculation!

Is there a good part in that at all?
Well, yes: The move leaves a field wide open for strengthened competition. And this is not only WildFly but for sure also TomEE with tomitribe. Congratulations to them. Further on many customers will save a lot of license fees. GF and WLS are differently licensed and using WLS standard gives customers more options on picking the right license. And at least the WLS team will be strengthened with those people don't having to switch heads anymore working frequently on different products.

Can Oracle do something to make the killing worth it?
As of today it is a senseless death. Users can simply sit back and wait for the next minor release which probably will happen once a year. If you've been complaining about infrequent releases until today .. prepare for even less in the future. There are indeed a couple of things Oracle could do to make this a strategic move for everybody and not only themselves:
1) Develop and support a clear upgrade path. Find a way to at least support a development setting based on a very lightweight server and only deploy to a full blown WLS in production. With the given features and differences between the two this is hardly a working story as of today.
2) Make an attractive licensing offering for GF users. Not only to the customers as of today but for all. Or even better: Come up with a bunch of licensing terms in the OTN license which allows NPOs to use WLS free of charge.
3) Consequently open-source GF (under a decent license) and make community contributions attractive. The used infrastructure and OCA makes this impossible as of today. Move the server code (including modules) to GitHub and appoint a change manager who reviews and pulls in proposed fixes and changes. Let the community decide on releases.

The Echoes Are Gone In The Hall
Basically the news isn't a big surprise. We all understand the move. Having two servers instead of one is a double burden. With the BEA merger Oracle killed their own application server. Now it was GlassFish's turn. Oracle already tried to reduce the needed efforts to maintain it by merging the teams and also discussed different options along merging WLS to HK2 or extending the use of the same components for both servers. Some things happened and pushed the time for yesterdays announcement out by a couple of months but finally did not prevent it. So. R.I.P. GlassFish. It was nice. Thanks for all the fish.

Tuesday, October 29, 2013

JavaLand 2014 - CfP Statistics And Answers To Common Questions

06:06 Tuesday, October 29, 2013 Posted by Test No comments:
, ,
You probably have heard about the new upcoming Java centered conference in Germany next year. JavaLand 2014 will open its gates for two days. So make sure you are around when this new conference will become the hub of the German Java developer scene. I'm proudly part of the conference organizers and as a program chair I get plenty of help from the awesome program committee which was recruited out of the German JUG umbrella called iJUG.

With every new conference or thing to happen people start asking questions. Until the final schedule isn't published and the first conference is run, most of it is unanswered. But I like to give you a solid first set of impressions about the conference. The following charts and arts are generated based on the more than 400(!) paper submissions we got during the official CfP! It is intended to give you a first impression but will probably not completely reflect the finished conference schedule which will be out shortly (expected: mid November).

The Topics - An Overview
First of all I tweeted a Wordle about the submitted topics.
Basically a broad mix around Java. It is quite interesting to see, that there is quite a bit of Spring in there and JavaFX absolutely was among the big topics. It was good to see, that JVM based languages also got some love because this conference is intended to host different topics around the JVM as a runtime and as such give exposure to all the different JVM languages also. Enterprise and Mobile together with different DevOps topics are spread among the place. If you look carefully you see some German in it. As of today we don't know the ratio between German and English talks. But given the fact that we got a good number of international proposals I expect it to play a role. We basically don't focus on either one. As long as there is good content in it.

Proposed Talks from 18 Different Countries
Overall we got proposals from mostly Europe and the States. In total 18 different countries. Which is amazing! A big "Thank you!" to all the submitters!

What role does Oracle play?
Next big question is what role does Oracle play in all that. The conference is organized by German Oracle User Group (DOAG) and many suspect any (probably unfair) Oracle involvement. The only thing I can reply to it is: There isn't anything wrong going on here. Oracle actually IS supporting this conference along the lines they did before with the annual DOAG Conference and Exhibition. Given the fact, that the DOAG Conference will be hosting less and less Java over the next years Oracle was given the chance to submit talks. Like anybody else could. Additionally they host program committee meetings in their locations. Which was incredibly kind of them. That is great support for the German Java Community!
The overall ratio Oracle vs. Non-Oracle talks in the CfP was 6:94 ... Yes, only 6 out of 100 talks were proposed by Oracle employees. This is not a typical Oracle conference ratio. If you compare the numbers I published from last year's JavaOne the Oracle Speakers take up to 30%.

What will the content look like?
A great question. We don't know yet. The last PC meeting will happen shortly but what I can tell you is how the overall distribution looks like according to the submitted proposals:

Comparable evenly distributed. Except that we got too less security submissions. But at least some good ones. I expected to see more JVM languages talks but the feedback we're taking here is that we did a bad job communicating the focus correctly. We'll try to correct this. We're beginners here. Please be patient ;)

What about the Rest?
There is plenty of stuff upcoming. We are hosting a complete scheduled conference and plan on different community centered activities around it. We also will have some other surprises in stock. Announcements are pending but will follow shortly. Best is to follow @iJUGeV or @myfear on Twitter to stay up to date.

Can I book? Where? How? How much?
Sure you can. The registration is open since a couple of days already. Going for a registration until the 01/31/2014 you get the non-iJUG member price for €250/day. If you're an iJUG Member you get it for €200/day! Which both is nothing!
Find all the details on the registration page. I'm looking forward meeting you there! If you have additional questions feel free to ask! I'll try to answer!

Wednesday, October 23, 2013

New Article in German iX Magazine: CapeDwarf

13:03 Wednesday, October 23, 2013 Posted by Test No comments:
, , ,
Another article hit the road today. This time a comprehensive introduction to CapeDwarf which is Red Hat's Google App Engine implementation for AS 7. In German iX Magazine 11/2013.

CapeDwarf tries to bring Google's App Engine to JBoss AS7
Red Hat's CapeDwarf project tries to bring two well-established technologies together: Google App Engine and Red Hat's Java EE server AS 7. The aim of the project is to implement all the APIs that Google App Engine provides and make them available on the application server.

This is a German article and you can either grab the latest issue online or buy it at your favorite kiosk.

Find some other articles of mine by searching this blog for posts labeled "article" and you get some results.

Review: "TestNG Beginner's Guide" by Varun Menon

11:18 Wednesday, October 23, 2013 Posted by Test No comments:
, ,
Packt was so kind to send me another book to look at. I've always been curious about testing in general and I was looking for some good stuff to hand to co-workers or otherwise interested people to get started with TestNG.

Unit/Functional testing has now become part of every development life cycle. Junit was once the main framework that was used by developers for the purpose of Unit testing when it came to Java. But Junit had certain limitations in terms of execution and features. This book explains about the features and usage of TestNg, a new framework that overcomes Junit’s limitations and provides a lot of extra features.
TestNg Beginner’s Guide is a practical, hands-on guide that aims to increase your knowledge of TestNg. This step-by-step guide will help you to learn and understand the different TestNg features, and you will learn about the advantages and how to use and configure each feature according to your needs.

Book: TestNG Beginner's Guide
Language: English
Paperback: 276 pages [ 9.2 x 7.5 x 0.6 inches]
Release Date: July 26, 2013
ISBN-10: 1782166009
ISBN-13: 978-1782166009

About the Author
Varun Menon is a QA consultant with several years of experience in developing automation frameworks on various technologies and languages such as Java, JavaScript, Ruby, and Groovy. He has worked on web and mobile applications for some of the leading clients in the field of supply chain management, online photo books, video analytics, and market research.

The Content
Chapter one gives a brief introduction about testing and test automation. How to get started with TestNG, where to get it from and how to integrate it into your favorite IDE. Eclipse is used throughout the book. Chapter two deals with the basic configuration and introduces test suites and the command prompt usage. It also adds a couple of tests for packages, classes and methods. Chapter three is all about annotations. Setup and destroy, disabling tests and how to use parameterization. Test groups are introduced in chapter four followed by adding dependencies in chapter five. Chapter six and seven deal with the factory annotation and parallelism in tests. Chapter eight gives an overview about build tool integration covering Ant and Maven. Logging and reporting about test runs is covered in chapter nine. Programmatic test creation is covered in chapter ten. A basic migration scenario is covered in chapter 11. The closing chapter deals with the differences between unit and functional testing and explains additional concepts like JMock, Mockito and how to use Selenium.

Writing and Style
Generally the instructions are clear and the screen-shots are helpful. The overall level of detail and mixed in complexity is appropriate. Overall an easy read and well structured. Great for beginners and even developers familiar with the topic could still use it as a reference.

Conclusion and recommendation
The book is aimed at introducing developers to TestNG. It uses numerous screenshots and code listings to introduce core features. and only requires basic Java and probably JUnit knowledge. The book is aimed at Java developers who are unfamiliar with TestNG. If you're completely new to testing and TestNG in particular it is worth a read. One trade off is the very basic style of the examples. Additionally it does not tell you about why to use that feature or when to use another.

Wednesday, October 2, 2013

Travel Report: JavaOne 2013 - Back To Glory

09:26 Wednesday, October 2, 2013 Posted by Test No comments:
, ,
I'm back since a few days already and needed to catch up with all the things which had been on hold for the last couple of days. It was the busiest time of the year for me. A complete week of JavaOne and OpenWorld in San Francisco. A very brief travel report.

Annual ACED Briefing
Many of you know that I am part of Oracle's Community Recognition Program called the "ACE Program". I get asked a lot about it. Especially because it seems as if I am working closer with Java EE and Open Source than with the Oracle Products. But this is not necessarily true. Anyway, the ACEs get a once-a-year chance of personally talking to Product Management and learn about the upcoming things early. This includes many of the upcoming announcements at OOW and J1. The ACE Briefing usually happens the last two days of the week before the conferences start in SF. Because of the many different professions among the ACEs it covers a broad mix of topics scratching nearly every bit of the Oracle product portfolio, from Engineered Systems to Linux, the DB, Middleware and Java. If you want a recap on everything you'd better re-watch the keynotes held at OpenWorld. They are available on the media network in the meantime. For me personally the best part of the briefing is catching up with the peers from all over the world. Even if the group is growing year by year there are many familiar faces. After working with them throughout the year, a beer and a chat makes all that a bit more personal. Thank you Roland, Vikki, Lillian for making that possible. But it is not all fun and games. The Friday also held some Customer Advisory Board activities and other meetings. Reedwood is generally a perfect place to meet Oracle people in person and move stuck things around. Email isn't personal communication and this is even more true for foreigners like me. If there is one thing that makes traveling valuable it is exactly that. Gathering some intercultural knowledge and try to fix things that broke over email or other text based communications over the year. Friday evening it was time to move to the big city. San Francisco was waiting and the illustrious group moved into the Hilton on Union-Square. The place to be for the next few days. It also is the main hotel for JavaOne and I was surprised to not see much decoration in place already. To me it seemed as if this was different to last year. But, everything gets closer to just-in-time .. why not that part also.

JavaOne vs. OpenWorld - Balancing Worlds
My personal challenge is to balance activities between the two conferences happening. I want to catch up with Product Management but I'm also interested in meeting the peers in the Java space. Unlike the last years I decided to not spend to much energy on walking back and forth between the two conferences but basically stick around the JavaOne hotels. Given that my sessions and panels were more or less evenly distributed over the whole time I had preps to do every day and also wanted to see some talks. Being part of the JavaOne content committee actually helped getting in every session I liked without having to be enrolled for them. It feels good to see that the tremendous amount of work which goes into voting and commenting on proposals finally pays of and gets recognized. As Adam Bien put it: "the advisory board did a great job this year". Thank you Adam. I felt the same. An insane amount of sessions I would actually have enjoyed to listen too. The most interesting ones exactly parallel to my own sessions. The good news is, that all the sessions got recorded and will be available on Parleys in very short time. Another interesting observation was, that most of the PMs I would love to talk to showed up at JavaOne. There basically was no need to run around to catch everybody. They've been all around JavaOne also. Generally the days of the conference seems to be a never ending day with a packed schedule for everybody. Saying hello mostly is ok. Sitting down for a longer chat is a rare pleasure for many.

Meeting Peers - Names - Rock-stars - People.
But the sheer amount of names you ran into is astonishing. Personally I don't believe in Rock-Star-Hero kind of things. What I learned about the Java community is, that there are incredible intelligent individuals out there which do amazing things with the technology they love. I've only rarely meet someone who wouldn't want to chat with me at all or makes me feel like I am not worth talking to. Thankfully this is a big exception and everybody running around at JavaOne is like you and me. I ran into Arun, Peter, John, Geertjan, Alexander, Uwe, Venkat, Lincoln, Ray, Andrew.... All have been there. And they've been like you and me. Drinking beer, preparing sessions and chatting with  peers they've not met in a long time. That is what JavaOne actually is for.

Setting the Stage - The best one so far
The content was amazing. So many great topics presented by gifted speakers. Packed sessions and a keynote which came back to Moscone for the first time in years. No-one could any longer assume that Oracle isn't listening. It simply takes some time to turn big things around. But it is possible. And the community is driving that change by being interested, committed and providing their criticism and ideas for improvements.
JavaOne Keynote back in Moscone (Picture: B.Borges)
I'm proudly wearing my JavaOne t-shirt today. It was a great show. And the biggest news has been, that there aren't any. The Internet-Of-Things is driving a lot of the future and the alignment of the programming models across all platforms beginning with Java 8 are both things that are the essence from the presented strategy. After this incredible week it is hard to let the work takeover again. But that is what is next. Thanks to everybody who stopped by and said hello. Thanks for being part of that incredible event. For me it has been the best one so far and I'm looking forward to the next year.

Thursday, September 12, 2013

New Article in German Java Aktuell - Java EE 7

12:24 Thursday, September 12, 2013 Posted by Test No comments:
, ,
Once in a while I publish stuff. This one is for my German speaking and reading audience. Latest Java Aktuell isse, which is the mouth piece of German iJUG e.V. has published an article of mine about the new Java EE 7 release.

Mobile statt Cloud - Java EE 7
Java Aktuell 04/2013
[GER] Es hat nur wenig mehr als drei Jahre gedauert, um aus der „6“ eine „7“ zu machen. Gemeint ist die Versionsnummer der Java Enterprise Edition (EE). Ursprünglich war die siebte Ausgabe stark auf das Thema „Cloud“ ausgelegt. Die Pläne stellten sich erst spät als zu ambitioniert heraus. Somit enthält die am 16. April 2013 fertiggestellte Version nur punktuell grundlegend Neues und stellt eine konsequente Abrundung der bereits vorhandenen Funktionen dar. Am 12. Juni 2013 feierte Oracle das fertige Werk mit einem internationalen Launch-Event.

You can download the article free (PDF) of charge! Enjoy!

If you want to know more about it have a look at the website www.java-aktuell.de

Tuesday, September 10, 2013

Java Mission Control 5.2 is Finally Here! Welcome 7u40!

21:08 Tuesday, September 10, 2013 Posted by Test No comments:
, ,
It has been a while since we last heard of this fancy little thing called Mission Control. It came all the way from JRockit and was renamed to Java Mission Control. This is one of the parts which literally survived the convergence strategy between HotSpot and JRockit. With today's Java SE 7 Update 40 you can actually use it again.

Java Mission Control 5.2
The former JRockit Mission Control (JRMC) is now called Java Mission Control (JMC) and is a tools suite which includes tools to monitor, manage, profile, and eliminate memory leaks in your Java application without introducing the performance overhead normally associated with tools of this type. Up to today the 5.1 version was available within the Oracle HotSpot downloads which could only be received by paying customers from the Oracle Support Website. Todays release is the first release of Java Mission Control that is bundled with the Hotspot JDK! The convergence project between JRockit and Hotspot has reached critical mass. With the 7u40 release of the Hotspot JDK there is an equivalent amount of Flight Recorder information available from Hotspot. And having it finally makes sense. Beside hundreds of minor fixes and improvements the JMC Client is now build to run on Eclipse 3.8.2/4.2.2 and is also featuring a new JVM Browser with server-side subnotes. This makes tracking of running recordings and JVMs a lot easier.

Java Flight Recorder (JFR)
But the main and most important feature is the Flight Recorder. The Flight Recording feature work with events. Those events need to be produced by the underlying JVM. Hotspot has now reached event convergence with JRockit. That means that most useful information that was provided from JRockit is now also available from Hotspot. And because those are quite different JVMs; the information will in some cases be a bit different. The overall profiling overhead for your applications still stays at less than 2%. Usually much less. Which, considering the information you get, is next to nothing.

JFR with GlassFish 4
Lets get your hands dirty and try this with latest GlassFish. First change your glassfish4\glassfish\config\asenv.conf/.bat and add AS_JAVA=PATH/TO/JDK7u40 now start the domain and navigate to the JVM options. Or as an alternative open glassfish4\glassfish\domains\domain1\config\domain.xml and search for the relevant java-config tag and add the following two jvm-options:


Now restart the domain and look for the jdk1.7.0_40\bin\jmc and fire it up. If you're running on the same machine you should already see a list of available JVMs in the JVM Browser. If you expand the GlassFish node and double click the "MBean Server" node you get a nice overview over what is happening right now:

From there you can start a flight recording by right clicking the "Flight Recorder" node in the JVM Browser. Select the desired recording time and event settings (which now btw have a new template feature to pre select events :)) and click finish. After the desired timeframe the recording gets downloaded to JMC and you can look through the timeline and find bottlenecks.
A very small drawback is, that you can't run it with GlassFish 3. There is a know bug which got fixed for the 4.0 release about ordering of the jvm-options.
UPDATE 12/02/13: A coworker pointed me to a nice workaround documented in the originally mentioned bug. It's possible to set the required flags using debug-options and enable debug for the domain:
<java-config ... debug-enabled="true" debug-options="... -XX:+UnlockCommercialFeatures -XX:+FlightRecorder">

What is hot?
The best thing since sliced breed is, that you now have method profiling events! With the method profiling events you can find out where your application is spending the most time executing your Java code. This is, for instance, useful to optimize the application where the optimizations actually have an impact.

Further on you have an improved allocation profiling tab.You can now see per TLAB allocation with traces, and object being allocated directly in old space. That "new and improved" theme continues throughout the all tabs in the flight recorder. You get a File I/O, Socket I/O and many many more which provide plenty of insights.

Experimental Plugins
And the best part for me is that the team keep going with a bunch of experimental plugins. A new one was added called JOverflow - Heap dump analysis for memory waste. This plug-in allows Mission Control to do heap dump analysis, primarily to look for wasted heap space. There are several different anti-patterns JOverflow will look for, such as duplicate strings, underutilized collections etc. This plug-in also adds an action (for local connections) that will perform a heap dump and then visualize the heap dump with JOverflow. This is somehow a short term replacement for the Memleak Analyzer which you might know from JRMC. The D-Trace Plugins also got a major overhaul. You can find out more about it on Marcus Hirt's blog.

Download and Further Reading
You can grep the latest 7u40 download from the Oracle Technology Network Java SE Download Page. Java Mission control is already integrated and you're ready to run it.
If you need more information visit oracle.com/missioncontrol where you can find the links to the documentation and Eclipse update sites.

Friday, September 6, 2013

CapeDwarf - Google App Engine on Java EE

12:04 Friday, September 6, 2013 Posted by Test No comments:
, ,
I have many hobbyhorses. Coming all the way from the early Java EE specifications and having done the "cloud" excursion with Java EE 7 I was curious to see what newly announced CapeDwarf project has in stock to bring Google's Platform as a Service offering "Google App Engine" on premise.

The Story so Far
I did play around with App Engine. It was the first true PaaS offering for me back in the days. And I liked it. What I dislike is, that you have to check if GAE is playing nicely with your flavor of Java. A couple of days back end of June Google and Red Hat announced the official partnership working on the GAE TCK which sooner or later should bring the App Engine to Wildfly.

Installing and Configuring your Environment
Let's start right away. Get CapeDwarf and play around with it. In the core there is Wildfly or AS7 as most of us still know the JBoss Applicationsserver. CapeDwarf is only an extension module and needs to be build in. There are basically two ways of getting it: Grep the latest build from the downloads page which would be the Beta5 (released  2013-07-10) or build it on your own. I tried the last way first and it is supported by a very brief readme on the github project page but I wouldn't recommend doing this. It takes roughly 30 minutes (pure build time) because you also have to build the AS 7.2.0.Final yourself. If you get the zip distribution all you have to do is to unzip it and start the CapeDwarf enabled server via:

$JBOSS_HOME/bin/standalone.bat/.sh -c standalone-capedwarf.xml

This looks like an AS 7 start at first beside the fact that it is taking much longer because of the JGroups startup. At least on my machine. Anyway after that you have to add an admin user and log-in to the server console at http://localhost:9090/ and check if the extension is there by visitin the "Extensions" tab. Now you're all set.

Using the Guestbook Example Application
All left to do now is to fire up the IDE of choice (NetBeans in my case) and get a nice little demo project up and running. Lets stick to the guestbook example which also is part of the official gae-sdk. You should have Maven and Java 7 at hand already. The guestbook example is available as an official archetype and you can simply have it by using the following mvn command:

mvn archetype:generate -B
-DarchetypeArtifactId=guestbook-archetype -DarchetypeVersion=1.7.7
-DgroupId=net.eisele.demo -DartifactId=guestbook -Dversion=1.0 -Dpackage=net.eisele.demo

Everything you need in terms of dependencies is in central so you don't even have to configure another repository! Open the generated project right away and start to tweak some things. First you need to change the die appengine.target.version in the pom.xml to 1.8.3 Next thing is you need to add the relevant datastore indexes. As I understand it, GAE does this on it's own. CapeDwarf which relies on a couple of existing Red Hat technologies needs to be instructed to fire up the indexes. Add the datastore-indexes.xml to your src/main/webapp/WEB-INF/ folder with the following content:

<?xml version="1.0" encoding="utf-8"?>
<datastore-indexes autoGenerate="true">
    <datastore-index kind="Greeting" ancestor="true" source="manual">
        <property name="date" direction="asc"/>
If you add the <finalName>ROOT</finalName> attribute to the <build> section of the pom you're ready to go. Deploy the app via the management console or put it to the $JBOSS_HOME/standalone/deployments folder. There you go. Navigate to http://localhost:8080/ and watch the magic happen.

You could post greetings or even login with an email-address and leave personalized comments. And everything without changing a single line of code. You could even deploy the same piece of code to the App Engine. Further on, if you navigate to http://localhost:8080/_ah/admin/ you get a nice little admin console which gives you access to the underlying datastore.

Even Datanucleus plays nicely within this game and you could make the examples run by changing the javax.jdo.PersistenceManagerFactoryClass in the jdoconfig.xml to org.datanucleus.api.jdo.JDOPersistenceManagerFactory. If you now get the dependency versions right (jdo-api:3.0.1, datanucleus-core:3.1.5) and you use the right maven datanucleus plugin:

You're fine to go with that also. Give it a try. It is really easy.

Things to improve on for now
The implementation is limited at the moment. It seems as if the project team focuses on the official GAE-TCK. A majority of the APIs is completed and only nine out of 26 services aren't supported according to the CapeDwarf homepage. Given that I would have expected to see a little bit more documentation. For now this basically comes down to the official Google documentation. If you run into something special you're on your own. If you have questions regarding the TCK a newly formed Google Group covers them. Good new: The Project Lead Aleš Justin is responsive and helpful as I have experienced all Red Hat Java guys so far. If you are looking for examples there is a broad test coverage based on Arquillian in the CapeDwarf project. So this is a good place to start for now.

Google App Engine an Alternative to Java EE 8?
What is the bottom line? I would call the GAE infrastructure mature. Being launched in April 2008 and released to public late 2011 it had solid five years to grow to customer needs. Looking at the definitions from the cloud topic in early Java EE 7 specs and comparing them with what GAE already achieved is saddening. While EE has a very decent technical cut along application layers, GAE at least partly breaks this up into a service oriented way. While you see stuff like security spread nearly all over the place in SE/EE (JAAS, JASPIC, individual specs) GAE simply provides a Users API for User Management and an AppIdentity API for integration with other systems. Beside this it also provides APIs and abstractions for features that Java EE simply doesn't offer ready-made. I'm thinking about a Multitenancy API or something like the Capabilities API. If someone wanted to start lightweight on Google's PaaS in the past and tried to have a later migration to Java EE based on-premise hardware in mind he had to think carefully about mapping technologies and buying into Google specific services. As of today CapeDwarf already changed the rules significantly and lowered the vendor-lock risk.

If you look at the specification side it has it's drawbacks. Google is in charge. Exclusively. For now I don't see any advisory-board or comparable thing in place. So if Google decides to pull back (e.g. Reader disaster) many people would be stuck. The open TCK on the other hand at least makes the specification available free of charge to everybody (ASL2.0). And this is what basically made CapeDwarf and AppScale possible. For now this isn't the better Java EE at least for me. But given the fact that we are again looking into a cloudy future with Java EE 8 this could be a blueprint for new specifications which need to be done and also could be a nice guideline for something I would call "topic centric APIs". Taking care for the business needs and no longer only for the technology problems. This is going to be an interesting movement in the next few years and I am curious if some other vendors jump on that train sooner or later. And it is sad to see that Google pulled themselves out of the JCP and the active development inside the standards body.

Further Links and Readings
The Blog of the project lead http://in.relation.to/Bloggers/Ales
CapeDwarf on Github https://github.com/capedwarf/
CapeDwarf Downloads http://www.jboss.org/capedwarf/downloads
The App Engine TCK https://github.com/GoogleCloudPlatform/appengine-tck

Friday, August 30, 2013

Review: "Oracle WebLogic Server 12c - Advanced Administration Cookbook" by Dalton Iwazaki

07:32 Friday, August 30, 2013 Posted by Test No comments:
Another book crossed my desk. Following the latest hype around newly WebLogic Server release and Frank Munz's book there is another "recipe" driven administration book from Packt Publishing available. It was published in June this year and contains 60 advanced recipes to configure, troubleshoot and tune Oracle WebLogic Server.

Oracle WebLogic Server 12c Advanced Administration Cookbook guides you through over 60 recipes covering right from the basics of the WebLogic Server 12c installation to JDBC, JMS, cluster configuration, and tuning. This book covers the day-to-day tasks of a WebLogic administrator, and is enhanced with a lot of tips to build a WebLogic production environment focused on stability, high availability, and performance.

Book: Oracle WebLogic Server 12c - Advanced Administration Cookbook
Language: English
Paperback: 284 pages [9.2 x 7.5 x 0.6 inches]
Release Date: June 18, 2013
ISBN-10: 184968684X
ISBN-13: 978-1849686846

About the Author
Dalton Iwazaki (@xrcs) lives in Sao Paulo, Brazil and started working with technology in 1994 in a school lab, at the age of 17. In 1999 he started working with Java development and server-side applications. In 2008, Dalton started working in partnership with Oracle Consulting on the infrastructure level of the WebLogic Server. Working together with Oracle's clients and projects, Dalton's solid expertise in infrastructure and Java development are a rare combination used in his specializations. He has 19 years experience in Systems Administration, IT Infrastructure, Java Development, Systems Architecture and Troubleshooting.

The Content
I can't help but this books has something in common with Frank's book. One main difference is, that it is organized in chapters and does not only list the individual recipes but tries to order them a little bit more, which makes sense to me. In chapter one, installation and configuration is covered (11 recipes). Chapter two explains how to set up a WebLogic Cluster (9 recipes). In Chapter three you're guided through how to configure and tune JDBC resources focused on high availability (8 recipes). JMS configuration for clusters is covered in chapter four (11 recipes). Chapter five deals with monitoring and available tools (7 recipes). Followed by chapter six which covers some troubleshooting tips for common problems (8 recipes). Configuration for production environments with respect to resilience, stability, and performance is covered in chapter seven (9 recipes). And finally chapter eight dives into security configuration (5 recipes).
If I didn't count wrong this makes 68 recipes on 260 content pages. Compared with the 64 recipes of Frank's book this a bit more than half of his book. Every recipe Starts with a "Getting ready" preface which basically explains what is going to happen and what should be in place already. The "How to do it..." section gives a detailed, step-by-step explanation which is followed by the "How it works..." paragraph summarizing what exactly happened. The "There's more ..." and "See also" sections point you to related recipes or individual hints from the author.

Writing and Style
Another easy read. Thank you to the editors and the author for taking care of not native speakers. The step-by-step explanations make this easy to follow for beginners and occasional screenshots help with details. "Reading" from front to back surprisingly doesn't make lot of sense. It is more like a toolbox which solves your issues if you run into them. I did compare it with the "other" cookbook and reading this one wasn't equality surprising as Frank's book was. The main difference here is that it has word "Administration" in it's title. I guess it is clear that this is not primarily meant for developers. Even if it would be a good start for everyone which has to deal with WebLogic and really don't want to dive into administration too much.

Conclusion and recommendation
I like it. It covers all the basics and advanced topics I consider important for administrators but also for developers who need to understand the basic concepts and individual advanced topics like cluster configuration for production. I wasn't expecting a developer centered book which also added to this positive experience.

Wednesday, August 7, 2013

I'm speaking at DOAG Conference, 19-21 November 2013 in Nuremberg, Germany

06:36 Wednesday, August 7, 2013 Posted by Test No comments:
Another conference announcement. The annual conference of the German Oracle User Group DOAG is ready to accept registrations. The speaker confirmations have been send out and I am happy to say that I will be speaking about the Oracle Cloud Java Service on the 19th.

Oracle Cloud Java Service for Java EE Developer
19.11.2013, 15:00-15:45, Room 14 (schedule entry)
A brief introduction about the two basic services (Java and Database) and an overview about the development tools and online consoles. All brushed up and explained for Java EE devs to make their start into Oracle's cloud offering a breeze.

The DOAG conference and exhibition features 10 streams with more than 400 sessions and additional activities around all the Oracle ecosystem topics. A complete schedule is online and covers all three days.
This years Java Track is in room 20 and features a track keynote by Ed Burns about Portlet 3.0 and JSF 2.2. With 15 Java sessions this for sure isn't a plain Java conference but it was never intended to be one. So you find additional stuff over at the different Oracle technology centered tracks like Development or Middleware & SOA. Most of the sessions will be German but as every year there is a strong international presence of many big names from the Oracle ecosystem.

Follow the conference on twitter via the #DOAG2013 hashtag but if you can make it, there is plenty of time to register! Looking forward meeting you there!

Wednesday, July 31, 2013

Two TCKs for Eclipse - What is really in it for Open Source?

08:45 Wednesday, July 31, 2013 Posted by Test No comments:
, , ,
Back in May Oracle awarded a Compatibility Testing Scholarship to the Eclipse Foundation. This got some attention in media during the last days and I just wanted to make sure that I shine some light on the whole process and the action in detail. What does look like a simple and honest gift on first sight actually has more aspects in it. But lets start at the beginning:

Technology Compatibility Kit
Covered by the Java Community Process (JCP) both Java as a language and the various platforms on top (Java SE, Java EE, Java ME) are developed. Each JSR (Java Specification Request) includes an EG (Expert Group) a bunch of documents and of course a reference implementation (RI) and a corresponding TCK (Technology Compatibility Kit). The TCK can be executed against implementations and checks them for compliance with the specification. So it basically is the code equivalent of the specification document. Most TCKs consist of a bunch of test cases as well as a "test harness" which executes the tests. If there is a TCK per JSR it is safe to assume that there are at least as many TCKs available as we have active JSRs in the JCP. But that is only a theoretical thought. Practically there aren't. At least not publicly avaiable.  Besides JBatch, CDI and Bean Validation I can't think of much more. And those are only part of the Java EE platform which has at least 28 specifications. The majority of TCKs unfortunately is under lock and key at Oracle. But why? The main reason for this is that the TCKs are also used as a tools for the platform certification. Successfully running a TCK against an implementation proves it's correctness and with that somehow it's compliance.

What does platform certification actually mean?
The platform compatibility is an excellent advert for products. The Java EE compatibility list is a Who-is-Who of the Java EE server market. If you're not on that list with your product you basically don't have a chance of being recognized. With Apache Tomcat being the only known exception to that rule. But what does it take to get the certification? For Java EE there is the Java EE Compatibility Test Suite (CTS) which probably consists of little more than the sum of the individual TCKs. Honestly I have not seen it. You have to become a licensee of Oracle to get access to it. And this is exactly where it is starting to become expensive. I do not know how expensive exactly but once you payed you can access the CTS through the Java Partner Engineering web site. There is only one alternative way of getting hands on the CTS. Going through the Compatibility Testing Scholarship Program which is a way for non-profit organizations and individuals to apply for a free-of-charge CTS. The requests are judged by a review board. There is a PDF out there which explains how this process exactly works. Beside the ASF various other organizations and individuals gained access to individual TCKs and CTS as of today. Now that you know about the basic program and certification it is easier to look at the details for the two Eclipse projects that has been granted a CTS Scholarship. I need to preface the following with a little disclaimer. I only can draw my conclusions from what is publicly known. I don't have any insights or further information on the reasons behind. It might be much simpler than what I came up with ...

EclipseLink - the JPA Reference Implementation
According to press release from early May Oracle demonstrates its "commitment to Java developers and the open source community" by granting access to two TCKs and related support services to the Eclipse Foundation. Time to start wondering. Wasn't EclipseLink the RI for JPA? What exactly are they doing if not building the TCK for JPA themselves, right? Why do they need a license?
EclipseLink has its roots in TopLink. Anyone who knows the history of TopLink knows that this is a relatively old product that belonged to WebGain before it has been acquired by Oracle. WebGain was a strong Eclipse supporter and even a member on the  Board of Directors back in 2002. Only five years after its acquisition by Oracle TopLink was donated to the Eclipse Foundation and has been there ever since. EclipseLink is available under the EPL 1.0. The project itself does not contain the TCK. A difficult situation for a RI. Looking at the list of committers isn't really exciting. 30 people. And only one non-Oracle. Why do I believe that this team actually owns the TCK (Oracle internally) and even develops it? Strictly speaking, EclipseLink has a license that doesn't fit the TCK licensing rules. Granting the Scholarship license here simply corrects some legal issues in that constellation.

Virgo - the Java EE Web Profile Server
But for Virgo the granted license really makes a difference, right? Maybe. Virgo is the former Spring dm server which was donated to the Eclipse Foundation by SpringSource back in 2010. The list of committers paints a different picture than the TopLink list. It is not just SAP behind every name. Committers spread equally among three companies.  SAP, Pivotal and Tasktop Technologies. The latter has an interesting management board. Former SpringSource COO Neelan Choksi and Rod Johnson himself are members. This might indicate that Pivotal has a little more influence on the project than SAP. Anyway, both companies are most likely not big Oracle buddies. The scholarship license isn't a gift for them obviously. In fact, Virgo is already Java EE 6 certified. However, under another name. The SAP NetWeaver Cloud has built its Java EE 6 Web Profile offering on Virgo. So SAP has probably acquired a license from Oracle and certified Virgo themselves. I don't know for sure but someone could have come up with the idea that it is cheaper to use an already certified server instead of paying the annual royalties year by year. Given the fact that the Eclipse Foundation is a non-profit organization it was easy to apply for the Scholarship program to get this sorted. At least in this case there is a positive side-effect. Virgo now has the chance of becoming another Java EE certified server. SAP already has proven that it is possible. Sooner of later the community will earn the profit by probably having a new EE 7 certified OSS server.

But it is a positive sum below the line, right?
Two new projects gained access to the TCK of the specification they are implementing. That is positive. Looking at the total sum of publicly available TCKs it is still frustrating. Especially in the EclipseLink case it is frustrating because the TCKs may not at all be available in public. An elongated discussion on the JPA mailing list from last year discuss this problem a bit and illustrates the drawbacks. Although it is getting better with the changes made by the JSR-348. We're still not there. In fact I expect that the TCKs are available to all interested parties. This would improve quality of the specifications and the reference implementations by finding holes in the specs and also inadequately tested areas of RIs. Both will prevent many errors from affecting users. As key part of JSR 358 is the work done towards a new licensing model for TCKs. An accompanying Java.net project contains all the discussion materials and is publicly accessible. Everyone is free to join the discussion and express his or her opinion. The Observer mailing list is available to any registered java.net user. If you're interested in the view of CloudBees, Red Hat and IBM onto licensing issues you can find some more material on the presentations page. Oracle itself proposes to proceed with standard TCK licensing models in the future version of the JCP:
"TCKs for all future JSRs must be made available for certification and branding purposes under one or more of the Approved Open Source Licenses and / or a Standard Commercial TCK License. The TCK for all future non-umbrella JSRs must be made available to all Participants in the relevant RI open source project under a standard JCP Community TCK License. " (Source: Oracle's Proposal for JSR 358, PDF, pages 15 +16)
That would be a step in the right direction and would truly help the open source community. If the granted TCKs are a gift or not: It simply isn't enough to cure today's problems. We need a general change if it should be better in the future.

Monday, July 22, 2013

Island News - New German Java Blog

06:58 Monday, July 22, 2013 Posted by Test No comments:
, , ,
This blog has its fans and I am very thankful for them. But one little drawback always has been that I blog in English. And I like it the way it is. But as a German there is always the need to spread the word out to the German Java Community.
And in order to do this in my native language the idea was born to actually run a German blog. Naughty, isn't it? :) It probably wouldn't be an option to simply setup a translated version of this blog. Nobody would want that. Especially not me. But German publishing house Heise was so kind to offer me a nice place on their developer website. This is where I will be blogging about news from the Island of Java. In German. It will be a mix of technical and non-technical topics. Mostly like I try to do it here. So if you're interested in reading about my rumblings with Java and the latest news from the community in German: Head over there and please don't forget to give feedback. I love to hear about what you want to read.

Wednesday, July 10, 2013

1935 days of twitter

12:35 Wednesday, July 10, 2013 Posted by Test No comments:
, ,
Today I finally managed to download my Twitter archive. This nice new features was introduces a while back already but I never really cared about it. But looking back at 5 years, 3 months, 17 days is like doing forensics. And it is good to look back in time to remember what you did. Here is a high level overview about my twitter content since than as a nice little wordle art. I love it. Thanks for reading both my twitter stream and this blog. Looking forward to the next years to come.

Monday, July 8, 2013

Review: "Oracle WebLogic Server 12c - Distinctive Recipes" by Frank Munz

07:42 Monday, July 8, 2013 Posted by Test No comments:
, ,
It has been some time since I last read a book about WebLogic. Also the coverage here on the blog has been a little weak in the last few years. Both due to various reasons I can not really talk about. Anyway I still enjoy working with this server and I am always on the hunt for new books covering different aspects. Frank Munz published his "WLS Distinctive Recipes" book early this year and I was more than happy that he send a review copy to me to have a detailed look. Thanks Frank!

Imagine you need to know about a problem with your car's engine. You could plough through the 1000-page manual. Or you could chat to the mechanic over a cup of coffee.
That's WebLogic 12c Advanced Recipes. It's WebLogic for software architects, administrators and developers. For people like you who know quite a bit about WebLogic. What you don't want is the typical 'recipe book' full of screenshots. Click here. Click there. Do this. Do that. That's WebLogic by numbers.
What you really want are the things you won't find in the manual, like recommendations, discussions, best practices, deployable modules, NetBeans projects, more than 40 webcast videos and directions on when to use a feature - and when not to. With all this and more, this book is the perfect complement to official courses and manuals. In short, this gem of a book is almost as good as attending one of Frank's renowned workshops.

Book: Oracle WebLogic Server 12c: Distinctive Recipes
Language : English
Paperback : 450 pages [ 0.9 x 7.4 x 9.1 inches ]
Release Date : January 9, 2013
ISBN-10: 0980798019
ISBN-13: 978-0980798012

About the Author
Dr. Frank Munz (@frankmunz) is an expert in middleware and distributed computing. He earned a Ph.D. in computer science from the "Technische Universität München" for his work on distributed computing and medical imaging in brain research. He published more than 20 peer reviewed scientific papers.
In 2011 Frank received the Oracle Technologist of the Year award for cloud computing.
Frank has over 15 years experience working for and on behalf of top middleware vendors and consultancies such as ConSol, Sun, BEA, TIBCO and Oracle, throughout Europe and Australia as a software architect, project manager and developer. In 2007 Frank founded munz & more - a cutting-edge consultancy focusing on Oracle middleware and cloud computing. Based on over a decade of teaching experience with the big vendors, and its limitations, Frank is offering his own high-end training program world-wide now (Cloud Computing, Oracle Fusion Middleware, Oracle WebLogic Server Architecture, Operations and Development, Performance Tuning, Oracle Service Bus 11g).
He loves to talk about features and showstoppers and frequently speaks at conferences all over the world.
When Frank is not working, he enjoys travelling in Southeast Asia, skiing in the Alps, tapas in Spain, and scuba diving in Australia.

The Content
As the title suggests, the book features "recipes". 64 in total. If you remove the preface and the index you end up with 417 pages full of content which is a great value. The individual recipes are organized in four steps (Situation - Solution - Directions - More?). The situation describes the problem domain generally. The solution part gives a recommendation and dives a little deeper into it. The More? part finally points the reader to a bunch of links into the Oracle documentation, webcasts or even youtube for further information on the selected topic. The topics range from licensing to EJB covering SOA and individual products like JMeter, BadBoy and Grinder. So it is a colorful mix of WebLogic related topics without a true theme throughout the book. It would be good to follow the suggestion and use the individual recipes as you need them. Reading the book from front to back wouldn't make much sense at all. The length of the recipes highly depends on the covered topic. Clustering found it's place on eight pages which honestly isn't enough to describe the details but good for giving an overview together with some specific tips which require a deeper knowledge of the topic than the book provides.

Writing and Style
An easy read for me as a non-native speaker/reader. Common vocabulary from the WebLogic and Java EE domain and comparably short sentences which makes it easy to follow. You find a couple of screenshots and illustrations around which helps understanding the basics. The font is readable and plenty of space next to the heavy head- and sub-headlines makes it feel fluffy and light. As usual and recommended by the author himself I did not read every single recipe but picked a few that caught my attention.

Conclusion and recommendation
To make it short it is a great collection of various topics Enterprise Java developers tend to run into with a solid "More?" section for further details. The missing theme makes it hard for beginners to take advantage from it. The very basic overviews and brief outlines of the solutions makes it a questionable valuable for advanced WebLogic developers. This turns around if you try to put yourself into the admin domain. This book obviously hasn't been written to support developers on the first hand. It was probably meant for the guys doing WebLogic operations. Coming from this side of the pond much of the stuff starts making sense.

Friday, July 5, 2013

Running Awestruct with Asciidoc on Windows with JRuby

10:22 Friday, July 5, 2013 Posted by Test No comments:
, ,
This blogpost has been sitting on my todo-list since some time. I've seen one of my favorite FOSS advocates Dan Allen working on Awestruct and Aciidoctor it since some time and even some Arquillian guys jumped on the train. Time to find out what the hell it actually is and what it takes to get a decent setup up and running.

First let me briefly introduce what I understood about all the key parts of that awesome mix. The whole thing basically is about documentation. This is a wide area and has different flavors and processes. The most basic idea here is that writing documentation for developers should be a breeze. It should be text based and most likely not require any special IDE (like Word ;)).

Asciidoc? Asciidoctor? Documentation!
Starting with an easy way of writing and formatting directly leads to the introduction of Asciidoc which basically is a text document format for writing notes, documentation, articles, books, ebooks, slideshows, web pages, man pages and blogs. The initial AsciiDoc is both a piece of software and kind of a markup language. To run it you need Python. Not exactly a commonly used thing on my side of the universe. But another nice port has been around since some time now. It is called AsciiDoctor which is an open source Ruby processor for converting AsciiDoc markup into HTML 5, DocBook 4.5 and other formats. That brings us one step closer to the Java ecosystem. Asciidoctor is a bit more than simply the processor and some stylesheets. The project provides plugins for Maven, Gradle and Guard and packages for operating systems such as Fedora. You can learn about AsciiDoc from the User Guide. Asciidoctor also has a good bunch of docs online.

Other Markups - Ways to write without word.
There are other markup formats out there which do not require anything more than a solid text editor. Most relevant ones are Haml (HTML abstraction markup language), Markdown and probably also YAML. Basically you have a bunch of choices here. In addition to that you also find additional flavors like the GitHub Flavored Markdown. To make a long story the developer community has been fighting the need for heavyweight word processors since the very beginning and depending on the community you are in you are forced to use the one or the other.

Awestruct? Websites!
But documentation is basically nothing without publication. Most of the already mentioned processing approaches can publish a good bunch of different target formats. Stuff like  ebooks, slideshows, PDF, word, web pages, man pages and blogs and many many more. But given the context we're most likely in it is not exactly sexy to run a Perl based solution during the more or less completely Java based build phase. This is where Awestruct and Asciidoctor come in. Awestruct is a tool for creating non-trivial static HTML sites in an easy way. The core concept of Awestruct is that of structures, specifically Ruby `OpenStruct` structures. The struct aspect allows arbitrary, schema-less data to be associated with a specific page or the entire site. Site-specific data is automatically loaded from simple YAML files, while data can be provided on pages using a front-matter prolog. In one sentence: "It builds webseits from different markup and configurations" in an easy way. As the complete project and ecosystem of Ruby is mostly build around Linux/Unix based systems you hardly find any documentation about setting this up on Windows.

Lets get rolling - on Microsoft Windows
This blog is there to fix this. It is going to be a step-by-step guide and should help you getting your initial environment up.
First thing to do is to download JRuby. There are indeed native Ruby versions for Windows available but the package concept for third party libraries is mostly build to support native OS extensions. By using JRuby we take advantage of the Java Runtime as a machine adoption layer while still staying close to the Ruby ecosystem. You can download JRuby from http://jruby.org/download. You find different releases and packaging formats there. I picked the 1.7.4 Windows x64 executable and installed it into a top level folder on my hdd:\jruby-1.7.4. If you allow JRuby to set the PATH variable automatically pointing to your \bin folder you're all set. A prerequisite is that you have a JRE installed. If not, you're most likely (reading the wrong blog) willing to use one of the JRuby+JRE installers.
To make JRuby work with your already installed Java Version you should first check which version you're actually using by typing:
jruby -v
jruby 1.7.4 (1.9.3p392) 2013-05-16 2390d3b on Java HotSpot(TM) 64-Bit Server VM
1.7.0_25-b16 [Windows 7-amd64]
The result shows exactly which JRE version is in use. You can change it by pointing the environment variable JAVA_HOME to another path. Sitting behind a corporate proxy will require another environment variable:
set http_proxy=http://your.proxy.com:3128
Now you're almost set to actually install Awestruct. Installation is comparably easy. Find a command prompt and enter:
jruby -S gem install awestruct bundler

This will contact the packaging manager and download the required libraries. That is all for now. Next step is to create a new folder somewhere which should host your website project. Go ahead and create one (named "test2" during this guide) and change to this directory with your command-line. Now it is time to initialize your project from default by entering:
awestruct --init --framework bootstrap

It is safe to ignore the warnings for now. The command should come up with a directory structure as outlined on the awestruct website. I get a "Permission Denied" error on my system issuing this command. To me it seems as if it is safe to ignore also. I filed and issue about it. This gave you a basic layout with twitter-bootstrap support for your project. You also got a "Gemfile" in the root folder. Gemfiles are the bundler mechanism of fetching dependent libraries for a project. The initial version only contains the raw minimum which is needed to run a very basic setup. To execute awestruct with less warnings and noise you should add some additional dependencies. Un-comment the lines starting with by removing the "#":
gem 'coffee-script'
gem 'asciidoctor'
gem 'kramdown'
gem 'uglifier'
gem 'htmlcompressor'

You install the new bundles by issuing a:
bundle install
At the command line. This again fetches some additional libraries and puts them in your jruby-1.7.4\lib\ruby\gems\shared\gems folder for you to use. We're almost there. Now you can start the built-in awestruct server (WEBrick) with:
awestruct -d
This still puts a bunch of warnings out but you can already access your website at http://localhost:4242/ and you will see the awestruct-welcome page. Now we need to make some asciidoc files. Create a new file in your project root and name it hello.adoc with the following content:
= Hello, AsciiDoc!
Doc Writer <doc@example.com>

An introduction to http://asciidoc.org[AsciiDoc].

== First Section

* item 1
* item 2

puts "Hello, World!"

Running in "-d" development mode should in theory automatically regenerate pages. This actually did not work with my setup. Instead kill the running awestruct process and restart it does. Also using Rake works very well. Anyway the outcome is the same: navigating to http://localhost:4242/hello.html displays your nicely shiny new asciidoc based website. Congratulations. You're ready.

There is a lot to learn from now on. You can have a look at the awestruct website and find you way through the documentation. You can also have a look at one of the examples from the gallery. There are a couple of extensions which make this even more interesting. If I find the time I am going to dig into details in later posts.